CN7021- ADVANCED SOFTWARE ENGINEERING

Introduction
1
Literarily, Software Engineering is made of two words that is, Software and Engineering. Where,

software means a collection of executable programming code, associated libraries and documentations

and; engineering on the other hand, is all about developing products, using well-defined, scientific

principles, techniques and approaches. Engineering could preferably be defined as the application of

well-defined, scientific principles, techniques and approaches.

Therefore, Software Engineering is an engineering branch that is related to both computer science and

systems engineering (Sommerville, 2016). It is associated with the development of software

applications (be it software systems or application software) using well-defined scientific principles,

techniques and approaches. The outcome of software engineering is an efficient and reliable software

product and this includes the initial development of software (that is, requirements gathering, software

design, coding or implementation and testing), its maintenance and updates, till desired software

product is developed, which satisfies the expected requirements.

Software Engineering considers building, maintaining and evolving software systems. Fundamentally,

it is a set of problem-solving skills, methods, techniques and technology applied in a variety of domains

to create and evolve useful software systems that solve practical problems.

Objectives

By the end of this week, you should be able to:

 Understand what software engineering is.

 Understand software crisis.

 Explain the goals of software engineering.

 Explain the principles of software engineering.

 Know who a software engineer is and the various tasks of a software engineer.
1
 CN7021- ADVANCED SOFTWARE ENGINEERING

 Explain the manifestation of software crisis

 Explain the causes of software engineering crisis.

 Explain the solution to software crisis.

 Know Software Engineering Code of Ethics and Professional Practice

What is Software Engineering?

Methods for designing and maintaining high-quality applications to solve problems in a systematic way

(Pfleeger, 1990).

The principles and methodologies for designing and maintaining software systems are studied in this

course (Zelkowitz, 1978).

Definition 1:

1) The application of a systematic, disciplined, quantifiable approach to the development,

operation, and maintenance of software; that is, the application of engineering to software.

2) The study of approaches as in the above statement (IEEE 1990).

Definition 2:

“The establishment and use of sound engineering principles in order to obtain economically software

that is reliable and work efficiently on real machines (Bauer, 1972)”.

Definition 3:

“An engineering discipline that is concerned with all aspects of software production from the early stages

of system specification through to maintaining the system after it has gone into use” (Sommerville, 2016).

In this definition, there are two key phrases:

1) Engineering discipline Engineers make things work. They apply theories, methods, and tools

where these are appropriate. However, they use them selectively and always try to discover

solutions to problems even when there are no applicable theories and methods. Engineers also

recognize that they must work to organizational and financial constraints so they look for

solutions within these constraints.

2) All aspects of software production. Software engineering is not just concerned with the

technical processes of software development. It also includes activities such as software project

2
 CN7021- ADVANCED SOFTWARE ENGINEERING

management and the development of tools, methods, and theories to support software

production.

Definition 4:

Software engineering is to “devise methodologies that are founded on the notion of evolution;” that is,

the notion that software systems continually change, new software systems are built from the old ones,

and . . . all must interoperate and cooperate with each other (Dayani-Fard, 1999)”.

The process of developing a software product using software engineering principles and methods is

referred to as Software Evolution. This includes the initial development of software and its maintenance

and updates, till desired software product is developed, which satisfies the expected requirements.

Software Crisis

The term software crisis was used in the early days of software engineering that is in early of the 1960s,

1970s, and 1980s. It was used to describe the impact of prompt increases in computer power and the

difficulty of the problems which could be tackled. In essence, it refers to the difficulty of developing

valid, maintainable, reliable and verifiable software applications or projects. The sources of the software

crisis are complexity, expectations, and change coupled with unprofessionalism (especially the lack of

expertise in producing sound user requirements, design, model and design, model, proper software

testing procedure).

Conflicting requirements has always hindered software development process. For instance, while users

demand a large number of features, customers generally want to minimize the amount they must pay

for the software and the time required for its development. When all these factors are not professionally

handled then, crisis arise.

