Lecture 1 : Introduction to Software Engineering and associated complexities, OOP overview, grouping and other odds and ends

The first lecture conducted by Mr. Harsha dealt with going back to OOP (Object Oriented Programing) and its fundamentals of design. The deviation of the subject matter from the previous lectures where we were discussing about the need for mathematical basis and about OCL was a surprise.

Several in class activities were conducted in an effort to clarify to the students of the proper need for modeling. It was clear by the end of those that different people would model the same problem in several ways depending on their domain understanding. i.e. they will use the head knowledge to bring about the design. This of course we must understand is detrimental to any proper design, as it will create ambiguities in the documents outlining the design.

If careful observation was made at the end of the day we can see that this lecture looked at the need for a proper design basis (i.e. a mathematical basis perhaps as outlined in an earlier lecture) when it comes to OOP.

The slides used for the presentation highlighted why software was complex, (and also the reason why software engineers are purportedly receiving higher pay) due to.

• Complexity of Problem domain
• Development process management
• Flexibility
• Contradictory requirements
• User/Developer mis-communication

At the end of the day it goes without saying that the vehicle of communication within which we will be learning about Advanced Software Engineering would be OOP. So its fair to expect that during the course of this module we will be seeing aspects of(hmm…)

• Object Oriented Analysis
• Object Oriented Designing

So during the last bit of the lecture there was a re-cap of earlier learned fundamentals present in OOP. These are:

• Abstraction
• Encapsulation
• Modularity
• Hierarchy

The day concluded with groups being made out so that they will be presenting different topics during the rest of the module.

So ended the lecture where over 100 students were in a room designed to hold 64. (no pun or complaint or offense intended)

P.s. we were all asked to blog about the lecture as well as create facebook accounts and groups for the lecture. Hence the blog post. :)

Object Oriented Analysis vs Object Oriented Design

Why software engineers are paid more?
Software engineers are modeling projects whereas engineers are building projects. Developing a Software Project is much more complex than the developing any other tangible project like building. Since the nature of intangibility of software, it is very harder to monitor and measure the progress of software project.


• Complexity of the problem domain
The domains can vary really vastly in a software problem. If the problem could be solved simply and easily by human, then there is no need for a software system. It is clearly obvious that we have so much software systems because of the complexity of the problem domain.

• Impedance Mismatch
The system developer and the architect of the system doesn’t know what the client really wants and the client also is not clear what he needs with his requirement.
So vague ideas and communication gap ends with the project in mismatching situation.

• Difficulty of managing the development process
Software is a total intangible product/Service. It is hard to measure and value in a quantitative manner. Qualitatively only we can get at the needed milestones and achievements in a software process.
Software development process is also a intangible process with lot of inconsistencies. There is no clear cut benchmark to evaluate the progress and the management.

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.

W.R.V.G.I.R Kumara (044051)

—

Object Oriented Analysis and Design

This lecture covers the important aspects of the Object Oriented Analysis and Designing and the entire Software Engineering process. The following is a summary of the lecture which was discussed in detailed at the lecture.

Advantages of Object Oriented Programming

• Easy to understand
• Easy for maintenance
• Reuse of code
• Reduce development time and cost

Reasons for Software complexity

• Complexity of Problem domain
• Difficulty in managing development process
• Flexibility
• Contradictionary requirements
• Impedance mismatches (User/Developer)

Attributes of a complex System

• Intra component linkages and Inter components linkage
• Part of Hierarchy
• Easer Hierarchy

Fundamentals of OOP

• Object Oriented Analysis
• Object Oriented Designing

Major elements of Object Model

• Abstraction
• Encapsulation
• Modularity
• Hierarchy

Advance Software Engineering – Software Complexity and Object Model

Last week ASE lecture was interesting passage of time where the lecture expanded from fundamental to the advanced theories enhancing the knowledge of the students on software engineering, OOA and OOD. There we got some useful points some which we were not having a clear idea to areas we needed to put our focus on. Following is a recap of the lecture.

Object Oriented Programming (OOP)

OOP is an approach to programming which involves the creating of abstracted code pieces/objects designed to interact with each other.The main concept lies with the "Object" to represent the required entities, their interactions and "Classes" or blueprints for object creation.

Few advantages of OOP

• Permit reusability
  - Inheritance
  - Polymorphism
• Ease maintainability
• Secure and Robust
  -Encapsulation
• Simplicity
• Extendibility (Scalable)
• Cost effective

