SEN 201

INTRODUCTION TO SOFTWARE ENGINEERING

Basic Concept of Software Engineering
Introduction
The Computer system has two major components namely hardware and software. The hardware
component is physical (can be touched or held). The non physical part of the computer system is
the software. As the voice of man is non-physical yet it so important for the complete
performance of man, so is the software. In this unit, the categories of software are examined.
Computer software is a general name for all forms of programs. A program itself is a sequence
of instruction which the computer follows to perform a given task.
Types of software
Software can be categorised into three major types namely system software, programming
software and application software..
System software System software helps to run the computer hardware and the entire computer
system. It includes the following:
• Device drivers
• Operating systems
• Servers
• Utilities
• Windowing systems
The function of systems software is to assist the applications programmer from the details of the
particular computer complex being used, including such peripheral devices as communications,
printers, readers, displays and keyboards, and also to partition the computer's resources such as
memory and processor time in a safe and stable manner
Programming software Programming software offers tools to assist a programmer in writing
programs, and software using different programming languages more conveniently. The tools
include:
• Compilers
• debuggers
• Interpreters
• Linkers
• Text editors
Application software: Application software is a class of software which the user of computer
needs to accomplish one or more definite tasks. The common applications include the following:
• Industrial automation
• Business software
• Computer games
• Quantum chemistry and solid state physics software
• Telecommunications (i.e., the internet and everything that flows on it)
• Databases
• Educational software
• Medical software
• Military software
• Molecular modeling software
• Photo-editing
• Spreadsheet
• Word processing
• Decision making software

What is Software Engineering?

Introduction
Software Engineering is the application of engineering to software. This unit looks at its goals
and principles
Definition of Software Engineering.
Software engineering is the application of a systematic, disciplined, quantifiable approach to the
development, operation, and maintenance of software, and the study of these approaches. In
other words, it is the application of engineering to software.
Sub-disciplines of Software engineering
Software engineering can be divided into ten sub-disciplines. They are as follows:
• Software requirements: The elicitation, analysis, specification, and validation of requirements
for software.
• Software design: Software Design consists of the steps a programmer should do before they
start coding the program in a specific language.It is usually done with Computer-Aided Software
Engineering (CASE) tools and use standards for the format, such as the Unified Modeling
Language (UML).
• Software development : It is construction of software through the use of programming
languages.
• Software testing Software Testing is an empirical investigation conducted to provide
stakeholders with information about the quality of the product or service under test.
• Software maintenance: This deals with enhancements of Software systems to solve the
problems the may have after being used for a long time after they are first completed..
 • Software configuration management: is the task of tracking and controlling changes in the
software. Configuration management practices include revision control and the establishment of
baselines.
• Software engineering management: The management of software systems borrows heavily
from project management.
Software development process : A software development process is a structure imposed on the
development of a software product. There are several models for such processes, each describing
approaches to a variety of tasks or activities that take place during the process.
• Software engineering tools, (CASE which stands for Computer Aided Software Engineering)
CASE tools are a class of software that automates many of the activities involved in various life
cycle phases.
• Software quality: The totality of functionality and features of a software product that bear on
its ability to satisfy stated or implied needs.

Software Engineering Goals and Principles

