What are the principles of Design Modeling?

Design models provide a concrete specification for the construction of the software. It represents the characteristics of the software that help the practitioners to construct it effectively. Design modeling represents the dummy model of the thing that is to be built. In software systems, the design model provides different views of the system.

A set of design principles when applied creates a design that exhibits both internal and external quality factors. A high quality design can be achieved.

- The work of analysis model is to describe the information domain of problem, user functions, analysis classes with methods. The work of design model is to translate information from analysis model into an architecture. The design model should be traceable to analysis model.
- A data design simplifies program flow, design and implementation of software components easier. It is as important as designing of processing functions.
- In design modeling, the interfaces should be designed properly. It will make integration much easier and increase efficiency.
- Design should always start considering the architecture of the system that is to be built.
- End user plays an important role in developing a software system. User Interface is the visible reflection of the software. User Interface should be in terms of the end-user.
- Component functionality should focus on one and only one function or sub-function.
- In design modeling, the coupling among components should be as low as is needed and reasonable.
- Design models should be able to give information developers, testers and people who will maintain the software. In other words, it should be easily understandable.
- Design models should be iterative in nature. With each iteration, the design should move towards simplicity.

What are the principles of Analysis Modeling?

Analysis models represent customer requirements. Design models provide a concrete specification for the construction of the software. In analysis models, software is depicted in three domains. These domains are information domain, functional domain and behavioral domain.
Analysis modeling focuses on three attributes of software: information to be processed, function to be delivered and behavior to be exhibited. There are set of principles which relate analysis methods :

- The data that flows in and out of the system and data stores collectively are called information domain. This information domain should be well understood and represented.
- The functions of the software effect the control over internal and external elements. These functions need to be well defined.
- The software is influenced with external environment. Software behaves in a certain manner. This behavior should be well defined.
- Partitioning is a key strategy in analysis modeling. Divide the models depicting information, function and behavior in a manner which uncovers detail in hierarchical way.
- Description of problem from end-user's perspective is the start point of analysis modeling. Task should move from essential information toward implementation detail.

What is software engineering practice? What are seven principles focussing on software engineering practice?

Practice is an array of concepts, principles, methods and tools that should be considered while software is planned and developed. The software process provides everyone involved in the creation of computer based system with a road map to reach the destination. Practice provides you with the detail that is needed to drive along the road. It helps you to understand the concepts and principles that must be understood and followed to drive safely and rapidly. Practice encompasses the technical activities that produce all work products that are defined by the software process model that has been chosen. Three elements of practice that are chosen are: concepts, principles and methods.

According to David Hooker, there are seven core principles that focus on software engineering practice:
- All the decisions should be made keeping in mind that one reason for the existence of a software system is to provide value to the all of its users.
- To have a more easily understood and maintained system, the design should be as simple as possible as one should keep in mind that software design is not a sloppy process. Keep in mind that simple does not mean 'quick and dirty'.
- For a software project to begin and end successfully, a clear vision is very necessary without which the software system weakens.
- The software system should be specified, designed and implemented in a manner that someone else will have to understand what you are doing.
- Software systems must be ready to adapt the changes in specifications and hardware platforms. One should not design the software system into a corner.
- The hardest goal while developing a software system is the ability to reuse it. Reuse can save time and effort. Forethought and planning is very important to realize reuse at entry level of the system development process.
- A clear, complete thought before action almost always produces better results.

Introduction to Crystal Agile Methodology and Agile Modeling

Crystal agile methodology is a software development approach. It is applicable for projects with small teams. It is a light weight approach. It is an adaptable approach. Crystal is a human powered methodology which means focus is on enhancing the work of the people. Crystal is ultra light which means it reduces the paper work, overhead involved. Crystal is stretch to fit methodology which means it grows just enough to get it to the right size. Crystal focuses on people and not processes.

Crystal consists of methodologies like Crystal Yellow, Crystal Orange, Crystal clear etc. It believes that project requires policies, practices and priorities as characteristics. Crystal methodology is based on the observation of various teams. Crystal methodology focuses on things that matter the most and make the most difference.

Agile Modeling suggests modeling is essential for all systems, but that the complexity, type, and size of the model must be in accordance with the software that is to be built. Some principles of agile methodology are:
- Agile Modeling is a practice based methodology.
- Values, principles and practices combine together for modeling.
- Agile Modeling is not a prescriptive process.
- Agile Modeling is not a complete software process.
- Agile Modeling focus on effective modeling and documentation.
- Developers using agile modeling should model with a purpose.
- Different models should be used to present different aspect and only those models should be kept that provide value.
- Traveling light is an appropriate approach for all software engineering work. Build only those models that provide value - no more, no less.
- During modeling, content is more important than representation.
- Be aware of the models and tools that are used to create them.
- The modeling approach should be able to adapt to the needs of agile team.