Why software engineers are paid more than other engineering fields?

Rather than other engineering fields the “Software Engineer” has to deal with different domain knowledge with unique set of constrain parameters and able to produce a system which can improve the productivity and efficiency or innovate to capture new value and all these in a dependable responsible manner.

Software development paradox

We have discussed some of the reasons for the complication for the software development process. Software development has been, is, and remains hard due to number of factors.

>>The complexity of the problem domain
Software is developed on variety of domains which involve humans to machine having different prospects of the system. So understanding the problem domain which sometimes alien to the software engineers in a short period of time with other practical restrictions is hard. And the outcome have high expectation and success of a well working system to match the client expectations is difficult.

>>Flexibility aspect of software
Software is much flexible than other tangible engineering outcomes, so the expectations of changing particular requirements is expected. But when accomplishing it shouldn’t harm the other functionality of the system like introducing new buys etc.

>>Difficulties of management
Software is intangible, so monitoring and estimating the progress is difficult (tricky).

>>Impedance mismatch
The user wants/requirements mismatch with the developer understanding of the system which lead to lack of satisfaction of the software. The client may not aware what they want or the developers doesn’t understand what is expected can lead to chaos.

>>Contradictory requirements
Sometimes due to the lack of knowledge to communicate it can lead to contradicting situations which will be not achievable. Maybe the client wants something which can somehow leads to difficulties for the entire system that he may wants.

>>Non-functional requirements
Performance, scalability, usability, reliability and cost like factors which maybe not having a clear understanding can play a major role in the development which incase can lead to contradictions on different parameters such as cost, time and scope.

Factors affection software.

Complexity factors:

Change is unavoidable.

Incrementally changes do not change inherent complexity.

Aggressive refactoring tends to slow down that tendency

Object Model

TheThe object oriented programming concept based on modeling things as objects and using its interactions to interpret real world elements and their behaviors.

OOD revised

The method of designing a software system that leads to object oriented breakdown by using different notations to express different models of the logical and physical design of the system.

Abstraction

In the lecture we talked about one of the most important aspect of OOP, abstraction. It is a concept that emphasizes the essential commonalities of entities while ignoring distinctions. We understood the complexities of understanding the specific features from abstract common feature and how it is useful but difficult to distinguish from a set of objects.

Hierarchy

Complex systems are made up of smaller sub systems which can be represented in hierarchical manner and we can go level by level in detail. These sub system can have sub system within and again we can decompose a complex system in to parts.

Prageeth Kumara - 044025

Advanced Software Engineering - Object Oriented Analysis & Design Concepts

In summary, during our first lecture we had a basic introduction to the essential concepts of Software Engineering which has been misunderstood by many students. So at the first we were asked three questions such as why object oriented programming (OOP) is needed? What are the advantages of learning and using OOP? What are the other options that we have?

OOP is needed Because of the growing complexity of software development. In OOP, whole software is described in terms of the objects or the concepts and their relations. OOP leads to:

• Reuse, and reuse (of program components) leads to faster software development and higher-quality programs
• Higher maintainability of software since its structure is inherently decoupled
• Develop systems that are easier to extend and easier to scale without changing the existing implementation. So the work that has been tested will not be affected by the new insertions to the system, hence it saves the cost of the software development and maintenance in many ways.

Then basically we discussed about the essential elements of the Software Engineering by sticking to the following major topics:

1. The Inherent Complexity of Software

Why software engineers are paid more?
Software engineers are modeling projects whereas engineers are building projects. Developing a Software Project is much more complex than the developing any other tangible project like building. Since the nature of intangibility of software, it is very harder to monitor and measure the progress of software project.

Most of the time software engineers develop systems based on other’s requirements in different domains which are not familiar to them previously. So developing the right system that complies with the client requirements for a given domain is a complex task. The complexity associated with the software projects can be further discussed in terms of the followings.

The Complexity of the Problem Domain - Software systems are developed in order to cater for various domains. Domains can be quite large, for instance “Medical,” “Legal”. Software engineers are not familiar with those domains, and hence they have to learn about those concepts within a very short time period prior to begin the real implementation. This can be very crucial if the problem domain is changing rapidly.

The Difficulty of Managing the Development Process - Since the software systems are intangible it’s enormously harder to monitor the progress of the project during the development process.
Note: Wicked Problem - Sometimes during the development of the software project, developers have to come up with a solution though they haven’t fully understood the problem yet. These are kind of a wicked problems.

