Some of the OO are attached for your knowledge and understanding : https://www.mathworks.com/help/pdf_doc/matlab/matlab_oop.pdf --- (In Matlab)

https://www.scoop.it/topic/rjqjimo/p/4098687175/2018/06/23/robert-lafore-c-solution-manual-pdf ----(In C++)

https://www.alliancesoftware.com.au/python-developers/?gclid=EAIaIQobChMI_4eigKev6AIVRxSPCh2RrgJsEAAYASAAEgIWAPD_BwE

Muhammad Ali thank you very much for a quick answer. I'm interested in OO analysing, specially to discover how it evolved etc. Kindly share your idea

fundamental issues of a software

1. modifiability

2. adaptation

3. evolution

Modifiability -> Info Hiding

Information or data hiding is a programming concept which protects the data from direct modification by other parts of the program.

Ex-class student {        char name[30];         int marks;      public:         void display(); }; int main() {

      student S;       S.marks=50;  // Wrong code!       getch();       return 0; }

Adaption -> Inheritance and classes

Inheritance enables new classes to receive—or inherit—the properties and methods of existing classes. In previous articles, you learned that an object is a self-contained component that contains properties and methods needed to make a certain type of data useful.

Object Oriented Methods are system development approaches that encouraging and facilitating re-use of software components. OO models are used to fill the gap between problem and solution. This performs well in situation where systems are undergoing continuous design, adaption, and maintenance.

Also, This OO Methods engage with international standard Unified Modeling Language (UML) from the Object Management Group. UML is a modeling standard for OO analysis and design which has been widely adopted in the IT industry.

Structure Programming Approach work as a Top-down approach. Here Program is divided into number of sub modules or functions and Software reuse is not possible. Structured design programming usually left until end phases. This is suitable for real time system, embedded system and projects where objects are not the most useful level of abstraction.

So, the fundamental issues with the Structure Programming are,

• Modifiability
• adaptation
• Evolution

Basically, OO Methods based on Information hiding, class and inheritance. So OO Methods address those like follows,

• Modifiability by Info Hiding
• Adaption by using Inheritance and Classes

So, Evolution is the one that did not fully solved by OO methods yet.

D/SE/18/0001

Response attached here

What fundamental issues with structure programming and how those were answered by OO

Same code repetitions or modifiability

The code that is written may appear in different parts of the program. It can be vulnerable to various problems because of its location. Programs have variables, which means that they can take on different values at different parts of the program. According to OO concepts we can make constructors and objects and use them instead of repeating the same code in the different parts of the program. Mainly we use the concept inheritance to minimize the amount of duplicate code in an application by sharing common code.

Lack of encapsulation

Its lack of availability in structured programming means that programs will be longer. According to the OO concepts encapsulation protects an object from unwanted access by clients and allows access to a level without revealing the complex details below that level ..and it reduces human errors and simplifies the maintenance of the application.

Lack of information hiding or modifiability.

Information hiding is a basic concept of OO design. Information hiding is used in designing the object, in particular when deciding what information should be visible and what information should be hidden.

Adaptation

Method overloading allows methods that perform similar or closely related functions to be accessed through a common name.

Complexity

Abstraction in OO concept can be used to manage complexity or hide irrelevant data.

Issues which did not answer yet by OO concepts.

OO concepts can be not suitable for all types of problems- for smaller problems it is in general not suitable.

It can be too scalable. If OOP is left to run out of control, then it can create a massive amount of bloated unnecessary codes.

Evolution is not completely addressed by the OO concepts.

The future phases of programming will address non-object problems with different models.

The future trends of OOP concepts are,

Standalone functions.

Simpler easier to use abstractions over threading.

Severe restrictions in inheritance. D/SE/18/0019

What fundamental issues with structure programming and how those were answered by OO? And are there are any issues which did not answer yet?

If so what is the future trend?

structured programming is a subset of procedural programming. It is also known as modular programming.

Issues of structured programming:

· Same code repetition

The code that is written may appear in different parts of the program. It can be vulnerable to various problems because of its location. Programs have variables, which means that they can take on different values at different parts of the program.

· Lack of encapsulation

Its lack of availability in structured programming means that programs will be longer.

· Lack of information hiding

Information hiding involves isolating design decisions in a computer program that have the greatest chance to change. This protects other parts of the program from modifications if the design decision is changed.

How oo address those issues:

Procedural Programming has been dominating the industry for several decades. Before OOP spreaded, as the codebase of programs kept growing because users wanted more and more features and technology evolved, it was becoming difficult to maintain a bunch of thousands procedures that were probably wrongly-named or misplaced somewhere they got hard to find out.

The major concepts of Object-Oriented Programming are:

· Object – The instance or representation of a class

· Class – The blueprint of an object

· Abstraction – Used to manage complexity or hide irrelevant data

· Inheritance – Allow one class to encompass the properties of another

· Polymorphism – Customized interpretation of different behaviors

· Encapsulation – Access control for instance variables and methods

OO offers more flexibility and better maintenance especially when it comes on to the upgrading of an application with advancements in technology, reusability, inheritance and better data security with its encapsulation concept. OOP is the preferences because, unlike the SP, it allows programmers to modify any part of the code, the beginning, the center or the end of a program without affecting the overall application.

issues:

There are some issues with OOP also. OOP is left to run out of control, then it can create a massive amount of bloated, unnecessary code. When that occurs, the overhead rises and that makes it difficult to keep costs down. Because of the duplication involved, the first-time coding can be more extensive than other options as well.

future:

The next phase of programming will address non-object problems with different models; Here are a few thoughts about future trends of OOP concepts;

· Standalone functions.

· Severe restrictions in inheritance

· The removal of null.

D/SE/18/0016

A.R.M.S.G.D Abeykoon

Modifiability, adjustment and advancement are crucial issues of programming.

•The upkeep cost is extraordinarily diminish by improving the modifiability. Flexibility is the capacity to change the product framework as indicated by setting varieties. Programming adjustment is worried about giving systems to cause courses of action on advancement of programming so as to reuse those in new manner. Advancement is the way toward creating programming and refreshing it. For instance, we can include or evacuate a few codes in the software. Information stowing away, Inheritance and classes are the item situated techniques address those issues. Data concealing technique assists with explaining the modifiability issue. Legacy and classes keep up the adjustment issue.

Information Hiding is the way toward concealing the subtleties of an article or capacity. The covering up of these subtleties brings about a reflection, which decreases the outer intricacy and makes the article or capacity simpler to utilize. What's more, data covering up adequately decouples the calling code from the inner operations of the article or capacity being called, which makes it conceivable to change the shrouded divides without having to likewise change the calling code.

D-SE-18-0018

When designing software can be using structured programming also known as procedural programming. Structured programming is user friendly, reduced complexity, easier to read and learn, Errors are more easily found and easier to maintain etc.

But Number of key issues can be dealt. These are the some of key issues we faced when designing software using structured programming and how those were answered by OO concepts;

· Same code repetition

The code that is written may appear in different parts of the program. It can be vulnerable to various problems because of its location. Programs have variables, which means that they can take on different values at different parts of the program.

· Lack of encapsulation

Its lack of availability in structured programming means that programs will be longer

· Lack of information hiding

Information hiding involves isolating design decisions in a computer program that have the greatest chance to change. This protects other parts of the program from modifications if the design decision is changed.

· Complexity

It's particularly illustrative because it leads to code that's harder to read, harder to write and easier to mess up.

· Error and difficult to change

OOP concepts (OOP) intend to improve code readability and reusability by defining how to structure a Java program efficiently. The main principles of object-oriented programming are:

· Abstraction

Abstraction aims to hide complexity from the users and show them only the relevant information. For example, if you want to drive a car, you don’t need to know about its internal workings. The same is true of Java classes. You can hide internal implementation details by using abstract classes or interfaces. On the abstract level, you only need to define the method signatures (name and parameter list) and let each class implement them in their own way. Then using this OO concept can be reduce the problems of complexity of the software.

· Encapsulation

Encapsulation allows us to protect the data stored in a class from system-wide access.

· Polymorphism

Polymorphism refers to the ability to perform a certain action in different ways. In Java, polymorphism can take two forms: method overloading and method overriding. Method overloading happens when various methods with the same name are present in a class. When they are called they are differentiated by the number, order, and types of their parameters. Method overriding occurs when the child class overrides a method of its parent

· Inheritance

Inheritance makes it possible to create a child class that inherits the fields and methods of the parent class. It Improves code reusability. Therefore we can see OOP concepts are more efficiency, reusability, reliability and secure than Structured programming.

But there are some issues which did not answer yet. OOP is functional programming but it is just hard, it requires more data protection, inability to work with existing systems, larger program size and not suitable for all types of problems-for smaller problems it is in general not suitable etc.

With rapid advancement in technology, OOP concepts also improve with new trends. Such as;

· Stroustrup

When developing system without appropriate libraries, anything significant seems complicated. With appropriate libraries, just about anything becomes manageable. There has been a trend for compiler vendors to let their "object models" and GUI

details shine through to the end user.

· Lindholm

Two driving forces for developers who write code will continue to be networking and distribution. Writing component-oriented software seems to be more about adequate investment, good design, and programmer discipline than about programming languages. Certainly some languages better support writing such software than others. But it would be misguided to expect that a magic new language will make writing components vastly easier than with current languages.

We have also developed many programming paradigms like structure programming, object-based and object-oriented programming and many others. In this direction, Google is working on the development of next generation programming language called "GO Language".

H.M.C.K.Herath

D/SE/18/0010

Object-Oriented Methods

· OO methods are system development approaches that encouraging and facilitating the re-use of software components.

· OO models are used to fill the gap between problem and solution.

· We can use this model when the systems are undergoing continuous design, adaption, and maintenance.

· It employs international standard Unified Modeling Language (UML) from the Object Management Group (OMG).

Structure Programming

· Structured programming is a programming paradigm that facilitates the creation of programs with readable code and reusable components.

· Structured programming encourages dividing an application program into a hierarchy of modules or autonomous elements, which may, in turn, contain other such elements.

· Structured Programming is good for the real-time systems, embedded system, and projects where objects are not the most useful level of abstraction.

Fundamental issues with the Structure Programming

· Modifiability

· adaptation

· Evolution

Object-Oriented Methods based on Information hiding, class and inheritance. So, the way Object-Oriented Methods address those mention methods are as follows,

· Information hiding (Encapsulation)

· Inheritance and classes

are the object-oriented methods address those issues.

è Information hiding method helps to explain the modifiability issue.

è Inheritance and classes explain the adaptation issue

From the above discussion we can understand, Evolution did not get a solution by OO methods yet.

TDRS SILVA

D/SE/18/0024

In the object-oriented approach, the focus is on capturing the structure and behavior of information systems into small modules that combines both data and process. The main aim of Object Oriented Design (OOD) and Object Oriented Analysis (OOA) is to improve the quality and productivity of system analysis and design by making it more usable.

These OO models perform well in a situation where systems are undergoing continuous design, adaption, and maintenance. It identifies the objects in problem domain, classifying them in terms of data and behavior.

there are 03 main fundamental issues in software,

-modifiability

-adaptation

-evolution

- Modifiability and Adaptation is the degree of ease at which changes can be made to a system and the flexibility with which the system adapts to such changes.

Following are the object-oriented methods which address fundamental software issues

OO methods address modifiability by information hiding using the encapsulation process. It is simply the combination of process and data into a single entity. Data of an object is hidden from the rest of the system and available only through the services of the class. It allows improvement or modification of methods used by objects without affecting other parts of a system.

Inheritance is a great feature that allows creating sub-classes from an existing class by inheriting the attributes and/or operations of existing classes.

Abstraction in the OO concept can be used to manage complexity or hide irrelevant data

Future directions of object-oriented methods

we anticipate a wealth of software design knowledge will be captured in the form of patterns and frameworks. These patterns and frameworks will span domains and disciplines such as concurrency, distribution, organizational design, software reuse, real-time systems, business and electronic commerce, and human interface design. we expect the following aspects of patterns and frameworks will receive particular attention.

Object-Oriented programming is a programming philosophy focused on the idea of objects, which in the form of fields and code may contain data in the form of procedures. Ultimately, object-oriented programming is about helping the programmer to manage program complexity in the large. This concept addresses lot of fundamental software issues. Some of the fundamental issues of software are,

1. Security

Design for security is concerned with how to prevent unauthorized disclosure, creation, change, deletion, or denial of access to information and other resources.

2. Same code repetition

Repeating the same code again and again in different methods, which makes the program longer.

3. Complexity

Complexity of programming is a concept that encompasses several properties of a porece of software, all of which influence interaction within. Complexity means being hard to grasp but eventually knowable with time and effort. It defines the the interactions between a number of entities. As the number of entities increases, the number of interactions between them would increase exponentially, and it would get to a point where it would be impossible to know and understand all of them.

How OOP methods address these issues,

· Encapsulation: the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Therefore, it is also known as data hiding. This helps to secure our data.

· Inheritance: it is a mechanism in which one object acquires all the properties and behaviors of a parent object. It helps the program to reduce the code reusing issue.

· Objects : This helps to enhance program modularity because every object exists independently.

· Abstraction: This OOP method helps the program to hide irrelevant data and reduce the complexity of the code.

There are some issues, some problems which OOP could not address, that lend themselves well to functional-programming style, logic-programming style, or procedure-based programming style, and applying object-oriented programming in those situations will not result in efficient programs.

G.M.K.S Karunasekara

D-SE-18-0025

Fundamental issues with the Structure Programming are,

Modifiability

• · Same code repetitions or modifiability The code that is written may appear in different parts of the program.
• · According to OO concepts we can make constructors and objects and use them instead of repeating the same code in the different parts of the program.
• · Programs have variables, which means that they can take on different values at different parts of the program.

Adaptation

• Adaption by using Inheritance and Classes

Evolution

• Evolution is an unsolved one

Complexity

• Summary of the OO concept can be used to manage complexity or to hide data that are not relevant.

Encapsulation

• Encapsulation helps protect data from external interference and misuse.
• Circulation led to important OOP concepts in data hiding

Issues which did not answer yet by OO concepts

• The OO concept is not suitable for all types of problems - it is usually not suitable for small problems.
• Evolution is an unsolved one.
• The future phases of programming will address non-object problems with different models.

Future Trends

• modular programming. –(Structural programming is a subset of procedural programming)
• Threading over simpler easy-to-use abstraction
• Standalone functions
• The removal of null.

Object Oriented Programming provides a clear modular structure for programs. It is good for defining abstract data types. Implementation details are hidden from other modules and other modules has a clearly defined interface. It is easy to maintain and modify existing code as new objects can be created with small differences to existing ones.

Structured programming is a procedural programming subset that reduces the need for go to statements. In many ways, OOP is considered a type of structured programming that deploys structured programming techniques. Certain languages – like Pascal, Algorithmic Language (ALGOL) are designed to enforce structured programming

Fundamental issues in Structured programming

• Lack of encapsulation: Its lack of availability in structured programming means that programs will be longer.
• code repetition: The code that is written may appear in different parts of the program. It can be vulnerable. Programs have variables, which means that they can take on different values at different parts of the program.
• Lack of information hiding: Information hiding involves isolating design decisions in a computer program that have the greatest chance to change.

How OOP can overcome these issues ??

Abstraction is the concept of hiding the internal details and describing things in simple terms. For example, a method that adds two integers. The internal processing of the method is hidden from the outer world. There are many ways to achieve abstraction in object-oriented programming, such as encapsulation and inheritance.

Encapsulation is the technique used to implement abstraction in object-oriented programming. Encapsulation supports information hiding by making use of the three access specifiers of a class. Information hiding is a principle of OOP, where a stable interface is open to the rest of the program while its implementation details are hidden. This is usually achieved in Object Oriented languages (such Java) by controlling access over the methods and fields of a class.

Inheritance encourage code reuse in programming. This is the concept in which we define a class which extends properties and methods from another class. This way new class have all the properties of class from which it is extended and you can add extra properties and methods in your new class.

With designs patterns, SOLID principles and other concepts Object Oriented programming the best solution to overcome most of the issues of structured programming.

Rather than using structured programming using these Object oriented techniques and concepts can make resultant software maintainable, flexible, extendable and reusable.

D.D.D Nandasena

D/SE/18/0031

Basically, as compared to functional programming or even object-oriented programming, structured programming is not very good for crafting abstractions. In essence, structured languages are less expressive. This means that you may end up writing more code to do the same things and, at the same time, admit more mistakes.

Mainly the fundamental issues with the Structure Programming are,

· Modifiability

· Complexity

· adaptation

· Evolution

The code that is composed may show up in various pieces of the program. It tends to be defenseless against different problems because of its location. Variables can take on different values at different parts of the program. By using object oriented concepts, we can make constructors and objects and use them instead of repeating the same code in the different parts of the program. The maintenance cost can be reduce by improving the modifiability of the program. Adaption can be done by using Inheritance and Classes. It's particularly illustrative because it leads to code that's harder to read, harder to write and also harder to modify. It will take more time and as well as more cost.

Future

Evolution did not solve by OO methods yet. But we can assume that the next step of programming will be having different models to address non object problems. Future OOP concepts will be basically depends on, Standalone functions and severe restrictions in inheritance.

W.A.N.Wickramasinghe

D/SE/18/0035

The fundamental issues with the Structural Programming are,

• Modifiability
• adaptation
• Evolution

Structure Programming

In structured programming design, programs are broken into different functions these functions are also known as modules, subprogram, subroutines and procedures.

Each function is design to do a specific task with its own data and logic. Information can be passed from one function to another function through parameters. A function can have local data that cannot be accessed outside the function’s scope. The result of this process is that all the other different functions are synthesized in an another function. This function is known as main function. Many of the high level languages supported structure programming.

Object Oriented Methods

Object Oriented methods are system development approaches that encourage and facilitate the re-use of software components.

The major concepts of Object-Oriented Programming are:

• Object
• Class
• Abstraction
• Inheritance
• Polymorphism
• Encapsulation

Traditionally, programmers would write programs that were called structured programs. The program would be designed to solve one big problem, but the programmers would break the problem down into smaller manageable problems and write small sections of code to solve each one. Object-oriented programming is the natural successor to this traditional way of programming. Instead of simply breaking the problem down into smaller problems, object-oriented programmers break the problem down into objects. The programmer then has to figure out what properties an object needs to function, and the methods necessary. Like most interesting new developments, object-oriented programming builds on some old ideas, extends them, and puts them together in novel ways. Therefore according to the above the evolution of the structural programming hasn't been addressed yet and will be in the future.

G.K Wijeratne

D/SE/18/0002

What are the basic problems related to structural programming and how has OO answered them?

Object-oriented methods are system development methods that facilitate the re usability of software components. Object-oriented models are used to reduce the interval between problems and solutions. It works well in situations where the systems are constantly designed, customized, and maintained.

Identical iterations or code changes

The written code can occur in different parts of the program. Due to its location, it can be vulnerable to various issues. Programs have variables, which means they can have different values in different parts of the program. According to OO concepts, we can create constructors and objects and use them instead of repeating the same code in different parts of the program. We mainly use the concept of inheritance to minimize the amount of duplicate code in an application by sharing common code.

Lack of encapsulation

The lack of availability in structured programming means that the programs will be longer. Under Object-oriented concepts, encapsulation protects an object from unwanted access by customers and provides access to one level without revealing complex details below that level. And it reduces human error and simplifies application maintenance.

Lack of hidden or editable information.

Hiding information is a basic concept in Object-oriented design. Information hiding is used when designing the object, especially to decide which information should be visible and which information should be hidden.

Adaptation

Method Overload provides access to methods that perform similar or closely related functions under a common name.

complexity

Abstraction in the Object-oriented concept can be used to control complexity or hide irrelevant data.

Problems to which the Object-oriented concepts have not yet been answered.

Object-oriented concepts may not be suitable for all kinds of problems; they are generally not suitable for minor problems.

It can be very salable. If OOP is not kept under control, it can cause much bloated unnecessary code.

Evolution is not fully addressed with Object-oriented concepts.

Future programming phases will address issues unrelated to objects with different models.

Future trends in OOP concepts ,

Independent functions.

Simpler summaries than the segment.

D/SE/18/0009

Software design plays an important role in developing a software. During software design process, software engineers produce different types of models which are like blueprints of the solution to be implemented.

There are several key issues which must be dealt with when designing software. Followings can be consider as fundamental issues in software.

· Modifiability

Modifiability is the degree of ease at which changes can be made to a software.

· Adaptation

Adaptation is related to the flexibility with which the software adapts to such changes made under modifiability.

· Evolution

Evolution refers to the process of developing software initially, then timely updating it for various reasons.

Most of these issues occurred due the traditional structured approaches. But Object-Oriented approach is able to address most of these issues.

In the object-oriented approach, it focuses on capturing the structure and behavior of information systems into small modules that combines both data and process. OO approaches comes with different characteristics such as objects, classes, attributes etc. and several great features such as encapsulation(data hiding), abstraction, aggregation, generalization, inheritance etc.

These concepts can be used to address the above mentioned issues of software designing.

For an example issues related to modifiability can be solved with the use of data hiding concept in OO and issues related to adaptation can be solved through the classes and inheritance concepts in OO.

Object Oriented models are used to fill the gap between problem and solution. It performs successfully within the situations where software systems are undergoing continuous design, adaption, and maintenance .

D/SE/18/0004

J.S.A.N.W.Premachandra

Issues of Softwares are regarding with the Software design,software implementations,software testing So as we know before coding we’ve to model our software it means we have to design the software part before coding

So when we talk about the issues basically its modifiability and to support modifiability we use concepts of coupling and cohesion and information hiding So for the reduce couplings,it means reducing the strength of association of a connection from one module to another we can use encapsulation and use wrapper which are some form of encapsulation and raising the abstraction levels

So by increasing ,Cohesion measure the relationship among the responsibilities of module it means it measures how well the lines of code within each module relate to each other.we can increase cohesion by maintain semantic coherence ,by abstract Common Services

Another basic issue is adaptation, In adaptation we have to see about reusability,composable,language independence like that So we acquire reusability by inheritance and composable by composition and basically we use classes in object oriented analysis.as well as we can achieve adaption by method overloading.

When we talk about trends using frameworks that provide wide large scale of reuse and distributed objects,Design patterns like that.

D.SE.18.0008

D.T.Mallikaarachchi

Q-What are the fundamental issues of software and how object-oriented methods address those?

A-

· Modifiability – Info hiding

A major problem with early modular systems is prone to error and difficult to change due to the widespread use of global data. Information hiding provided an approach for greatly reducing, if not eliminating, global data. It is easy to make minor changes in the data representation or the procedures in an OOP. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods

· Adaptation- Inheritance and classes

Inheritance is a way to express a relationship between blueprints (classes). A class is a blueprint or template or set of instructions to build a specific type of object. Therefore inheritance enables new classes to inherit the properties and methods of existing classes.

Ex-to build a new object that is similar to one that is already exists, and instead of creating new class from scratch, to reference the existing class and simply indicate what’s different.

· Evolution

Object-oriented analysis methods apply object-oriented concepts to the analysis phase of the software life cycle. The emphasis is on identifying real-world objects in the problem domain and mapping them to software objects. The initial attempt at object modeling was a static modeling approach that had its origins in information modeling (E-R modeling/semantic data modeling used in logical database design) Static object modeling was also referred to as class modeling and object modeling. It shows classes which objects belong and depicting classes and their relationships on class diagrams.

D/SE/18/0014

The fundamental issues of software are Modifiability, adaptation and evolution

· Modifiability (Information Hiding) - Despite the widespread use of global data, a major issue with early modular systems is prone to error and difficult to modify. The covering of information offered an strategy to significantly minimize global data, if not eradicate it. Making minor changes in the representation of data or the procedures in an OOP is simple. Changes within a class do not impact any other aspect of a system, because the only public access the outside world has to a class is by using methods

· Evolution - Changes within a class do not impact any other aspect of a system, because the only public access the outside world has to a class is by using methods. The initial attempt at object modeling was a static modeling technique that was often referred to as class modeling and object modeling (E-R modeling / semantic data modeling used in logical database design). This tells classes what objects belong on class diagrams and portrays classes and their relationships.

· Adaptation (Inheritance and classes)- Inheritance is a way to convey a blueprint (class) relation. A class is a model or prototype, or collection of instructions for creating an object type. Thus inheritance allows new classes to inherit current class properties and methods. Ex-to create a new object that is identical to one that already exists, and to reference the current class instead of building a new one from scratch, and simply show what's special.

Object-oriented methods address those issues in following ways like,

· Object – The instance or representation of a class

· Class – The blueprint of an object

· Abstraction – Used to manage complexity or hide irrelevant data

· Inheritance – Allow one class to encompass the properties of another

· Polymorphism – Customized interpretation of different behaviors

· Encapsulation – Access control for instance variables and methods

With designs patterns, SOLID principles and other concepts Object Oriented programming the best solution to overcome most of the issues of structured programming. Rather than using structured programming using these Object oriented techniques and concepts can make resultant software maintainable, flexible, extendable and reusable.

Still there are some problems that couldn't be solved by OOP, that lend themselves well to functional-programming style, logic-programming style, or procedure-based programming style, and implementing object-oriented programming in those circumstances does not result in successful programs.

WKCS Kumarasinghe

D/SE/18/0021

Basically, fundamental issues of software can be mainly considered as:

• Modifiability
• Adaption
• Evolution

Object-Oriented methods promotes:

• Information-hiding to address modifiability. Using this concept it is possible to restrict access to specific objects and decide information that is openly available and not.
• Inheritance and classes concepts to address adaptability.

The problem of evolution is however not answered through the OO concepts.

D/SE/18/0029

In the object-oriented approach, the focus is on capturing the structure and behavior of information systems in small units that combine both data and process. The main objective of Object Oriented Design (OOD) is to improve the quality and productivity of system analysis and design by making it more usable.

In the analysis phase, OO models are used to fill the gap between the problem and the solution. It performs well in situations where systems are subject to continuous design, adaptation, and maintenance. Identifies elements in the problem area, and classifies them in terms of data and behavior. The basic OO model is beneficial in facilitating the changes in the system at low cost, Simplifies the design of distributed systems, reuse of components and simplifies the problem of integrating components to configure large system.

The fundamental issues with the Structure Programming are,

· Modifiability- is the degree of ease at which changes can be made to a system, and the flexibility with which the system adapts to such changes.

· Adaptation- Adaptation is related to the flexibility with which the software adapts to such changes made under modifiability.

· Evolution- Evolution refers to the process of developing software initially, then timely updating it for various reasons.

However OO system comes up with different features to address these issues By,

Encapsulation

Abstraction

Inheritance

Polymorphism and Dynamic Binding.

Encapsulation is a process of information hiding. It is simply the combination of process and data into a single entity. It allows improvement or modification of methods used by objects without affecting other parts of a system. Also at the same time Inheritance allows to create sub-classes from an existing class without repetition which will ease the work. Polymorphism is the ability to take on many different forms.

Building complex system by splitting the complexity level by level is another main feature of OO methods.

Applying Abstraction during the design and domain modelling, helps a lot in design the a system which is flexible and maintainable.

• Some of the issues, which did not answer yet by OO concepts.

This is not suitable for simple problems so functions work slower than normal function as there is indirection.Also Improper use of inheritance may lead to wrong solutions.

Often, data members in the base class are left unused which may lead to memory wastage.

It can be too scalable. If OOP is left to run out of control, then it can create a massive amount of bloated unnecessary codes.

The future phases of programming will address non-object problems with different models.

• As the future direction of OO

These patterns and frameworks will span domains and disciplines such as concurrency, distribution, organizational design, software reuse, real-time systems, business and electronic commerce, and human interface design.

D/SE/18/0017

W.M.C.D.K.WEERAKOON

An object-oriented approach is a system development approach that encourages and promotes the reuse of software components. The OO model is used to fill the gap between problems and solutions. This method works well when the system is designed, adjusted, and maintained

continuously.

Fundamental issues of software

Modifiability

Modifiability refers to the ease with which changes can be made to the system and the flexibility of the system to accommodate such changes.

Adaptation

Adaptation in computer science refers to a process where an interactive system adapts its behavior to individual users based on information acquired about its user and its environment.

Evaluation

Evaluation is a process that critically examines a program. It involves collecting and analyzing information about a program's activities, characteristics, and outcomes.

Maintenance

Maintenance in software engineering is the modification of a software product after delivery to correct faults, to improve performance or other attributes

Reusability

Reusability is the use of existing assets in some form within the software product development process; these asset are products and by-products of the software development life cycle and include code, software components, test suites, designs and documentation.

Object oriented methods address those

Modifiability -> information hiding

Adaption -> Classes and inheritances

Evaluation -> Classes and inheritances

Maintenance -> classes and inheritences

Reusability -> Encapsulation

D- SE - 18 - 0032

Issues of Softwares are regarding with the Software design,software implementations,software testing So as we know before coding we’ve to model our software it means we have to design the software part before coding

So when we talk about the issues basically its modifiability and to support modifiability we use concepts of coupling and cohesion and information hiding So for the reduce couplings,it means reducing the strength of association of a connection from one module to another we can use encapsulation and use wrapper which are some form of encapsulation and raising the abstraction levels

So by increasing ,Cohesion measure the relationship among the responsibilities of module it means it measures how well the lines of code within each module relate to each other.we can increase cohesion by maintain semantic coherence ,by abstract Common Services

Another basic issue is adaptation, In adaptation we have to see about reusability,composable,language independence like that So we acquire reusability by inheritance and composable by composition and basically we use classes in object oriented analysis.as well as we can achieve adaption by method overloading.

When we talk about trends using frameworks that provide wide large scale of reuse and distributed objects,Design patterns like that.

I.N. Denipitiya

D/SE/18/0030

D-SE-18-0020 N.W.P Kavishka

What are the fundamental issues of software and how object-oriented methods address those?

the object-oriented approach, the focus is on capturing the structure and behavior of information systems into small modules that combines both data and process. The main aim of Object Oriented Design (OOD) is to improve the quality and productivity of system analysis and design by making it more usable.

In analysis phase, OO models are used to fill the gap between problem and solution. It performs well in situation where systems are undergoing continuous design, adaption, and maintenance. It identifies the objects in problem domain, classifying them in terms of data and behavior.

The OO model is beneficial in the following ways −

 It facilitates changes in the system at low cost.

 It promotes the reuse of components.

 It simplifies the problem of integrating components to configure large system.

 It simplifies the design of distributed systems.

In the object-oriented approach, the focus is on capturing the structure and behavior of information systems into small modules that combines both data and process. The main aim of Object Oriented Design (OOD) is to improve the quality and productivity of system analysis and design by making it more usable.

In analysis phase, OO models are used to fill the gap between problem and solution. It performs well in situation where systems are undergoing continuous design, adaption, and maintenance. It identifies the objects in problem domain, classifying them in terms of data and behavior.

Fundamental issues of a software are

• modifiability
• adaptation
• evolution

Object Oriented methods based on

• information hiding
• classes
• inheritence

Basically these are address like this,

• Modifiability- Info Hiding
• Adaption- Inheritance and clases

PM Sumanasiri

D/SE/18/0034

1. Modifiability

2. Adaptation

3. Evolution

Modifiability is addressed by data hiding.Information or data hiding is a programming concept in Object Oriented method that protects the data from direct modification by other parts of the program. This is called Encapsulation in OOP. In here we can restrict access to whole class or certain data of class. So data can be modified or accessed by define circle of people.

Adaptation addressed by Object oriented method called inheritance.

Inheritance let new classes to inherit the properties and methods of existing classes

With inheritance, we can reuse the fields and methods of the existing class.

. Polymorphism is another method that address this issue.

Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.

Evolution is not yet addressed in object-oriented methods.

D/SE/18/0028

Common fundamental software issues

· Lack of information hiding

Information hiding is a basic concept of object oriented design. It is used in object planning and especially when deciding what information to look for and what to hide.

· Incorrect calculation

This can be seen n functions such as finance and date calculations. The man criteria are mathematical functions and mathematical operators.

· Unreliable results or performance

This means the software that retrieves data from files or tables incorrectly and cannot be trusted to perform correctly every time it is used.

· Incorrect file and data handling

This means the software that retrieves data from files or tables incorrectly.

· Inadequate security control

This means that unauthorized access to the system is not adequately controlled.

· Same code receptions

The code which is written can be appeared in another place of the program.

How object oriented methods address those issues

There are several major concepts of object oriented programming. Such as,

Object

Class

Abstraction

Inheritance

Polymorphism

Encapsulation

Above mentioned OO concepts help with the issues that could occur when dealing with softwares. Object oriented methods basically address information hiding using the encapsulation process. Inheritance is a great feature that allows you to create subclasses of an existing class. Likewise, OO methods address those software issues.

Future Trend

We can identify five major directions that researchers are currently investigating

1. Programming languages

2. Concurrency and distribution

3. Object management

4. Software management

5. User environments

MMK ROWEL

D/SE/18/0022

Object Oriented Methods

It is a system development approach which encourage and facilitate to re use of the software components. OOP concept is used to reduce or to fill the gap between problems and solutions. · It employs international standard Unified Modeling Language (UML) from the Object Management Group (OMG). And also this is applicable while in the continuous design, adaption, and as well as in the maintenance stage.

Structured Programming

It is a top-down approach. This allows the creation of programs with readable code and reusable components. Structured programming encourages dividing an application program into a hierarchy of modules or autonomous elements, which may, in turn, contain other such elements. Structured design programming usually left until end phases. And it is good for the real-time systems, embedded system, and projects where objects are not the most useful level of abstraction.

Fundamental issues with structured programming are;

* Evolution

* Adaptation

* Modifiability

Basically, Object Oriented Methods based on Information hiding, class and inheritance. So Object Oriented Methods address them like follows,

* Modifiability by Info Hiding

* Adaption by using Inheritance and Classes

Therefore, Evolution is the one that did not solve by Object Oriented methods yet

C.B. Kumarage

D/SE/18/0015

The fundamental issues of software • Modifiability, adaptation and evolution are fundamental issues of software. • The maintenance cost is greatly reduce by improving the modifiability. Adaptability is the ability to change the software system according to context variations. Software adaptation is concerned with providing techniques to make arrangements on development of software in order to reuse those in new way. Evolution is the process of developing software and updating it. As an example, we can add or remove some codes in the software. How object – oriented methods address those issues • Information hiding(Encapsulation), Inheritance and classes are the object oriented methods address those issues. Information hiding method helps to clarify the modifiability issue. Inheritance and classes maintain the adaptation issue. • Encapsulation helps to keep the data safe from outside interference and misuse. Encapsulation led to the important OOP concepts of data hiding. Example for encapsulation is a calculator. We don’t have an idea about the mechanism but only the output is shown. • Inheritance helps to derive a class from another class for a hierarchy of classes that share a set of attributes and methods. • Classes is the major concept in OOP. It is user defined data type.

D/SE/18/0007

The fundamental software issues that have to face, Adaption, Modifiability, Evolution.

The main aim of Object Oriented Approch is to improve the quality and productivity of system analysis and design by making it more usable.

And, it focus is on capturing the structure and behavior of information systems into small modules that combines both data and process.

Also, Object Oriented methods based on inheritance, Encapsiulation, Ploimorpism, Abstraction.

So, these are address according those issues as inheridance for adaption and inheritance for modifiability

D-SE-0033

What are the fundamental issues of software and how object oriented methods address those ?

Followings can be consider as fundamental issues in software.

1. Modifiability

2. Adaptation

3. Evolution

4. Security

5. Code repetition

6. Complexity

How OOP methods address these issues:

Object-oriented methods facilitate the re usability of software components and can be used to reduce the interval between problems and solutions. The following concepts can be used to resolve the problems of software.

Encapsulation

Encapsulation is one of the fundamental concepts in object-oriented programming (OOP). It describes the idea of bundling data and methods that work on that data within one unit. This concept is also often used to hide the internal representation, or state, of an object from the outside. Therefore, it is also known as data hiding. This helps to secure our data.

Inheritance:

Inheritance is a mechanism in which one class acquires the property of another class. With inheritance, we can reuse the fields and methods of the existing class. Hence, inheritance facilitates Reusability and is an important concept of OOP. It helps the program to reduce the code reusing issue.

Abstraction:

Abstraction means displaying only essential information and hiding the details. Data abstraction refers to providing only essential information about the data to the outside world, hiding the background details or implementation. This OOP method helps the program to hide irrelevant data and reduce the complexity of the code.

D/SE/18/0003

T.S. Wijesingha

There are few fundamental issues

• Modifiability
• adaptation
• Evolution

In the object-oriented approach, the focus is on capturing the structure and behavior of information systems into small modules that combines both data and process. The main aim of Object Oriented Design (OOD) is to improve the quality and productivity of system analysis and design by making it more usable.

This is how object-oriented methods address those issues:-

Object – The instance or representation of a class

Class – The blueprint of an object

Abstraction – Used to manage complexity or hide irrelevant data

Inheritance – Allow one class to encompass the properties of another

Polymorphism – Customized interpretation of different behaviors

Encapsulation – Access control for instance variables and methods

There are three main fundamentals of software modeling,

· Modifiability

· Adaptation

· Evolution

Modifiability

This means hiding data. Generally, you do not grant users access to all data, so you must avoid using this data for security reasons.

Adaptation

Method overloads access methods that perform similar or similar tasks with common names.

Evolution

Improvement is the first way to create programs that can be easily improved for a variety of reasons.

To overcome those issues in OOP concept we can use

Abstraction

Abstraction is the idea of ​​reducing a concept to its essence in a specific context. A simplified version of a concept can help you better understand the concept.

Inheritance

This is an object or class based on another object or class.

Encapsulation

The circulation can be thought of as putting something in a capsule, limiting its contact with the outside world. In software, data integrity helps restrict access to internal objects and attributes.

Composition

Composition is the principle of combining multiple objects into more complex objects. Instead of directly inheriting the object, you actually create an instance of the object and use its functionality.

So that’s why we used the OOP concept to make better programs.