Object Oriented Analysis & Design

In the lecture conducted in the subject of software engineering. I learned that Software engineering is considered to be inherently complex, that is why the Software Engineers (SE) is being well paid than the other type of engineers. The discussion on the complexity pointed out with the following attributes.

The Complexity of the Problem Domain-Here the point was that the problem domain could not be understood easily since the product is intangible. There is no clear understanding among the client and the SE about the problem domain. For example if we say we are building a cat various people can see various aspects of the cat important to them. So if you do not communicate well there would be a difficulty in understanding the problem domain.

The difficulty of managing the development process-The difficulty of managing the development process due to the intangibility of the software project. The problem is that the development is not visible to the manager, he can only see the when the final out come or relies date comes in a project. SE’s think they can do it in a very shot time where they can’t. Then completion is delayed or done with the reduced functionality .This is because he doesn’t have the clear understanding of the domain.

Flexibility possible through software – Flexibility is possible because it does not take much cost to change the implementation factions only the developer’s time is needed. It is more difficult in other hard bound products.

Contradictory requirements - This can happen due to miss communications and the requirements art defied well enough. The SE might understand the requirements that the user gave in a different way because every body has his or her mine set where they think in there own terms.

Impedance mismatch between users and developers – User and developments can think differently and might not communicate the correct way to each other this is a problem in software development.

Non-functional requirements like usability, performance, cost, scalability and reliability – It is difficult to mat all the nonfunctional requirements of the users as the above when the performance, reliability is going to be highly implemented it costs more when cost is being reduced due to budget the above requirements cannot be made at a appreciated level. This is also a problem.

Requirements of a software system often change during its development- The requirements of a software system is more likely to change during the half way through the project may change of industry may be change of development pan.

Although the software is inertly complex the user need not see what is happening in side as a Se you need to show the user the simple and pleasant easy to understand nice user interface.

Then next discussion was on the attributes of a complex system First thing was the hierarchy.

Hierarchy-this creates the complexity of the system. A system consists of interrelated sub systems which can then be put in to even smaller systems and so on. This will go in until the component level is reached. This depends on the observers of the system the way they see the system. A medical prospective of the cat would have different attributes and factions that a mechanical attributes and factions may differ.

The linkage of the components intra-components is stronger than the inter-component linkage of the system. Components with in a subsystem are tightly linked than the components form another sub system.

The systems can be reused as they are built in components; they have to be easily extendable with the new components. Complex systems never starts form the scratch but built on top of a simple systems or API’s.

There are fundamental limiting factors of human cognition; we can address these constraints through the use of decomposition, abstraction, and hierarchy.

The OOAD the analysis is to analyze the requirements in terms of objects and classes, to identify the objects I the project and to create separate classes to them.

To design the system using the object class according to the user requirements in the logical and the physical cortexes.

There is something called a object model to do this. There are some major elements in this model which needed to be considered. Abstraction, Encapsulation, Modularity and Hierarchy are some of them.

Abstraction – Find out the special characteristics of an object that can be that can distinguish it form the other objects with the clear boundaries relative to the viewer. Recognition of the similarities of the objects is important to distinguish the objects. This should be a simple specification where the details are emphasized on the importance to the user. Entity abstraction (Considering the properties of objects), Action abstraction (Considering the functionality of the object), Virtual machine abstraction (Set of similar objects represented as one due to abstraction level) and coincidental abstraction (Non similar objects represented as one) are some abstraction types

Encapsulation – putting the properties and the factions together in a single module without having it to depend on the other such modules internal values; This serves the actual implementation of the abstraction. Also allows to hide the details of implementation.

Modularity- This is to group the factions in to a components which are loosely coupled and they should have the ability to work independently. Reduces the cost of software redesign and modules can be reused.

Hierarchy – Is the ordering of the abstractions in to a tree like structure. There are two types of Hierarchy’s is a and part of. As a example wheel is a part of the car and ford is a type of a car.

Buddhika M. Kalupahana(044019)

Software Engineering.... A Reminder......

