Docstoc

Modeling Software

Document Sample
Modeling Software Powered By Docstoc
					b. Evolutionary Software Process Models


Is an iterative / contain looping. The result of the process of product that more and more
complete until the most complete version produced as a final product of the process. Two
models in evolutionary software process model are:

1. Incremental Model

rona3

Description:
1. Combine elemet-element from the waterfall to the nature of iteration / looping.
2. Element-element in the waterfall is done with the results of a product with certain
specifications, then the process starts from the first phase until the end and produce products
with a more complete specification than the previous. And so on until all the specifications
meet the requirements set by the user.
3. Product results of the first increment is usually the core product (core product), ie products
that meet basic needs. These products are used by the user or undergoing review / checking
of details. The result of the review into provision for development on the next increment.
This continues to be done until a complete product is produced.
4. This model is suitable if the number of members of the team of developers / builders of the
Old Testament is not enough.
5. Able to accommodate changes flexibly.
6. Products produced in the first increment is not a prototype, but the product is working
correctly with the basic specification.

Problems with Incremental model:

1. Suitable for small projects (no more than 200,000 lines of coding)

2. There may be difficulty to map user needs into a plan specifications of each product
increment

2. Spiral model

rona4

The process is described as a spiral. Each loop represents one phase of the software process.
Innermost loop focuses on the feasibility of the system, the next loop of the definition of
needs, the next loop associated with system design and so on. Each loop is divided into
several sectors:

 1. Objective settings (setting goals): determine the destination of the specified phase.
Restrictions on the process and the product is known. Planning was prepared. The risk of the
project is known. Alternative strategies have been prepared based on known risks, and
already planned.
  2. Risk assessment and reduction (treatment and risk reduction): each risk is analyzed in
detail in this sector. Handling steps performed, for example, create a prototype to determine
the incompatibility needs.
  3. Development and Validation (Development and testing): After evaluation of the risk,
then the selected system development model. For example, if the risk of the user interface is
dominant, then create a prototype user interface. If the security problem, then use a formal
model with mathematical calculations, and if the problem is the waterfall model of systems
integration is more appropriate.
  4. Planning: Projects are evaluated or reviewed and decided to continue into the next phase
of the loop or not. If you continue to the next phase of the plan for the next loop.

The division is not sector could be developed as in the distribution sector, following the spiral
model variations below:

rona5

• Customer communication: establish good communication with users / customers.

• Planning: defining sesumber, deadline, other information about the project

• Risk analysis: identification of risk management and technical

• Engineering: construction of examples of applications, such as prototype

• Construction and release: development, test, install and support.

• Customer evaluations: getting feedback from users beradasarkan OT evaluation in phase
engineering and installation phases.

In the spiral model, the risk is considered. Risk is something that might lead to errors. Spiral
model is a realistic approach to large-scale software. Users and developers can understand
well the software built for any progress made during the process can be well observed.
However, a long time may not be the choice for users, because of time equal to the cost
greater.

c. Formal Transformation

This method is based on a mathematical transformation specification through different
representations to an executable program. Using the program transformation approach to the
specification states 'cleanroom' for the development of PL.
rona6

This method has limitations in its use. The benefit is reducing the number of errors on the
system so that its main use is in a critical system. It becomes cost effective.

The use of formal development model requires a level of secrecy before use.
Problems in the model development of formal methods:

• Requires special expertise and training to apply it
• Difficult to determine some aspects of a system such as
user interface

c. Development Using the Concept of Re-use (Use Repeat)
This method is based on systems that have been incorporated from a number of existing
components or systems COTS (Commercial-off-the-shelf)

Step-by-step process:

• Analysis of components

• Requirements change

• System design with reuse


• Development and Development and incorporation


This approach is important but still have limitations in their use
rona7

Application RAPID DEVELOPMENT MODEL

Rapin Application Development (RAD) is a model of a linear sequential software
development process that emphasizes an extremely short development cycles. Model RAD is
an adaptation of "high speed" of the linear sequential model in which rapid development is
achieved by using component-based construction approach. If your needs are well
understood, the RAD process enables a development team to create "a complete functional
system" within a very short period of time (approximately 60 to 90 days). Because the system
is mainly used in construction applications, the RAD approach encompasses the phase -
phase as follows:

 1. Bussiness modeling
The flow of information between functions - business functions is modeled in a way to
answer the question - the question follows: what information to control the business
processes? What information is on the come up? Who memunculkanya? Where does this
information go? Who processed it?

 1. Data modeling


Information flow is defined as part of the modeling bussiness phase was filtered into a series
of data objects needed to sustain the business. Characteristics (called attributes) of each
object are identified and relationships between objects - the object is defined.

 1. Process modeling


The flow of information that is defined in the data modeling phase
transformed to achieve the information flow necessary for the implementation of a business
function. The picture processing was created to add, modify, delete, or retrieve a data object.

 1. Application generation


RAD assumes the use of fourth generation techniques. In addition
create software using third-generation programming language that conventional, RAD
process more work to another memkai existing program components (when possible) or
create components that can be used again (if necessary). In all cases, the equipment -
automated tools used to facilitate the construction of software.

 1. Testing and turnover