The Flexibility Possible Through Software - As software is much more flexible compared to other tangible products like building, clients may request lots of rapid changes while the problem is being solved. If we are not developing the project in a structured manner tackling those client requests may introduce new bugs to the system.

Contradictory requirements - Since it’s harder to translate the thoughts in mind in to set of words, there is chance to appear contradictory requirements from multiple clients.

Impedance mismatch between users - Most of the time clients may not sure about what they want and developers also don’t know what the clients want from them. Developing the system according to the developer perspective will not fulfill the client requirement.

Non functional requirements - Functional requirements specify what the system should essentially do whereas non-functional requirements specify how the system should behave while operating. Those non-functional requirements can be software specific and achieving them makes the software development more complex. Examples of such requirements are:
• Portability • Reliability • Performance • Testability • Modifiability • Reusability • Interoperability

Requirement change during its development - Although that is very rare in other engineering projects, software tends to be changed during its development process with the understanding of the system. Most of the changes are proposed by the clients of the system when they get knowledge about the system gradually.

All these things makes software engineering different from problem solving in other engineering fields and sciences. How does software engineer deal with complexity in large projects?

• Divide and conquer
• Abstraction (Modeling), decomposition, hierarchy
• Iterate and increment
• Reuse and recycle
• Strong cohesion and low coupling
  – Among different subsustems within the system

Next we discussed about the attributes of a complex system:

2. Attributes of a complex system

Hierarchical Structure: Complex systems are structured to describe the function of its sub systems as well as the hierarchic relationship among these sub systems.

Relative Primitives: The choice of what components in a system are primitive is largely up to the judgment of the observer of the system.
Separation of Concerns: Intra-component linkages are generally stronger that inter-component linkages.

Common Patterns: Hierarchic systems are usually composed of only a few different kinds of sub-systems in various combinations and arrangements.

Stable Intermediate Forms: Complex systems designed from scratch never works so we have to start over, beginning with a working simple system.

Finally we talked more about the essential principles of Object Orientation

3. Basic Principles of Object Orientation - Elements of an object model

Object-Oriented Analysis - OOA is concerned with developing software engineering requirements and specifications that expressed the whole software system as a group of interacting objects within the problem domain. "OOA focuses on what the system does"

Object-Oriented Design - OOD is concerned with the concepts in the analysis model and mapped onto implementation classes and interfaces. "OOD focuses on how the system does".

In OOP, the basic conceptual framework is the object model. There are four major elements of this model:

Abstraction

Abstraction is a kind of representation of a concept that emphasizes the essential commonalities of entities while ignoring distinctions. Some of the examples for abstractions are animal, vehicle, furniture, shoe, food, etc…If we take the concept of “Animal”, when we define abstract data; we identify their essential characteristics as follows, since the consideration is to identify the similarities and to ignore for the time being the differences. In this abstract view of the Animal we only have essential attributes and operations that are common to all the other animals so we can’t instantiate objects out of that. Simply means if we are asked to draw an animal which has these properties we can’t.

As software engineer often faces the question seeing that how to identify useful objects from a requirement specification. Although it is crucial to identify the right level of abstraction, that can lead the most extendable and maintainable software implementation. Also it allows us to manage the complexity associated with the system. Abstraction is totally depends on the domain and perspective of the software to be implemented.

Encapsulation

While abstraction helps to focus on the essential characteristics of an object, encapsulation enables to expose only those details that are necessary to effectively use the object. This is achieved through information hiding. Clients of particular software totally depend on the interfaces, so encapsulation helps software engineers to hide the details of the implementation of the interface by revealing as little as possible about the inner workings of the Interface to the clients.

Example: it is not important for an automobile purchaser to know the inventory cost of an automobile but it is important for the purchaser to know the purchase price. Encapsulation allows us to hide the inventory cost but allows access to the purchase price based on client requirement.

Additionally encapsulation helps for minimizing interdependencies among modules by defining strict external interfaces. This way, internal coding can be changed without affecting the interface, so long as the new implementation supports the same (or compatible) external interface. It prevents a program from becoming so interdependent that a small change has massive effects. In this way with the use of this technique we can change the implementation of an object without affecting the application that uses it for.

Modularity

Modularity allows physical and logical decomposition of large and complex things into smaller and manageable components.

This allows software engineers to decompose a large chunk of a system into small and manageable subsystems in a loosely coupled manner. The subsystems can be independently developed and compiled as long as their interactions with other modules are well understood. By modularizing the software we can tackle the complexity associated with it easily. But inter module dependencies within the system should be minimal.

