Agile modeling is one of the most
trusted development methodologies when it comes to producing an effective
documentation and software system. If described at a high level, it comprises
of all the best practices, best principles and values required for modeling a
high quality software product (this description may seem a bit hyperbolic, but it tends to be true for the most part). These practices are lightweight in
implementation, with a lot of flexibility. Although, Agile Modeling is a set of principles and therefore on its own, it is of no use. It has to be mixed with other fuller technologies such as rational
unified process, extreme programming, and adaptive software development, scrum
and so on. This process enables us to develop software that satisfies all of our
requirements. Agile modeling is governed by the following values. Some of these
values are extended from extreme programming:
- Communication: All the
stakeholders should maintain an effective communication between them.
- Simplicity: Developers should
strive to develop the simplest solution possible meeting all the requirements.
- Humility: As a programmer, you
should have a sense of humility that you may not know everything and you should
allow others to add value to your ideas.
- Feedback: There should be a
mechanism for obtaining feedback early in every stage of development.
- Courage: You should have
courage to make decisions and stay firm.
The principles on which the Agile
Modeling is based are defined by the agile manifesto. Two of these principles
are to assume simplicity and embrace changes. Assuming simplicity makes it easy
to design software. You are able to cut out unnecessary secondary requirements
and focus on the primary needs, thereby reducing the complexity. When you
embrace the fact that there will be changes in the requirements, it adds
flexibility to your project. As a result, you can develop more flexible projects that can adapt
to the changes in requirements, and other changes, over time.
The software evolves in increments. You should know
that it is this incremental behavior that maintains agility of the system. The
requirements are ever changing and so there should be rapid feedback mechanism
in place through which early feedback can be obtained. With this early feedback
it becomes easy for you to ensure that your system is fulfilling all the needs.
The modeling should be done with a purpose i.e., if you don’t understand the purpose
of your project, its audience or its environment you should avoid working on it
unless you are pretty confident.
It is always wise to have a contingency plan.
Therefore, it’s good to have multiple models on standby. There can be a situation
in which your primary model might fail, the standby models will provide a back
up. One thing worth noting is that agile models are not just mere documentation;
they are light weight realizations of your system’s purpose. Once the purpose
is fulfilled, the models are discarded.
One belief of agile developers is that
representation is less important than the content. It is the content that
matters. Also there are a number of ways in which the same content can be
represented. Focus should be maintained on quality work because sloppy work is
not valued anywhere. Also adapting to the principles of agile modeling for
meeting the environment needs is important. Modeling in an agile manner
requires practice. Agile modeling can be applied through various practices. You
have to pick the most appropriate one for your project. However there are few
fundamental practices that are always important for success of an agile model:
> Parallel creation of several
models.
> Application of the right
software artifacts depending up on the situation.
> Moving forward through
continuous iteration.
One word of caution though!
These models are just an abstract representation of the actual systems and
therefore cannot be accurate.
No comments:
Post a Comment