Who is a software Engineer…
A software engineer is one employed to solve problems by the application of information technology. He can measure software. He can provide BigOh measurements of algorithms. He can run a performance monitor to measure the relative CPU usage of my procedures. He can run "top" or open the TaskMonitor? to view memory usage. He can run a test client to measure maximum throughput or determine the maximum number of simultaneous clients a server can handle. As an engineer He can try to improve these measurements by modifying my software design. He can then measure the new design to determine if my changes actually did what he intended.

Why software Engineering is so important?

• But it is just not a simple as it described. Because when we think about the design of the software, we may unable to identify an exactly right or wrong design. So software engineering is not such a simple field of engineering.
  
• The complexity of Software Engineering
  
• As a software engineer we may have to give solutions to highly complex problems. This complexity starts from the problem domain and extends up to change management. A one of the most difficult task which faces by a software professional is identify the problem domain. Because it is a highly complicated matter to understand the problem domain correctly. Because requirements are changing over the time.
  
• Mean while the requirements are get contradict. The requirements are changing over the time. The way of defining requirement at the beginning would be get changes during the life cycle of the development process. As a simple example, if it is a accounting package, and if a new tax type has been introduced by the government at that time, the requirements are getting changes completely.
  
• And Managing of development process is also complex. Because software products are intangible. So it is very difficult to measure the development of the product. Most of the software professionals think that they are on the correct time line and correct track. But at the end they found that they have been very late and the product cannot be delivered by the time. Since software development process is a completely a team work, sometimes many problems arises. Wicked problem is also a challenge in software engineering. Some major crises arise during the middle of the process. Sometimes new problems may come, after implementing the first phase. So at the beginning we cannot predict the end correctly.
  
• Impedance Mismatch between users and developers is another issue. There would be have a big difference between how a requirement is defined by the user and how it is get understand by the developer. Mainly the ambiguity of our natural languages causes to this issue.
  
• The complexity of the software engineering process is very high in terms of Usability, Performance, Cost, Scalability of the product, reliability of the product etc. When a product get very high in terms of performance it will increase the cost also. So balancing all the above requirements are very difficult.
  
• Software products are changing over time. So it is needed to manage those changes correctly. Otherwise the source code will get into a confused state.
  
• Another major task what a software engineer should engage is he has to work for hiding the complexity. Since software systems are highly coplex systems, software engineer should take the responsibility to hide the responsibility. Otherwise the system will not get usable.

Complicated systems.

There are many complicated systems around us. One clear characteristic which all the complicated systems process is it build a hierarchy.

As examples if we think a language as a complicated system, we can identify an hierarchy as follows. There are letters at the root and letters formulate words. Word phases and sentences generates from words. Then paragraphs will found. By that way we can find books, magazines and publications etc. at another level.

The best way to understand a complex system is identify the hierarchy, which stand besides.

In these hierarchies we can identify the communication dependencies. Especially intra-component communication as well as inter component communication is worth to identify.

There are two ways of defining a hierarchy.

Is a hierarchy________

As an example "car IS A vehicle." So the car is implemented using attributes of vehicle.

Part of a hierarchy________

As an example "Tier is a part of a car". The tier and car can be implementing independently.

OOP Recap…..

Object Oriented Analysis.

• Object-oriented analysis is a method of analysis that examines requirements from the perspective of the classes and objects found in the vocabulary of the problem domain

Object-oriented design

• Object-oriented design is a method of design encompassing the process of object-oriented decomposition and a notation for depicting both logical and physical as well as static and dynamic models of the system under design

Abstraction

• We reduce the information and create a generalized model by only keeping the information relevant to particular purpose. As examples animal, furniture, food, book, vehicle can be identify as abstractions. The levels of abstraction vary depending on the purpose. During the design phase, finding of the correct level of abstraction is an important matter that should be considered.
  

Wajira Somarathne (044038)

Object-oriented analysis and design - Concepts

The last lecture is on following topics.

Why Software is inherently complex

The five attributes of a complex system

Object-oriented analysis and design