Hierarchy

Hierarchy is a ranking or ordering of abstractions. The two important hierarchies in an OO system are:

U. W. D. Dilhani (044007)

Software Engineering and Object Oriented Analysis & Design

Monday was our first software engineering lecture. During that lecture I got chance to learn new concepts and also to refresh my earlier knowledge.

:-) Software Industry….
Software industry is young industry when comparing to other industries. But this industry has high demand. There are many reasons for that; domain identification is very difficult, progress of the development is invisible, team work ,requirements gathering is very difficult, Basically Software is abstract and intangible.

:-) What makes good software….

Depending on the application user expects different capability from the application. Such as banking systems must secure, a telephone switching system must be reliance etc. These all attributes can be generalized into following attributes. And those are the key Essential attributes of good software such as Maintainability,Dependability,Efficiency,Usability.

:-) New word……

This is new word I head in the lecture and it’s quite interesting .Wicked problem-come up with an initial solution and implements it and see. Like wise you are going forward. Following link gives more details about this Wicked problem

:-) Software and complexity…..

Software is a more complex and also it is an essential property of all large software system. People can develop software but the challenge is developing a industrial-strength software. If we didn’t develop such systems the developed systems are nor more usable. So handling complexity is major task in software industry and there fore we should find a way to tackle this complexity.

We observe that this inherent complexity derives from four elements:

1. The complexity of the problem domain,
2. The difficulty of managing the developmental process,
3. The flexibility possible through software,
4. The problems of characterizing the behavior of discrete systems.

The complexity of the problem domain

There are lots of root causes to become the problem domain complex. There can be contradictory requirement. This means two or more requirements are complicit each other. Suppose if client ask the product within two week and also he asks for bug free product; this instance shows the contradiction of requirements.

Impedance mismatch is another reason for getting the problem complex. User and developer see the product in different views. In software industry user not able to describe what he wants and same time developer don’t know what user wants. So in this situation requirement gathering is very difficult. Following picture shows famous example of impedance mismatch

And the other thing is requirements are changing during the development process. Normally the large software is evolving with the time. Different users have different requirements so we can’t give generic product.

The difficulty of managing the developmental process,

The user don’t care about how much complex inside the product. So developer responsibility is to give simple solution for the complex problem by hiding the complexity from the user. So developer has to concern about maintainability, flexibility. To achieve this developer have to use different techniques. Also lots of software developments are carried out using team. So managing teams with the development process is also very difficult task .This may get complex when the development work is geographically detached.

The flexibility possible through software

With the software it can be change, add the new things. So flexibility is the thing which we should done the things without introducing new issues or bugs.

The problems of characterizing the behavior of discrete systems.

In general events we may able to describe using the theories. Within the large software application there are lots of variables, thread .So current state of the application is determined by values of these variables. Computers are digital devices with discrete states. So it is very of characterizing the behavior of discrete systems.

Most of the time software industry fails to master the complexity there for software crisis arises. Which means software may not be able to deliver on time and within budget.

There are some complex systems in our environment such as plant, animal, language, human etc.

:-) Attributes of complex system

Normally complex systems are hierarchical and it consists of sub system .Those sub systems are interrelated.The inter-component linkages within a sub system are much stronger than the intra-component linkages. Basically And the complex systems are evolve with the time.

:-) Finished Complexity and discussed about some fundamentals…….

— Object-oriented analysis - Read and identify the objects and classes.

— Object-oriented design - Add more classes, introduce other things not directly related to design and problem domain.

Normally people regard their environment in terms of objects. A model which develops using object oriented technology is often easy to understand because it directly relates to reality.

The following figure shows in object oriented technology has reduced the semantic gap between realty and the model.

:-) What is Object Model?

Object-oriented technology exits on top of foundation and the it consists with some elements.When we take theses elements collectively call the object model.

:-) Major elements of Object Model

During our lecture we discussed about four major elements of object model as mention in the figure.

Abstraction

We identify the object in abstract manner. The level of abstraction depends on the requirement. You have to find the right level of the abstraction in that problem domain .For that you refer the software specification document and find the similarities. Then you can be able to find the right level of abstraction. Also depending on purpose we can reduce the attributes .If not lots of attributes will be in your program and it affect the maintainability of program. There are many abstraction con be find out in our environment such as animal, person, vehicle. Normally Abstract classes cannot be instantiated