Agile modeling becomes difficult to implement in large teams, lack of modeling skills or team members are not co-located.

What is Adaptive Software Development (ASD)? What are three phases of ASD?

Adpative Software Development (ASD) is a method for the creation and development of software systems. It focuses on rapid creation and evolution of software systems. ASD is a pat of rapid application development.

Adaptive software development life cycle is mission focused, feature based, iterative, time-boxed, risk driven, and change tolerant. In adaptive software development, the developer has a basic idea in mind and they g to work. The focus is in the computer code.

In ASD, there are no pre-planned steps. The software is made very quickly. New versions can come out very quickly as the development cycle is very short. The structure of adpative software development and rapid application development are similar, difference lies in the fact that:
- adaptive software development does not allow the time when the project is finished, rapid application development does.
- adaptive software development does not have a real end point whereas rapid applicatio development allows the end of project.

Adaptive Software Development life cycle comprises of three phases:
- Speculation
- Collaboration
- Learning

In speculation, user requirements are understood and an adaptive cycle planning is conducted. It depends on bug and user reports.
Effective collaboration with customer is very important. Communication, teamwork, individual creativity are a part of effective collaboration. The individual developers combine their portions of work.
Learning cycles are based on the short iterations with design, build and testing. ASD teams can learn through focus groups, formal technical reviews and postmortems.

What is Extreme Programming? What are the principles and key activities of Extreme Programming?

Extreme Programming aims at improving the quality of the software. The key elements of extreme programming include code reviews, unit testing, code simplicity, changes in customer's requirements, frequent communication with customers and programmers.

The basic principles of Extreme Programming are quality work, incremental change, embracing change, simplicity and rapid feedback. There are few principles that are less central. These include teach learning, small investment, open communication, local adaptation. Extreme Programming is an efficient, flexible, light weight, predictable, low risk way to develop a software.

Extreme Programming (XP) promises to improve responsiveness to changes in business requirements, reduces project risks and improves the productivity. Extreme Programming (XP) is a set of rules and practices which occurs within the four
framework activities:

- Planning
Planning includes creating user stories, assigning value to the story based on overall business value of the feature. Cost is assigned after assessing each story. The XP team and customers work together to decide how to group stories for next release and an acceptance test criteria is build.

- Design
Extreme Programming design follows "keep it simple" principle. Design provides implementation guidance for a story as it is written. Extreme Programming encourages use of CRC(Class Responsibility Collaborator) cards identify and organize object oriented classes relevant to current software increment. Extreme Programming encourages re-factoring also.

- Coding
Unit tests should be developed, the developer is able to focus on what must be implemented to pass unit test. Extreme Programming development cycle involves pair of programmers that program together and the development is driven by tests. Pairs also evolve the design of the system. As pair programmers complete their work, the code developed by them is integrated with the work of others. Development is followed by integration.

- Testing
The unit tests are organized into universal testing suite, integration and validation testing can occur on daily basis. Extreme programming acceptance tests are specified by customers and focus on overall features and functionality of the system that are visible to the customer.

What is the Incremental Model in Software Engineering? What are its advantages and disadvantages?

When the elements of waterfall model are applied in iterative manner, the result is the Incremental Model. In this, the product is designed, implemented, integrated and tested as incremental builds. This model is more applicable where software requirements are well defined and basic software functionality is required early.

In incremental model, a series of releases called 'increments' are delivered that provide more functionality progressively for customer as each increment is delivered.
The first increment is known as core product. This core product is used by customers and a plan is developed for next increment and modifications are made to meet the needs of the customer. The process is repeated.

ADVANTAGES OF INCREMENTAL MODEL IN SOFTWARE ENGINEERING

- It generates working software quickly and early during the software life cycle.
- Flexibility is more and less costly.
- Testing and debugging becomes easier during a smaller iteration.
- Risk can be managed more easily because they can be identified easily during iteration.
- Early increments can be implemented with fewer people.

DISADVANTAGES OF INCREMENTAL MODEL IN SOFTWARE ENGINEERING

- Each phase of an iteration is rigid and do not overlap each other.
- Problems may arise pertaining to system architecture because not all requirements are gathered up front for the entire software life cycle.