The term “software crisis” was first coined by F. L. Bauer at the first NATO Software Engineering

Conference in 1968 at Garmisch, Germany. The term was used early in Edsger Dijkstra's 1972 ACM

Turing Award Lecture.

The major cause of the software crisis is that the machines have become more powerful! This implied

that: as long as there were no machines, programming was no problem at all; when there were few weak

computers, programming became a mild problem, and now with huge computers, programming has

equally become a huge problem. The crisis manifested itself in several ways that include:
3
 CN7021- ADVANCED SOFTWARE ENGINEERING

1) Software projects running over-budget or costly.

2) Software running over-time.

3) Software was very inefficient.

4) Software was of low quality.

5) Software often did not meet requirements.

6) Software projects were unmanageable and code difficult to maintain.

7) Software projects was never delivered in due time.

Why is it essential to apply Software Engineering to Systems?

Various scientific and engineering oriented processes and methodologies have been developed over the

last few decades by researchers to stop the software crisis, with varying degrees of success. These

various scientific and engineering oriented processes and methodologies are what software engineering

brought to suppress a widespread talk of a crisis in software production which, eventually led to the

Software Crisis 1.0. The different methods, and processes fit within a plan of action called a process

model. Week 4 is about methods, and processes. When they are applied suitably to projects then they

will provide:

1) An easy-to-understand system creation process.

2) Systems and applications that are easy to manage and modify.

3) Reliable applications and systems.

4) Software projects running friendly budget.

5) Software that are very efficient.

6) Software with high quality.

7) Software meeting user requirements.

8) Software projects delivered in due time.

Software Engineering tackles a variety of issues.

1) How do we satisfy rising demand while staying within budget?

2) How do we ensure that the software we create is of high quality?

3) What should we do to prevent potentially disastrous time delays?

4
 CN7021- ADVANCED SOFTWARE ENGINEERING

4) How do we choose suitable methods to develop a given project knowing fully that small or

medium-scale projects are not suitable when it comes to the development of large-scale or

complex projects?

5) How do we cope with changes in software development that are unavoidable?

6) How do we cope with informal communications that take up a considerable portion of the time

spent on software projects?

7) How do we cope with users who generally have only a vague idea about the scope and

requirements of a software system needed to be developed?

Principles of Software Engineering

The principles of software engineering include: Abstraction, information hiding (encapsulation),

modularity, interoperability, localization, uniformity, and completeness (Sommerville, 2016).

1) Abstraction: What is Abstraction?

a. A general idea rather than one relating to a particular object.

b. A mode of thought: concentrate on general rather than on the specific manifestation or

realization of these ideas.

Kinds of Abstraction

 Every programming language provides an abstraction of machine code

 Higher levels of abstraction:

o Data: abstract data types – what the data objects stand for and what operations can be

applied to them, not how they are represented on physical storage or their actual

representation.

 Sets can be implemented in many ways with vastly different properties

o Control: captures the order in which commands are performed or values are being

accessed

o Procedural: what does a procedure (or function) do?

 How is essential only when we implement and analyze it

5
 CN7021- ADVANCED SOFTWARE ENGINEERING

 We shall focus on procedural abstractions, but first...

2) Encapsulation: it is a fundamental concept that bundles data with the methods that operate on the

data. Encapsulation is used to hide the values and state of a structured data object inside a class in

case of an object oriented programming paradigm. This prevents the values and state form

unauthorized parties’ direct access to them.

3) Modularity: it is a general software development concept that involves separating a program’s unit

into independent pieces or building blocks, each containing all parts needed to execute a single

aspect of the functionality.

Using this approach a large complex problem is broken down into sub-problems, and if necessary

these are further divided until the tasks to be solved are simpler or easier for programming code to

be developed. It is a Top-Down Design in achieving stepwise refinement of the functionality of a

program.

Why Modular Programming?

Modularity is the process of dividing a complex system into modules or components (Pressman &

Maxim, 2015). It provides a mechanism for realizing the philosophy of separation of concern. Most