:-) Encapsulation

Hide details of implementation of the methods. This picture shows simple example of encapsulation.

Modularity

Best way to handle the complex systems is using divide and conquer method .You divide the whole system into manageable chunk. It will support for maintainability of program. By modularizing you can understand the each module separately.

Hierarchy

Complex systems can be representing in hierarchical manner and we can go level by level in detail. So you able to find sub system and with in that sub system again small sub system like wise you can go along the hierarchy. Within the system as well as among those systems intercommunication take place. You have to minimize inter dependency between the modules. Hierarchy helps to deal the complex problem in simple manner.There are two hierarchy types.

1. Is-a- : Cat is an animal
2. Part -of : Monitor is part of Computer
   

Also there should be a purpose for go to hierarchy. For a simple solution hierarchy may not applicable.

W.Y.M.W.H.E.Wijebandara(044046)

Advanced Softtware Engineering - Lecture 1

Why software is complex ?

• Complexity of the problem domain - Software is developed to solve a problem. If the problem could be solved simply and easily by human, then there is no need for a software system. So inherently the problems that have to be solved using software systems are complex. Most of the software domains that we come across are different from one another. So their requirements, available resources etc. are different. At the same time even in a particular domain, the knowledge is rapidly changing. So it’s not practical to learn in depth in a particular domain, just to develop the software.

• Impedance Mismatch - Another major reason for this complexity is the impedance mismatch. The developer of the system doesn’t know what the user really wants and the user doesn’t know how to tell what he really wants. The users and developers are having different perspectives regarding the problem and they provide different assumptions about the nature of the problem.

• Difficulty of managing the development process - If you are building a house you can see how it is being built. You can see the foundation is being laid; walls are building, then the roof and so on. So at any given point of a time it can be said what are the things completed and what more to be done. Managing is easy.But when it comes to software, it is intangible. You cannot see how it grows, so as to measure and manage the development process. At the initial stages you will feel that the project is on track and all the things are going smoothly, but when you reach the deadlines you recognise that lot more to be done but limited time.

On the other hand when the size of the system is getting bigger the management of it is too difficult. (Here we are talking about the hundreds and thousands of lines of code and sometimes millions of lines of code).

• The flexibility possible through software -When we are building a house it is highly unlikely that we will change the structure in the halfway though. Even we does, it will cost a lot. Since software offers ultimate flexibility, it is possible to change the designs, requirements etc. during the development cycle.

• Requirement of a software system often changes during the development - Changing requirement and the features during the development cycle is a common thing. Some times the users do not have a proper idea of what they want. When they see the system being developed half way through, they realise what they really needed. From the developers’ side, as and when they develop they get a better understanding of the domain and will find better ways to do. These may come out as new features or as improvements. Both these reasons cause the changing requirements during the development cycle.

• Non Functional Requirements - When it comes to software, only the functionality is not enough. The users expect something more from a software system. Non-functional requirements such as usability, performance, scalability etc. are important. In addition to the functionality of the system, the developers have to pay attention on these areas as well. So managing both of these requirements is not an easy job.

The role of the Software Engineer...

The role of the software engineer is to hide this complexity from the user and provide a simplified view to use. For an example every time when we are getting money from ATM, what if we (as the users) have to call the bank and ask whether sufficient money is in the account, after that again do a check to see whether the sufficient amount is there with the ATM machine etc. The system has hidden all those complex things from the user, and when the user enters the amount, it will provide money or a message.

Attributes of a complex system

Normally complex systems are formed in a form of a hierarchy. There are small sub systems that are inter-related and within those sub systems there are further sub systems and so on. But there is an elementary component which all the sub systems are made out of. The inter-component linkages within a sub system are much stronger than the intra-component linkages which are present among sub systems. The complex systems are developed by evolving. It as to be designed from the scratch and cannot be patched up to make it work.

OOP Recap

Object Oriented Analysis

Object oriented analysis is the method of analysing the requirements in a form of an object model.

Object Oriented Design

Object oriented design is the method of designing the system that leads to object oriented decomposition by using different notations to express different models of the logical (class and object structure) and physical (module and process architecture) design of the system.

Abstraction

Abstraction denotes the essential characteristics that should be present to distinguish one object from another. The level of abstraction depends on the way we are using it. For an example tree can be an abstract in a system that deals with botanical details, but it may not be the case in another system.

Duleepa Karunaratne (044021)

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)