Goals
Stated requirements when they are initially specified for systems are usually incomplete. Apart
from accomplishing these stated requirements, a good software system must be able to easily
support changes to these requirements over the system's life. Therefore, a major goal of software
engineering is to be able to deal with the effects of these changes. The software engineering
goals include:
• Maintainability: Changes to software without increasing the complexity of the original system
design should be possible.
• Reliability: The software should be able to prevent failure in design and construction as well as
recover from failure in operation. In other words, the software should perform its intended
function with the required precision at all times.
• Efficiency: The software system should use the resources that are available in an optimal
manner.
• Understandability: The software should accurately model the view the reader has of the real
world. Since code in a large, long-lived software system is usually read more times than it is
written, it should be easy to read at the expense of being easy to write, and not the other way
around.
Principles
Sounds engineering principles must be applied throughout development, from the design phase
to final fielding of the system in order to attain a software system that satisfies the above goals.
These include:
• Abstraction: The purpose of abstraction is to bring out essential properties while omitting
inessential detail. The software should be organized as a ladder of abstraction in which each level
of abstraction is built from lower levels. The code is sufficiently conceptual so the user need not
have a great deal of technical background in the subject. The reader should be able to easily
follow the logical path of each of the various modules. The decomposition of the code should be
clear.
• Information Hiding: The code should include no needless detail. Elements that do not affect
other segment of the system are inaccessible to the user, so that only the intended operations can
be performed. There are no "undocumented features".
• Modularity: The code is purposefully structured. Components of a given module are logically
or functionally dependent.
• Localization: The breakdown and decomposition of the code is rational. Logically related
computational units are collected together in modules.
• Uniformity: The notation and use of comments, specific keywords and formatting is consistent
and free from unnecessary differences in other parts of the code.
• Completeness: Nothing is deliberately missing from any module. All important or relevant
components are present both in the modules and in the overall system as appropriate.
• Confirm ability: The modules of the program can be tested individually with adequate rigor.
This gives rise to a more readily alterable system, and enables the reusability of tested
components.
Summary
• Software engineering is the application of a systematic, disciplined, quantifiable approach to
the development, operation, and maintenance of software, and the study of these approaches. In
other words, it is the application of engineering to software.
• The goals of Software engineering include: Maintainability, Reliability, Efficiency,
Understand ability.
• The principles of software engineering include: Abstraction, Information Hiding,
Modularity, Localization, Uniformity, Completeness, Confirm ability
Overview of Software Engineering.
In the 1968, software engineering originated from the NATO Software Engineering Conference.
It came at the time of software crisis. The field of software engineering has since then been
growing gradually as a study dedicated to creating qualified software. In spite of being around
for a long time, it is a relatively young field compared to other fields of engineering. Though
some people are still confused whether software engineering is actually engineering because
software is more of invisible course. Although it is disputed what impact it has had on actual
software development over the last more than 40 years, the field's future looks bright according
to Money Magazine and Salary.com who rated "software engineering" as the best job in America
in 2006.
The early computers had their software wired with the hardware thereby making them to be
inflexible because the software could not easily be upgraded from one machine to another. This
problem necessitated the development. Programming languages started to appear in the 1950s
and this was also another major step in abstraction. Major languages such as FORTRAN,
ALGOL, and COBOL were released in the late 1950s to deal with scientific, algorithmic, and
business problems respectively. E.W. Dijkstra wrote his seminal paper, "Go To Statement
Considered Harmful", in 1968 and David Parnas introduced the key concept of modularity and
information hiding in 1972 to help programmers deal with the ever increasing complexity of
software systems. A software system for managing the hardware called an operating system was
also introduced, most notably by Unix in 1969. In 1967, the Simula language introduced the
object-oriented programming paradigm.
The technological advancement in software has always been driven by the ever changing
manufacturing of various types of computer hardware. The more the new technologies upgrade,
from vacuum tube to transistor, and to microprocessor were emerging, the more the necessity to
upgrade and even write new software. In the mid 1980s software experts had a consensus for
centralised construction of software with the use of software development Life Cycle from
system analysis. This period gave birth to object-oriented programming languages. Open-source
software started to appear in the early 90s in the form of Linux and other software introducing
the "bazaar" or decentralized style of constructing software.[10] Then the Internet and World
Wide Web hit in the mid 90s changing the engineering of software once again. Distributed
Systems gained sway as a way to design systems and the Java programming language was
introduced as another step in abstraction having its own virtual machine. Programmers
collaborated and wrote the Agile Manifesto that favored more light weight processes to create
cheaper and more timely software.
Evolution of Software Engineering
There are a number of areas where the evolution of software engineering is notable:
• Professionalism: The early 1980s witnessed software engineering becoming a full-fledged
profession like computer science and other engineering fields.
• Impact of women: In the early days of computer development ( 1940s, 1950s, and 1960s,),
the men were found in the hardware sector because of the mental demand of hardwaring heavy
duty equipment which was too strenuous for women. The witing of software was delegated to
the women. Some of the women who were into many programming jobs at this time include
Grace Hopper and Jamie Fenton. Today, many fewer women work in software engineering than
in other professions, this reason for this is yet to be ascertained.
• Processes: Processes have become a great part of software engineering and re praised for their
ability to improve software and sharply condemned for their potential to narrow programmers. •
Cost of hardware: The relative cost of software versus hardware has changed substantially over
the last 50 years. When mainframes were costly and needed large support staffs, the few
organizations purchasing them also had enough to fund big, high-priced custom software
engineering projects. Computers can now be said to be much more available and much more
powerful, which has a lot of effects on software. The larger market can sustain large projects to
create commercial packages, as the practice of companies such as Microsoft. The inexpensive
machines permit each programmer to have a terminal capable of fairly rapid compilation. The
programs under consideration can use techniques such as garbage collection, which make them
easier and faster for the programmer to write. Conversely, many fewer organizations are
concerned in employing programmers for large custom software projects, instead using
commercial packages as much as possible.
The Pioneering Era
The most key development was that new computers were emerging almost every year or two,
making existing ones outdated. Programmers had to rewrite all their programs to run on these
new computers. They did not have computers on their desks and had to go to the "computer
room" or “computer laboratory”. Jobs were run by booking for machine time or by operational
staff. Jobs were run by inserting punched cards for input into the computer’s card reader and
waiting for results to come back on the printer.
The field was so new that the idea of management using schedule was absent. Guessing the
completion time of project predictions was almost unfeasible Computer hardware was
application-based. Scientific and business tasks needed different machines. High level languages
like FORTRAN, COBOL, and ALGOL were developed to take care of the need to frequently
translate old software to meet the needs of new machines. Systems software was given out for
free by the vendors since it must to be installed in the computer before it is sold. Custom
software was sold by a few companies but no sale of packaged software.
Organisation such as like IBM's scientific user group SHARE gave out software free and as a
result reuse was order of the day. Academia did not yet teach the principles of computer science.
Modular programming and data abstraction were already being used in programming.
1945 to 1965: The origins
The term software engineering came into existence in the late 1950s and early 1960s.
Programmers have always known about civil, electrical, and computer engineering but fount it
difficult to marry engineering with software.
In 1968 and 1969, two conferences on software engineering were sponsored by the NATO
Science Committee. This gave the field its initial boost. It was widely believed that these
conferences marked the official start of the profession of software engineering.
1965 to 1985: The software crisis
Software engineering was prompted by the software crisis of the 1960s, 1970s, and 1980s. It was
the crisis that identified many of the problems of software development. This era was also
characterised by: run over budget and schedule, property damage and loss of life caused by poor
project management. Initially the software crisis was defined in terms of productivity, but
advanced to emphasize quality.
• Cost and Budget Overruns: The OS/360 operating system was a classic example. It was a
decade-long project from the 1960s and eventually produced one of the most complex software
systems at the time.
• Property Damage: Software defects can result in property damage. Poor software security
allows hackers to steal identities, costing time, money, and reputations.
• Life and Death: Software defects can kill. Some embedded systems used in radiotherapy
machines failed so disastrously that they administered poisonous doses of radiation to patients.
The most famous of these failures is the Therac 25 incident.
1985 to 1989: No silver bullet
For years, solving the software crisis was the primary concern for researchers and companies
producing software tools. Apparently, they proclaim every new technology and practice from the
1970s to the 1990s as a silver bullet to solve the software crisis. Tools, discipline, formal
methods, process, and professionalism were published as silver bullets:
• Tools: Particularly underline tools include: Structured programming, objectoriented
programming, CASE tools, Ada, Java, documentation, standards, and Unified Modeling
Language were touted as silver bullets.
• Discipline: Some pundits argued that the software crisis was due to the lack of discipline of
programmers.
• Formal methods: Some believed that if formal engineering methodologies would be applied to
software development, then production of software would become as predictable an industry as
other branches of engineering. They advocated proving all programs correct.
• Process: Many advocated the use of defined processes and methodologies like the Capability
Maturity Model.
• Professionalism: This led to work on a code of ethics, licenses, and professionalism.
Fred Brooks (1986), No Silver Bullet article, argued that no individual technology or practice
would ever make a 10-fold improvement in productivity within 10 years.
Debate about silver bullets continued over the following decade. Supporter for Ada, components,
and processes continued arguing for years that their favorite technology would be a silver bullet.
Skeptics disagreed. Eventually, almost everyone accepted that no silver bullet would ever be
found. Yet, claims about silver bullets arise now and again, even today.
” No silver bullet” means different things to different people; some take” no silver bullet” to
mean that software engineering failed. The pursuit for a single key to success never worked. All
known technologies and practices have only made incremental improvements to productivity and
quality. Yet, there are no silver bullets for any other profession, either. Others interpret no silver
bullet as evidence that software engineering has finally matured and recognized that projects
succeed due to hard work.
However, it could also be pointed out that there are, in fact, a series of silver bullets today,
including lightweight methodologies, spreadsheet calculators, customized browsers, in-site
search engines, database report generators, integrated design-test coding-editors with
memory/differences/undo, and specialty shops that generate niche software, such as information
websites, at a fraction of the cost of totally customized website development. Nevertheless, the
field of software engineering looks as if it is too difficult and different for a single "silver bullet"
to improve most issues, and each issue accounts for only a small portion of all software
problems.