of the programs written at the ordinary and advanced level courses are likely to be short; however,

in the IT arena most problems will require thousands, if not millions of lines of code. (Windows

2000 – over 35 million lines of code). The importance of dividing a problem into a series of self-

contained modules then becomes obvious.

With modular programming;

1. A problem to be split in stages and for a team of programmers to work on the problem, also

enabling a faster solution.

2. Senior programmers can be given the more complex modules to write, and the junior

programmers the simpler ones.

3. Program modification is easier since changes can be isolated to specific modules.

4. Modules can be tested and debugged independently.

6
 CN7021- ADVANCED SOFTWARE ENGINEERING

5. Since a module performs a specific well defined task, it is possible to develop and place

commonly used modules in a user library so that they can be accessed by different programs.

(E.g. Validation, Uppercase, Text color…Pascal). If a programmer cannot continue through the

entire project, it is easier for another programmer to continue working on self-contained

modules.

6. It improves the maintainability and reliability of a program

Example of modularized system is represented in Figure 1 where an automated teller system is

represented. From the figure, each box (node) in the chart represents a block of code called a

module. The root node (box at the top) represents the main section of the program. Each connecting

line represents a call to a module. The connecting lines could be variables (data) which are passed

to and from modules.

4) Interoperability: Since there are various applications out there developed with different technologies

and platforms. The need for free and easy exchange of information among them becomes essential.

The ability of applications to exchange and make use of information is called interoperability.

5) Localization: is the process of adapting or translating software to a specific locale’s language,

culture, and legal requirements. In some cases, localization may require modifications to the user-

visible components of software. These components include user interface, images, graphics, and

documentation.

What is the reason for the high cost of software?

Hardware has progressed significantly. However, software has come a long way... We work on the

software functions that are the least known. Why should a basic and well-understood role be encoded

in hardware? Increase your demand for apps, think about your mobile phone.

7
 CN7021- ADVANCED SOFTWARE ENGINEERING

Figure 1.1 The cost of software production (Douglas, 2005)

The number of services continues to increase.

Simple: 1 month, 1 programmer, 500 lines of code – introductory programming assignments

• Small: 2 years, 3 programmers, 50K LOC – Nuclear power plant, pacemaker

• Really small: 4 months, 1 programmer, 2000 LOC – Course project

• Medium: 3 years, tens of programmers, 100K LOC – compiler optimization

• Large: 5 years, 100s of programmers, 1M LOC – MS Word, Excel

• Very large: 10 years, 1000s of programmers, 10M LOC – Air traffic control, telecommunications,

space shuttle

• Very, Very Large: 15+ years, 1000s programmers, 35M LOC – W2K

• Ultra-Large Scale: ? years, ? developers distributed, 1000s of sensors, decision units,

heterogeneous platforms, decentralized control. Intelligent transportation systems; healthcare

systems

Software Evolution

Software Evolution commences from the requirements gathering process. After which developers create

a prototype of the intended software and show it to the users to get their feedback at the early stage of

the software product development. The users suggest changes, on which several consecutive updates

and maintenance keep on changing too. This process changes to the original software, till the desired

software is accomplished.

8
 CN7021- ADVANCED SOFTWARE ENGINEERING

Even after the user has the desired software in hand, the advancing technology and the changing

requirements force the software product to change accordingly. Re-creating software from scratch and

to go one-on-one with the requirement is not feasible. The only feasible and economical solution is to

update the existing software so that it matches the latest requirements.

Software Evolution Laws

1) Lehman has given laws for software evolution. He divided the software into three different

categories: Static-type (S-type) - This is a software, which works strictly according to defined

specifications and solutions. The solution and the method to achieve it, both are immediately

understood before coding. The s-type software is least subjected to changes hence this is the

simplest of all. For example, calculator program for mathematical computation.

2) Practical-type (P-type) - This is a software with a collection of procedures. This is defined by

exactly what procedures can do. In this software, the specifications can be described but the