Because the RAD process emphasizes the use of return, many
program components have been tested. This reduces overall testing time. But the new
components have been tested and all interfaces must be fully trained.

rona8

Lack of RAD model is:

  1. For large projects but the scale, RAD requires sufficient human resources to create a
good number of RAD teams.
  2. RAD demand and customer development commitment in the rapid-fire activities required
to complete a system, within the time frame is shortened. If this commitment does not exist,
RAD projects will fail.

Prototyping Model
rona9

Sometimes clients just give some general needs of the software without detailed input,
process or detailed output. Other times may be where the team builders (developers) not sure
about the efficiency of the algorithm used, the level of adaptation to the operating system or
user interface design of form. When this situation occurs very helpful model prototyping
software development process.

The process of prototyping model depicted in Figure 1, can be explained as follows:

   * The collection needs: developers and clients to meet and determine common goals, needs
known and picture the parts that will be needed next. Detailed requirements may not be
discussed here, at the beginning of the collection needs.
   * Design: designing done quickly and the design represents all aspects of software that is
known, and this design is the basis for the manufacture of prototypes.
   * Evaluation of prototype: prototype to evaluate clients who made and used to clarify the
need for software.


The third iteration of this process continues until all needs are met. Prototype-prototype made
to satisfy clients' needs and to understand client needs better. Prototype created can be reused
to build software more quickly, but not all the prototype can be utilized. Although the
prototype facilitate communication between developers and clients, making client get an idea
of the beginning of the prototype, helping to get the detailed needs better yet prototypes also
cause problems:

1. In making the prototype of many things that are ignored, such as efficiency, quality, ease
of maintained / developed, and compatibility with the actual environment. If clients feel
comfortable with the prototype are presented and insisted on the product, then the developers
should work hard to bring these products to be better, according to the quality it should be.

2. Developers usually make a compromise in some respects because they have to make a
prototype in a short time. Maybe the operating system that is not appropriate, a different
programming language, or a simpler algorithm.
In order for this model can work well, need to be agreed jointly by the client and the
developer that built a prototype tool for defining software requirements.

Component-based Development Model

Component-based development is closely linked with object-oriented technology. In object-
oriented programming, many classes that are built and becomes the components in a
software. These classes are reusable means it can be reused. This model is iterative or
repeated process.

In general, the process that occurs in this model are:

  1. Identification of classes that will be used again by testing the class with the data to be
manipulated by applications / software and new algorithms
  2. Class created in the previous project stored in a class library, so that it can directly be
taken from existing libraries. If you find that there is need for new classes, then the newly
created class with object-oriented method.
  3. Build software with classes that are defined or created a new class, integrate.

Reuse of existing software components benefit from:

a cycle time of software development, because it can reduce the time 70%

b The production cost is reduced to 84% reduced component development arena
Software development using components already available to use COTS components
(Commercial off-the-shelf) - which can be obtained by buying or components that have been
previously constructed internally. Component-Based Software Engineering (CBSE) is a
process that emphasizes the design and software development by using existing software
components. CBSE consists of two parts that occur in parallel, namely software engineering
(component-based development) and engineering domain as illustrated in Figure 2:

  1. Domain engineering creates the domain model for the application to be used to analyze
the needs of users. Identification, development, clustering and allocation software
components that can be used in existing systems and future.
  2. Software engineering (component-based development) conducted an analysis of a
predefined domain model then determines the specifications and design based on the model
structure and specification of the system, then perform software development using
components that have been defined based on the analysis and resulting design before
eventually produce software.

rona10

Extreme Programming (XP) model

This process model was created and developed by Kent Beck. This model is the latest model
in the world of process engineering software and try to answer the difficulty in developing
software is complicated and difficult in implementation.
According to Kent Beck XP is: "A lightweight, efficient, low-risk, flexible, predictable,
scientific and fun way to develop software". A model that emphasizes:

- Direct user involvement
- Testing

- Pay-as-you-go design

The four critical values of XP

  1. Communication / Communication: communication between developers and clients is
often a problem. Because of that communication in XP is built by doing programming in
pairs (pair programming). Developer accompanied by other clients do coding and unit testing
so that the client can be directly involved in programming while communicating with the
developer. Also jugadiperhitungkan workload estimates.
  2. Simplicity / Simple: Emphasis on simplicity in the encoding: "What is the simplest thing
That Could possibly work?" Better to do something simple and develop it tomorrow if
necessary. Facilitate more communication, and simple design reduces the explanation.
  3. Feedback / Input / Feedback: Any feed back responded by conducting tests, unit tests or
system integration and do not be put off because the costs will swell (money, manpower,
time).
  4. Courage / Courage: A lot of new ideas and dared to try, dare to do back and every time
an error is found, immediately repaired.

Reference:

 1. http://www.benpinter.net/index.php?topic=SoftwareDevelopment
 2. http://romisatriawahono.net/
 3. http://university.romisatriawahono.net/