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 ]