solution is not obviously instant. For example, gaming software.

3) Embedded-type (E-type) - This software works closely as the requirement of real-world

environment. This software has a high degree of evolution as there are various changes in laws,

taxes etc. in the real-world situations. For example, online trading software.

E-T ype software evolution

Lehman has given eight laws for E-Type software evolution -

1) Continuing change - An E-type software system must continue to adapt to the real-world

changes, else it becomes progressively less useful.

2) Increasing complexity - As an E-type software system evolves, its complexity tends to increase

unless work is done to maintain or reduce it.

3) Conservation of familiarity - The familiarity with the software or the knowledge about how it

was developed, why was it developed in that particular manner etc., must be retained at any

cost, to implement the changes in the system.

4) Continuing growth- In order for an E-type system intended to resolve some business problem,

its size of implementing the changes grows according to the lifestyle changes of the business.

9
 CN7021- ADVANCED SOFTWARE ENGINEERING

5) Reducing quality - An E-type software system declines in quality unless rigorously maintained

and adapted to a changing operational environment.

6) Feedback systems- The E-type software systems constitute multi-loop, multi-level feedback

systems and must be treated as such to be successfully modified or improved.

7) Self-regulation - E-type system evolution processes are self-regulating with the distribution of

product and process measures close to normal.

8) Organizational stability - The average effective global activity rate in an evolving E-type system

is invariant over the lifetime of the product.

What is the purpose of software engineering?

As starting point, to improve software quality and maintainability. Secondly, to meet growing demands.

Furthermore, to reduce software costs. In addition to effectively build massive, complex software

systems. Last but not least, to promote community effort in software development

Software development has been for centuries but, little or no application of scientific and engineering

principles, techniques and approaches of Engineering to software development was considered.

Software development was more of art than science. This led to the Software Crisis 1.0. The term

software crisis was first coined in 1958, but within 10 years, problems in software’s development and

delivery led to the phrase software crisis (Naur, 1968). Software Crisis 1.0 became rampant in the 1960s,

with software taking longer and costing more to develop than estimated, and not working very well

when eventually delivered.

During this software crisis era, software products faced some challenges that affect their operational,

transitional and maintainability characteristics.

Software Engineering Phases

1) Definition: What? Description and review of requirements, the developer must be aware of

the following: Application domain, required features, required output, and user interface.

Planning a project entails allocating money, calculate costs, define job responsibilities and

provide a timetable. Analyze the system, assign device resources to the following:

Hardware, Software and Users.

10
 CN7021- ADVANCED SOFTWARE ENGINEERING

2) Development: How? Define modular modules and major data structures in detailed design.

Define algorithms and procedural information. Software design. User experience design is a

high-level design. Coding, write code for a variety of purposes. Unit checking for each

module, Integration, module combination and system checking.

3) Maintenance: Managing change. Adaptation, updates, new hardware, new business policies.

Correction, fix program defects. Enhancement, adding features. Prevention, making it easier

to manage.

4) Umbrella Activities: Throughout lifecycle. Version control, monitor changes. Reviews,

ensure quality. Documentation, boost maintainability. Configuration management entails

maintaining the dignity of a group of components.

Software development protocol that follows a step-by-step process and includes the following major

phases, research, development, coding, testing.

Process models

Views of the method that are idealized. Different models are often used for different sub processes, for

example, the spiral model (in Figure 1.4) can be used for overall growth, prototyping (in Figure 1.3) for

a particularly complex component, and the waterfall model (in Figure 1.2) for other components.

Figure 1.2. Waterfall Model (Douglas, 2005)

11
 CN7021- ADVANCED SOFTWARE ENGINEERING

Figure 1.3 Prototyping Model (Hans, 2007)

Figure 1.4 Spiral Model (Sommerville, 2016)

When can prototyping be used?

Assist the customer in defining their needs, have a concrete model to "try out", this is often achieved via

the user interface. Look at alternative methods for a problematic component, for example, see whether a
12
 CN7021- ADVANCED SOFTWARE ENGINEERING