Why Software Is Inherently Complex?

Software systems are built for different complex problem domains. Software engineers have to handle this complexity and make sure that the systems reach end users with a simpler, easy to use interface. It is up to the designers and software engineers to apply theories and concepts of software engineering to make the software systems more usable and user friendly to the end users. Software engineers have to deal with different domains. To implement a fully working software system, the engineer must have a clear understanding of the problem domain. But although an engineer might have the required knowledge for a particular domain, this knowledge may rapidly get outdated. Therefore developing software systems to work in complex, unknown domains is always a challenging task for software engineers.

For example consider the heart pace controller software or auto pilot software. In both situations, to develop such software, the developer needs to have perfect domain knowledge. In case of a small mistake done during coding due to incomplete understanding of the problem domain can result in severe damages and threats to human life as well. Therefore when it comes to critical software systems the correct and complete understanding of the problem domain is a must.

The problem of complexity gets further complicated due to the fact that software is intangible. Compared to other engineering fields, in software engineering the product is intangible. Consider a civil engineering scenario; it is possible to clearly see the progress of the project while it is done. But with software it’s very difficult to see how the project is progressing. The developers are optimistic too. They think that they can develop the system in last minute. Therefore software systems are inherently complex.

Most software systems are built by group of developers. So managing the team work is a difficult task. Understanding, knowledge, values, believes differ from one person to the other. Conflicts might occur between members of a team. Therefore sometimes it is difficult to manage development process. It is possible that the same requirement gets understood in two different ways by two different members within the same group. Therefore when the system is developed as number of modules, they may not be compatible with each other, simply because the requirements are interpreted in different ways. Most of the times until you reach the point of integration, these misinterpretations will not be discovered. Therefore one module might produce negative integer numbers and input it to a module where the latter module doesn’t accept negative integers. Therefore after integration it is possible for the system to crash. Therefore with the difficulty of managing the development process, software systems are further complicated.

Due to the flexibility possible through software, clients often demand to change the requirements. With construction or any other area, flexibility is not possible. If the client wants to change the design of the house, he/she will have to demolish the house and rebuilt. But it is often possible to change the design of a software. Therefore software engineers always have to undergo difficulties with changing client requirements. When you introduce the changes to a software, you have to manage those changes properly. If not lot of bugs will be introduced to the code.

Sometimes contradicting requirements may exist. Also there is Impedance mismatch between users and developers. Therefore it is difficult to come up with the exact solution that the clients expect.

Although software systems and the problem domain that are being modeled are complex in its internal structure, it is up to the developers to simplify the user’s interaction with the system by providing simple user interfaces and handling the complexity within the software.

The Five Attributes of a Complex System

• Normally complicated systems make up a hierarchy. For example Human is one such complex system which is composed of set of interrelated subsystems. When we identify the sub systems it becomes easy to understand any complex system. A hierarchy can be one of two types; Is A hierarchy or Part Of hierarchy. i.e. Monitor is a Part Of computer where as computer Is A machine.
• The identification of primitive components in a system depends on the person who is observing.
• The communication between the components that make a complex system is known as inter-component linkages where as the communication within the components is known as intra-component linkages. Intra-component linkages are generally stronger than inter-component linkages.
• Complex systems have common patterns. Therefore patterns are reused and small components are reused in those patterns
• Every complex system is built on some system that worked. It is not possible to craft these primitive objects from scratch.

Object-oriented analysis and design

In Object-oriented analysis and design, everything is treated as an object. Real world entities are modeled as objects in this concept. In Object-oriented analysis conceptual classes are identified from the requirements document where as in Object-oriented design maps these conceptual classes in to implementation classes.

Major elements of object model

— Abstraction

Abstraction is the process of simplifying the description of an object by emphasizing on the essential characteristics of it. The concept of abstraction is same as generalization in which only the important details are captured while hiding non essential details. The whole idea is to capture some kind of commonality between different instances according to the purpose. Level of abstraction depends on our requirement.

There are 4 types of abstraction

