DESIGN OF OBJECT ORIENTED APPLICATION
INTERODUCTION:
Creating a blueprint or plan for the behaviour and structure of the software system is a necessary step in the design of an object-oriented application. This procedure makes ensuring the application is scalable, modular, and maintainable. To develop an object-oriented programme, remember to take the following important phases and factors into account:
Identify needs: Start with comprehending the objectives and needs of the application. To do this, one must collect both functional and non-functional requirements, comprehend the issue domain, and pinpoint user requirements. The design process is aided by the objectives being well defined.
Determine the major Objects and Classes: Decide which classes and objects will be the major components of the programme. Classes specify the guidelines for producing objects, while objects reflect actual things in the real world. Determine these things' characteristics (information) and behaviours (behaviours) by examining the connections and interactions between them.
DEFINE THE CLASS RELATIONSHIPS:
Establish the connections between classes, such as those caused by association, composition, and inheritance. Subclasses can be created that take on traits and behaviours from a superclass thanks to inheritance. Creating objects that contain other objects and form a part-whole relationship is known as composition. An association shows a connection between two or more things.
Use Design Patterns: Design patterns offer tried-and-true answers to typical design issues. To solve certain design problems and encourage code reuse and maintainability, use the right design patterns, such as Factory, Singleton, Observer, or MVC (Model-View-Controller).
Data and behaviour encapsulation: Encapsulation is a cornerstone of object-oriented design. It entails grouping information and associated behaviour into a class and just exposing the interfaces required for interacting with the object. Encapsulation improves data integrity, information concealment, and modularity.
First Principles
The process of developing a project covers some first principles— those traits that tend to
characterize successful projects.
1.Traits of Successful Projects
A successful software project is one in which the deliverables satisfy and possibly exceed the
customer’s expectations, the development occurred in a timely and economical fashion, and the result
is resilient to change and adaptation. By this measure, we have observed several traits1 that are
common to virtually all of the successful object-oriented systems we have encountered and noticeably
absent from the ones that we count as failures:
Existence of a strong architectural vision
Application of a well-managed iterative and incremental development lifecycle
1. Strong Architectural Vision
A strong architectural vision is something that is common to virtually all of the successful
object-oriented systems we have encountered. So, what is architecture? The IEEE Recommended
Practice for Architectural Description of Software Intensive Systems defines architecture as the
―fundamental organization of a system embodied in its components, their relationships to each other,
and to the environment, and the principles guiding its design and evolution‖. There are numerous
other definitions for architecture in use
today, but most definitions indicate that architecture is concerned with both structure and behaviour,
is concerned.
A system that has a sound architecture is one that has conceptual integrity, and as Brooks
firmly states, ―conceptual integrity is the most important consideration in system design‖. In some
ways, the architecture of a system is largely irrelevant to its end users. However, having a ―clean
internal structure‖ is essential to constructing a system that is understandable, can be extended and
reorganized, and is maintainable and testable. It is only through having a clear sense of a system’s
architecture that it becomes possible to discover common abstractions and mechanisms.
Good software architectures tend to have several attributes in common
1. They are constructed in well-defined layers of abstraction, each layer representing a coherent
abstraction, provided through a well-defined and controlled interface, and built on equally
well-defined and controlled facilities at lower levels of abstraction.
2. There is a clear separation of concerns between the interface and implementation of each
layer, making it possible to change the implementation of a layer without violating the
assumptions made by its clients.
3. The architecture is simple: Common behaviour is achieved through common abstractions and
common mechanisms.
Architectures constructed in this way tend to be less complex and more robust and resilient. They also
enable more effective reuse.
2. Iterative and Incremental Lifecycle
Iterative and incremental development is where the functionality of the system is developed in
a successive series of releases (iterative) of increasing completeness (incremental). A release may be
external (available to the customer) or internal (not available to the customer). The selection of what
functionality is developed in each iteration is driven by the mitigation of project risks, with the most
critical risks being addressed first. The experience and results gained as a result of one iteration are
applied to the next iteration. With each iteration, you gradually refine your strategic and tactical
decisions, ultimately converging on a solution that meets the end user’s real (and usually unstated)
requirements and yet is simple, reliable, and adaptable.
The following are some advantages of an iterative development approach.
1. Requirements changes are accommodated. Each iteration focuses on a specific set of
requirements.
2. There is no ―big bang‖ integration effort at the end of the project. Each iteration involves the
integration of the elements included in the release. Integration is progressive and continual.
3. Risks are addressed early. Early iterations mitigate key risks and allow for the identification of
new risks earlier in the lifecycle, when they are more easily addressed.
4. Tactical changes to the product are possible. Changes can be made to the product and/or early
releases of the product are possible in order to counter a competitor’s move.
5. Reuse is facilitated. Key components of the architecture are actually built early, so the
identification of reusable elements, as well as the opportunity to reuse existing elements, is
easier.
6. Defects can be found earlier and corrected. Testing is performed during every iteration, so
defects can be found early and corrected in subsequent iterations instead of being found at the
end of the project, when there may not be time to fix them (or the impact of fixing the defects
is too big).
7. Project personnel are employed more effectively. Iterative development encourages a model
in which team members play multiple roles during iteration, as opposed to a pipeline
organization in which analysts hand off to designers, who hand off to programmers, who hand
off to testers, and so on. An iterative approach leverages the expertise of the team members
and eliminates handoffs.
The Macro Process: The Software Development Lifecycle
The macro process is the overall software development lifecycle that serves as the controlling
framework for the micro process. It represents the activities of the entire development team, and as
such, the macro process dictates a number of measurable products and activities that permit the
development team to meaningfully assess risk and make early corrections to the micro process, so as
to better focus the team’s analysis and design activities.
1.Overview
The purpose of the macro process is to guide the overall development of the system,
ultimately leading to the production system. The scope of the macro process is from the identification
of an idea to the first version of the software system that implements that idea. The development of
subsequent versions of the system, whether for evolutionary or maintenance purposes, is
accomplished by executing another instance of the macro process (another lifecycle).
The macro software development process can be described in terms of two dimensions,
content and time—what is done and when it is done. The content dimension includes roles, tasks, and
work products and can be described in terms of disciplines, or areas of concern, which logically
group the content. The time dimension shows the lifecycle aspects of the process and can be
described in terms of milestones, phases, and iterations.
2.The Macro Process Content Dimension— Disciplines
The macro process involves the following disciplines, executed in the following relative order.
1. Requirements: Establish and maintain agreement with the customers and other stakeholders on
what the system should do. Define the boundaries of the system.
2. Analysis and design: Transform the requirements into a design of the system, which serves as a
specification of the implementation in the selected implementation environment. This includes
evolving a robust architecture for the system.
3. Implementation: Implement, unit test, and integrate the design, resulting in an executable system.
4. Test: Test the implementation to make sure that it fulfils the requirements (i.e., the requirements
have been implemented appropriately). Validate through concrete demonstration that the software
product functions as designed.
5. Deployment: Ensure that the software product (including the tested implementation) is available for
its end users.
The following disciplines are executed throughout the lifecycle.
1. Project management: Manage the software development project, including planning, staffing, and
monitoring the project, as well as managing the risks.
2. Configuration and change management: Identify the configuration items, control changes to those
items, and manage configurations of those items.
3. Environment: Provide the software development environment, including both processes and tools
that support the development team.
Download the following Units for getting full information according your syllabus
Emailing Satelaite Navigation System Example
Control System - Traffic Management System EXAMPLE
Satellite Based Navigation System - System Architecture EXAMPLE
vacation tracking system project
Comments