method produces satisfactory results. Boost morale, a partially operational framework offers insight into

a project.

Agile methods

Flexibility is emphasized in the production of software that is both fast and capable. Agile manifesto,

focus on customer collaboration rather than contract negotiation (Sommerville, 2016), value people and

experiences over processes and resources, choose to spend time in creating working applications rather

than detailed documentation.

Examples of Agile Methodologies:

1) Extreme programming (XP). Four characteristics of agility are highlighted:

1. Communication: continuous interaction between customers and developers.

2. Simplicity: choose the simplest concept or implementation.

3. Courage: commit to delivering features early and often.

4. Feedback: feedback loops built into the various development activities.

Facets of XP, the game of preparation (customer defines value), simple design, writing tests

first, small release, metaphor (common vision, common names), refactoring pair programming,

collective ownership, continuous integration (small increments), sustainable rate (40 hours per

week) and on-site customer.

When Does extreme become too extreme?

Requirements expressed as a set of test cases must be passed by the software, a vulnerability if

one of them is changed. Requirements expressed as a set of test cases must be passed by the

software, refactoring problem, reworking a device without degrading its design is difficult.

2) Crystal: a series of methods focused on the idea that each project needs its own set of policies

and conventions.

3) Agile software development: 30-day iterations; various self-organizing teams; regular

"scrum" teamwork (ASD)

Why is it so difficult to create software?

Contact, between the client and the developer. The most common cause of failed software projects is

poor problem definition within the development team. Better people equals more communication. New
13
 CN7021- ADVANCED SOFTWARE ENGINEERING

programmers need training. Project characteristics, novelty, changing requirements 5 times the cost of

production and up to 100 times the cost of maintenance. Security requirements. Real-time requirements.

Reliability requirements. Hardware/software configuration.

Facilities and equipment, identification, acquisition. Management problems, realistic targets, cost

estimate, scheduling, resource distribution, quality assurance, version control, contracts. Personnel

attributes, capacity, prior knowledge, communication skills, team cooperation, training.

Operational Characteristic

This tells us how well the software works in operations. It can be measured on:

1) Budget or Cost

2) Usability: is assessed by considering human factors, overall aesthetics, consistency, and

documentation (Pressman and Maxim, 2015).

3) Efficiency

4) Correctness

5) Functionality

6) Reliability: measurement of the frequency and severity of failure, the accuracy of output results,

the mean-time-to-failure (MTTF)-the ability to recover from failure, and the predictability of the

program (Pressman and Maxim, 2015).

7) Security

8) Safety

Transitional Characteristic

This aspect is important when the software is moved from one platform to another:

1) Portability

2) Interoperability

3) Reusability

4) Adaptability

Maintainability Characteristic

This aspect briefs about how well the software has the capabilities to maintain itself in the ever- changing

environment:
14
 CN7021- ADVANCED SOFTWARE ENGINEERING

1) Modularity

2) Maintainability

3) Flexibility

4) Scalability

In short, Software engineering is a branch of computer science, which is expected to use well-defined

engineering concepts required to produce efficient, durable, scalable, cost effective, and on-time software

products. Although, constructing software is a challenging task, because software is complex. However,

when software engineering is applied to software product’s development then we expect a product with

characteristics that include:

1) meeting users’ needs

2) low cost of production

3) high performance

4) portability

5) low cost of maintenance

6) high reliability

7) delivery on time

8) high maintainability

Moreover, the need of software engineering arises because of higher rate of change in user requirements

and environment on which the software is working. Following are some of the needs stated:

1) Large software - It is easier to build a wall than a house or building, likewise, as the size of the

software becomes large, engineering has to step to give it a scientific process.

2) Scalability- If the software process were not based on scientific and engineering concepts, it

would be easier to re-create new software than to scale an existing one.

3) Cost- As hardware industry has shown its skills and huge manufacturing has lower down the

price of computer and electronic hardware. But, cost of the software remains high if proper