1. Entity abstraction
2. Action abstraction
3. Virtual machine abstraction
4. Coincidental abstraction

— Encapsulation

Encapsulation is the process of enclosing attributes and behavior in to one object by means of information hiding. Therefore to use an object, programmer or other objects need to know only its behavior not about its internal structure. Encapsulation hides the details of the implementation and gives access to its internal data through methods. Therefore Encapsulation gives the objects the black box behavior.

— Modularity

Due to the benefits decomposition, software systems are designed as separate modules. (Things related to one module have to be handled by that module and different modules are there to handle different things) These modules can be maintained independently. Modularity is the property of a system that is decomposed into a set of modules. Since humans can understand 5 to 7 things at once, it is difficult understand complex systems at once. But with modularization we can achieve higher level of understanding about a complex system. One module can be considered as a package of abstraction. Modules have boundaries which are known as interfaces. A module interface expresses the elements that are provided and required by the module. For modularization to work properly, we need to minimize inter-module dependencies.

Overall goal of the decomposition in to modules

The best way to handle complexity is the divide and conquer method. With this method we can decompose any complex system in to manageable chunks which are known as modules. Since the modules can be designed and revised independently, we can achieve less cost with decomposition in to modules. With modules it is also easy to understand how any complex system functions. All modules should function properly for the functioning of the system. But it should be possible to change the implementation of one module without knowing the implementation of other modules and without affecting the behavior of other modules

— Hierarchy

In most complex systems it is possible to find more than one abstraction at a time. A ranking or ordering of abstractions is known as a hierarchy. With the proper understanding of these hierarchies, it is possible to simplify any complex problem. A hierarchy can be one of two types; Is A hierarchy or Part Of hierarchy. i.e. Monitor is a Part Of computer where as computer Is A machine.

Surangi N. Alexander (044052)

Object Oriented Analysis and Design - Concepts

What I learnt from Advanced Software Engineering Lec1

Software Products are intangible as well as inherently complex. So Software Engineer’s task to model the real world entities is tough than working at other fields. They are paid well as they handle the complexities of modeling the real world.

Why software’s are Complex?
Software Engineer has to hide the complexity of the system from the end user’s and provides functionalities needed through simple interfaces. Domain knowledge is changing rapidly making the software more complex. There is mismatch of understanding about the software system between developer and user. Requirements of a software system often change during its development

Attributes of Complex systems?
Complex systems make hierarchies. This hides complexity from the user. Hierarchy is the basic means to provide extensibility of software modules and helps in increasing the reuse of modules. Levels can be identifies through the hierarchies. A complex system is composed of interrelated subsystems that have in turn their own subsystems, and so on, until some lowest level of elementary components is reached. Normally in a system, inter subsystem communication is less and intra subsystem communication is high.

Human’s memorizing capacity is low. Humans have limitations with dealing with the complexities The complexity of the software systems is increasing, yet there are basic limits upon humans ability to cope with this complexity.

OO helps to organize the inherent complexity of software systems. Object-orientation is so called because it sees things that are part of the real world as objects. It makes Software Engineer’s life easy than working with procedural languages.

Followings are the features of OOP

• Extensibility - Adding new features and modifying some existing ones
• Simplicity - Software objects model real world objects, so the complexity is reduced and the program structure is very clear
• Maintainability - Objects can be maintained separately, making locating and fixing problems easier
• Flexibility - No need to change from scratch. But it is necessary to manage properly without introducing new bugs.
• Reusability - Objects can be reused in different programs
• Modifiability - It is easy to make minor changes in the data representation or the procedures.
• Complexity

Major elements of Object Model

1. Abstraction

Abstraction provides a well-defined conceptual boundary according to the perspective of the viewer. Abstraction refers to the act of representing essential features without including the background details or explanations. Classes use the concept of abstraction. Classes define the properties and methods of an object type.

There are different types of abstraction:

• Entity abstraction: The object presents a useful model of an entity in the problem-domain
• Action abstraction: The object provides a generalised set of operations, all of which perform the same kind of function.
• Virtual machine abstraction: The object groups together operations that are all used by some superior level of control
• Coincidental abstraction: The object packages operations that have no relation to each other.

Examples:

• You can create an abstraction of a animal with characteristics, such as color, height, and weight, and actions such as grow, eat and move. The characteristics are called properties, and the actions are called methods.

Classes are blueprints for Object. Objects are instance of classes.

2. Encapsulation

Each object-oriented object can't see each other as they having a shield around it. But they can exchange things though. It separates the external aspects of an object from the internal implementation details of the object, which are hidden from other objects. The object encapsulates both data and the logical procedures required to manipulate the data.

This should not depend on the internal implementation of the classes. Classes are normally focuses on implementation of behaviors.

3. Modularity

Every complex system can be decomposed in to modules or units that can be solved separately. Each module can be compiled separately, but has connections with other modules.

4. Hierarchy

Hierarchy is the basic means to provide extensibility of software modules and helps in increasing the reuse of modules. They can be divided in to two parts: is a, part.
Examples: Keyboard is a part of computer; Graphic card is an electronic card

Notes:

Difference of functional and non functional requirements
Functional requirements – Specifies essential function that a system or component must be able to perform
Non functional requirements – It specifies additional features other than essentials. Specifies how a system must behave, it is a constraint upon the systems behavior

What is a wicked problem?
Wicked problems are problems which, by their very nature, cannot be completely specified or even understood. Problem understanding develops with the proposed solutions to these problems and implementing the solutions. The existence of the solution may change the nature of the problem

Erandi Senarathna(044036)

Handling Complexity by OOP

What is so important about object oriented programming?
What are the alternatives?
Why learning object oriented programming so important?

Developing systems based on object oriented approach can create extendable systems. Meaning that original system can be improved without changing the existing code. This leads to create reusable systems.

Software is inherently complex. This complexity arises due to various reasons.

Domain complexity

Software engineers think about the systems from their point of view and develop the systems. This may not be the system that the users are actually looking for. This problem arises due to the impedance mismatch of the users and the developers. And some times the problem is clearly understood only when the solution is created, this scenario is called wicked problem. And requirements may change over the life cycle of a software development project. Making changes to the code in the later stages may be more costly than doing it in the early stages in development.
Sometimes contradictory requirements have to be resolved before starting the development. Process.

Flexibility

Many people hesitate to consider a software as a product. Because it is intangible. And clients may ask to develop the system from the scratch as they don’t see any waste like breaking a building and rebuilding the same thing again. But this flexibility creates complexity for software people.

Project Management

Managing the development process is also difficult. As there may be several modules in a project and each module may be having sub modules. Separate teams may be developing their own modules. The major challenge is to maintain the integrity and utility of the design. So once all the modules are done they can be easily fixed into a single system that makes up the final system.

Addressing the complexity

But ultimately software engineers should hide the complexity of the system form users by providing simple attractive user interface to perform what is intended. The basic theory used is that
“Any complex system is made out of simple structures”
Like human body which is made out of cells. Set of cells creates tissues…. So complex systems can be structured into a hierarchy of components. But the primitive components may be different for different people. For example if one is structuring the human body he can consider the cell as the basic element but another can still take tissue as the basic element.

When considering the software systems as mentioned earlier which is inherently complex follows the same principles. In object oriented design, we model real world entities as objects. The complexity is handled by designing them as hierarchies of components. At this point several terms come into play.

Abstraction

Abstraction allows creating a template that represents a group of objects. But this is based on the perception of the system by the user. For example in a system where gender is not significant, system designers may design the person class to represent all the employees of the organization. But factors like maternity have to be considered abstraction in the person level is not adequate. Designers have to move a level down and design two classes to represent Man and Woman.

Encapsulation

Using this concept classes are designed by encapsulating properties and behaviors in to one compartment. And properties are not allowed to be manipulated from out side directly. This is some times called information hiding.. Encapsulation ensures independent implementation of each class. So internal implementation is independent from others.