process is not adapted.

4) Dynamic Nature- Always growing and adapting nature of the software hugely depends upon

the environment in which the user works. If the nature of software is always changing, new
15
 CN7021- ADVANCED SOFTWARE ENGINEERING

enhancements need to be done in the existing one. This is where the software engineering plays

a good role.

5) Quality Management- Better process of software development provides better and quality

software product.

Who is a Software Engineer?

As computers have a central and growing role in commerce, industry, government, medicine, education,

entertainment and society at large, software engineers are those who contribute by direct participation

or by teaching, to the analysis, specification, design, development, certification, maintenance and testing

of software systems.

A software engineer is an individual who applies the principles of software engineering to the analysis,

design, development, testing, and evaluation of a software project in order to meet with user’s or

customer’s requirements. A software engineer can design both data and architecture, the job is often

allocated to specialists when large, complex systems are to be built. The engineer fully analyzes,

designs, models and implement software, there after tests, debugs and maintains it (Pressman and

Maxim, 2015). Software engineer needs knowledge of varieties of computer programming languages

and applications; to enable him cope with the varieties of works before him or her as user’s

programming language choice flies with time.

Functions of a Software Engineer

A software engineer (Pressman and Maxim, 2015):

1) Analyses information to determine, recommend, and plan computer specifications and layouts, and

peripheral equipment modifications.

2) Analyses user needs and software requirements to determine feasibility of design within time and

cost constraints.

3) Coordinates software system installation and monitor equipment functioning to ensure

specifications are met.

4) Analyses, designs, models, implements and modifies software systems, using scientific analysis and

models to predict and measure outcome and consequences of design.

5) Determines system performance standards.

6) Develops and direct software system testing and validation procedures, programming, and

documentation.

7) Modifies existing software to correct errors; allow it to acclimatize to new hardware, or to improve

its performance.

8) Obtains and evaluates information on factors such as reporting formats required, costs, and security

needs to determine hardware configuration.

Software Engineering Code of Ethics and Professional Practice

Although not bound by laws but there are some standards of acceptable behavior bound by the more tenuous

notion of professional responsibility. Some of these are:

1) Respect for the confidentiality of employers or clients irrespective of whether or not a formal

confidentiality agreement has been signed.

2) No misrepresentation of competence. A software engineer should not knowingly accept work that is

outside your competence.

3) Respect for local laws governing the use of intellectual property such as patents and copyright.

4) A software engineer should not use your technical skills to misuse other people’s computers. Computer

misuse ranges from relatively trivial (e.g. game playing on an employer’s machine, say) to extremely

serious (like dissemination of viruses or other malware)

As regards those standards bound by laws, professional societies and institutions have an important role

to play in setting ethical standards. Organizations such as the ACM, the IEEE (Institute of Electrical and

Electronic Engineers), and the British Computer Society publish a code of professional conduct or code

of ethics. Members of these organizations undertake to follow that code when they sign up for

membership. These codes of conduct are generally concerned with fundamental ethical behavior. For

instance, professional associations, notably the ACM and the IEEE, cooperated to produce a joint code

of ethics and professional practice (Sommerville, 2011). Software engineers shall commit themselves to

making the analysis, specification, design, development, testing and maintenance of software a beneficial

and respected profession. In accordance with their commitment to the health, safety and welfare of the

public, software engineers shall adhere to the following eight Principles:

1) Public: Software engineers shall act consistently with the public interest.

17
 CN7021- ADVANCED SOFTWARE ENGINEERING

2) Client and Employer: Software engineers shall act in a manner that is in the best interests of

their client and employer consistent with the public interest.

3) Product: Software engineers shall ensure that their products and related modifications meet the

highest professional standards possible.

4) Judgment: Software engineers shall maintain integrity and independence in their professional

judgment.

5) Management: Software engineering managers and leaders shall subscribe to and promote an

ethical approach to the management of software development and maintenance.

6) Profession: Software engineers shall advance the integrity and reputation of the profession