Modularity
The best way to tackle the complexity is using the divide and conquer approach. Complex software system is sub divided into manageable modules and developed independently as they are loosely coupled. Each module define an interface to connect with other modules.

Hierarchy

We design real world entities as objects. We use abstraction to represent groups of objects. But to understand the system more closely we define relationships between these groups. These relationships create hierarchies. For instance if we are designing a car we can relate the tyre by a part of relationship. And then we consider tyre as another abstraction that represent set of tyres. And we can create automatic_gear car by extending the car. All these things create hierarchies that increase the understanding and the structuring of the system.

Charith Handagama(044015)

Object Oriented Programming – A Recap

This is the summary of what we discussed during our last lecture.

There are three main questions that we have to answer with regard to OOP. Why OOP is needed? What are other options we have? And what is the importance of learning OOP?

Software is inherently complex. There are many reasons for software to be increasingly complex.

1. Complex and unique problem domain

Software is developed to cater the needs of different kinds of fields. Most of the times there systems are one of a kind. When developing such systems software engineers first have to understand the detailed nature of the problem domain. These problem domains are very complex and rapidly changing. So understanding them is not an easy task at all. Most of the times when a software engineer moves from one project to another, they have to learn about that new problem domain. Given the capacity of human learning this is a very challenging thing.

Other Issue with this kind of complex problem domains is that you can’t understand what the problem is until you find the solution. So until then you can’t identify the issues with it.

2. Contradictory requirements

It is very difficult to extract the correct requirements of the system from the users. Most of the times users also don’t know what exactly they need.

3. Flexibility

Flexibility is a great feature of software systems and also a feature that makes it more complex. Because of the flexibility while the project is going on users ask many new features, do changes to existing requirements, drop features, etc… In this kind of scenario change management is very important, otherwise we may not know what exactly the software is doing. And also if the system is not designed properly, when we try to add or change features it will introduce new bugs.

As software engineers our job is to hide this complexity from the users and give them an illusion of simplicity.

4. Intangible nature of the final product

Software products are intangible. When we do a software product we can’t see the progress of it as with other engineering disciplines like civil, mechanical, etc…

By using good Object Oriented Analysis, Design and Programming principles we can reduce the impact of above problems and develop better maintainable and extendable software.

Attributes of Complex Systems

Complex systems are made out of hierarchical collection of components. These components are linked together through inter and intra component linkages. In order to understand the system properly we have to understand these hierarchical subsystems first.

There are only few types of basic subsystems available in any complex system. We reuse those basic components to build complex systems.

This hierarchical nature can be of two types “Is-a” or “Part-of”.

Another main feature of complex system is that they do not develop overnight, rather they evolve over time.

This hierarchical nature of complex systems allows us to modularize the development process. So we can employ divide and conquer strategy to develop the project. Another advantage of modularization is that it allows us to understand the system better. In large complex systems no one person can fully understand it. But when we divide that in to small modules one person can have better understanding of that part.

Few Key Words

1. Object Oriented Analysis

OOA is concerned toward developing software engineering requirements specifications that expressed as a system's object model.

2. Object Oriented Design

OOD is about developing an object oriented model of a software system to implement the identified requirements.

3. Abstraction

We reduce the information and create a generalized model by only keeping the information relevant to particular purpose. For example we can consider things like animal, furniture, food, book, vehicle as abstractions. Abstraction is a concept, we can’t initialize them. Our levels of abstraction vary depending on the purpose. Finding correct level of abstraction is an important design decision.

4. Encapsulation

Is the process of wrapping functionality and data together in to one unit. This is a way of information hiding. Through this method internal working of methods are hidden and only an interface (API) is presented to the users to work with. So if any changes to be done to the functionality or data in the class they can be done without affecting other components in the system.

By, M.A.C.Sandarenu 044034A

Lecture 1 - Advanced Software Engineering

In the last lecture, we discussed the fundamentals of object-oriented analysis and design. There were some major topics were discussed;

- Complexity of the software

- Attributes of a complex system

- Elements of an object model

Complexity of the software