consistent with the public interest.

7) Colleagues: Software engineers shall be fair to and supportive of their colleagues.

8) Self: Software engineers shall participate in lifelong learning regarding the practice of their

profession and shall promote an ethical approach to the practice of the profession.

The rationale behind this code is summarized in the first two paragraphs of the longer form

(Sommerville, 2016).

Computers have a central and growing role in commerce, industry, government, medicine, education,

entertainment and society at large. Software engineers are those who contribute by direct participation

or by teaching, to the analysis, specification, design, development, certification, maintenance and

testing of software systems. Because of their roles in developing software systems, software engineers

have significant opportunities to do well or cause harm, to enable others to do well or cause harm, or to

influence others to do well or cause harm. To ensure, as much as possible, that their efforts will be used

for good, software engineers must commit themselves to making software engineering a beneficial and

respected profession. In accordance with that commitment, software engineers shall adhere to the

following Code of Ethics and Professional Practice.

The Code contains eight Principles related to the behavior of and decisions made by professional

software engineers, including practitioners, educators, managers, supervisors and policy makers, as well

as trainees and students of the profession. The Principles identify the ethically responsible relationships

in which individuals, groups, and organizations participate and the primary obligations within these
18
 CN7021- ADVANCED SOFTWARE ENGINEERING

relationships. The Clauses of each Principle are illustrations of some of the obligations included in these

relationships. These obligations are founded in the software engineer’s humanity, in special care owed

to people affected by the work of software engineers, and the unique elements of the practice of software

engineering. The Code prescribes these as obligations of anyone claiming to be or aspiring to be a

software engineer.

In conclusion, the software lifecycle includes the following steps: definition (what), how to grow, how

to maintain (change). Different process models focus on various aspects. Maintainability of the waterfall

model. Prototype model: specifications clarification. Spiral model for risk assessment. The cost of

maintenance is much higher than the cost of production. Bottom Line, software in the United States is

a critical component of our societal infrastructure, costing upwards of $200 billion per year. There is a

need to – Improve software efficiency – Lower software costs and risks.

Conclusion

In this week, we have learnt that software engineering is the application of a systematic, disciplined,

quantifiable approach to the development, operation, and maintenance of software project, and the study

of these approaches. In a nutshell, it is the application of engineering principles and techniques to

software development process. Also, we learnt the principles (Abstraction, Information Hiding,

Modularity, Localization, Uniformity, and Completeness), a software engineer as an individual who

applies the principles of software engineering to the design, development, testing, and evaluation of the

software and systems in order to meet with client’s requirements as well as his functions. Finally, we

learnt the code of ethics and professional practice in software engineering. Next week, we shall begin

with the consideration of one of the quantitative approaches in software engineering that help to yield

a maintainable, reliable, and cost effective software product.

References

1. Bauer, F.L. (1972). Definition of software engineering. Munich.

2. Dayani-Fard, H. (1999). Legacy Software Systems: Issues, Progress, and Challenges. IBM

Technical Report.

3. Douglas, B. (2005). Software Engineering for Students. 4th Edition. Pearson Education Limited

4. Han, V. (2007). Software Engineering: Principles and Practice. Wiley

5. IEEE. (1990). 610.12-1990: IEEE Standard Glossary of Software Engineering Terminology.

6. Naur, P. B. (1968). Software Engineering: A Report on a Conference Sponsored by the

NATO Science Committee. IEEE Computer Society Randell.

7. Pfleeger, S.H. (1990). Software Engineering: Methods and Management. Belmont.

8. Pressman, R. S. and Maxim, B. R. (2015). Software Engineering: A Practitioner’s Approach. 8th

Edition. McGraw-Hill Education, 2 Penn Plaza, New York, NY 10121.

9. Sommerville, I. (2016). Software Engineering (10th Ed.). Harlow. Pearson Education.

10. Zelkowitz, M.V. (1978). Perspectives on Software Engineering. ACM Computing Surveys.

20