Developing software is more complex than developing a building or a car. There are so many reasons why the software become complex.

• Getting domain knowledge is difficult; for example when developing a HR system or financial system or an application for banks, it’s required to get that particular domain knowledge. Another fact is that domain knowledge is changing very rapidly.
• When it comes to software, it’s difficult to get the visibility in the development process.
• Flexibility is one of the main aspects of software. Requirements are changing rapidly when we concern developing software, but if we don’t manage them (requirements) properly it may introduce new bugs. So introducing changes without introducing bugs should be the major concern.
• There may be multiple clients, so that they may have requirements which contradict with each other.
• Users of the software don’t have a better understanding of what exactly they require, as well developers may focus on the product not what users want, but actually what they are interested.
• Non-functional requirements, software requirements that describe not what the software will do, rather define how the software will do it, for example, software performance requirements, usability, reliability, etc make software more complex than other fields.
• With the time pass & with the progress of the software, users get better understanding of the system. So there is a high possibility of changing the requirements during the implementation of the project.

[Due to this complexity of the software and since IT professional are required to handle this complexity, they are paid more when compared to other professionals.]

It is the responsibility of the software engineer to hide the complexity of the system from the user and provide a simplified interface to him. For example consider the system interface provided in an ATM to the user. There the internal structures, complexity of the business logic, etc… every thing is hidden from the user.

Attributes of a complex system

Next we looked at the attributes of a complex system:
Mainly there are five attributes of complex system. Those attributes can be listed as below.

• Complicated systems create hierarchies and it is composed of sub systems which are interrelated. (Hierarchies are discussed later in the post)
• Level of abstraction required depends on the viewer of the system.
• Communication between components is known as inter-component communication where as communication within a component is referred as intra-component communication. Intra-component linkages are generally stronger than inter-component linkages.
• Complex systems have common patterns. These patterns may involve the reuse of small components.
• Always start with a working simple system. Complex systems can be built upon simple systems.

Elements of an object model

Then we discussed about what is meant by object-oriented analysis and design. There we are mapping real world entities into objects. Object-oriented analysis concerns about identifying classes & objectives by carefully going through requirement analysis. Object-oriented design further examines new classes which are not directly related to that particular domain.

There are four major elements of object model known as Abstraction, Encapsulation, Modularity, and Hierarchy.

Abstraction defines essential characteristics of an object, so that it’s differentiated from other objects. It is a concept. For example an animal is not a real thing. It’s a concept. Like wise real world objects like shape, furniture, flower, vehicle, shoe, etc can be given as examples to illustrate the abstraction. Assume you are asked to write a class to represent Animal. Is it possible for you to do it? Animal is not a real world thing, it’s just a concept. After identifying the interested requirements of a system, finding the right level of abstraction plays a major role when developing systems. Another fact to mention is that Abstraction does not really require hierarchies. Abstraction focuses on the behavior of a system like, breathe, run, and walk. There are basically four types of abstractions; Entity, Action, Virtual machine, and Coincidental abstraction.

Then we looked at what encapsulation was. Encapsulation tells how to implement those behaviors. For example encapsulation defines how to breathe, how to run, how to walk, etc. Through encapsulation actual implementation details is hidden. For example consider this: Customer, waiter and kitchen are three encapsulated objects in the 'cup of coffee' example. Customer and kitchen do not know each other. The waiter is the intermediary between those two. The 'hatch' enables them to communicate and exchange coffee and money. Note that no part of a complex system should depend on the internal details of any other part.

Modularity is another element of object model. Normally divide and conquer method is used in software systems. Large systems are divided into manageable chunks. When the things become smaller, it would be more understandable as well. Then different modules are dealt with different parties and each module handles different activity. Inter module dependencies should be minimum.

Hierarchy composed of several levels. With hierarchies we can get better understanding of a system.

Following illustrate an example for a hierarchy.

There are two levels of when it comes to hierarchies.

Examples for is-a and part of hierarchies.

By: W.A.A.D. Wickramaarachchie [ 044044 ]