SOFTWARE ENGINEERING

Clive Ivan A. Nam-ay

BTIT-4B

Mrs. Minabelle Villafuerte

Assignment #1

1. What is Software engineering?

- Software engineering is the application of a systematic, disciplined, quantifiable approach to the
development, operation, and maintenance of software; that is, the application of engineering to software
(IEEE, 1990). The systematic, disciplined, quantifiable approach is often termed a software process
model (in the general sense) or a software development process (in the specific sense). Specific software
development processes consist of a particular set of software development practices which are often
performed by the software engineer in a predetermined order. Software development practices, models,
and methodologies will be introduced in the next two subsections.
2. Evolution of Software Engineering
- At the start of the computer age, all of the engineering tasks involving computing technology
focused on hardware: the design and debugging of electronic circuits, the organization of logical devices,
the machinery of printers, disk drives and other elements, and the operation of complicated systems.
Programmers began to develop an engineering discipline for software only as they began to appreciate the
problems of describing, coding, and delivering software systems. As it was originally conceived, software
engineering was to be the discipline that would guide the development of programs that were too big and
complicated for any single individual to handle. In the early days of the field, it was often called
programming in the large. In an effort to bring some order to this work, early programmers looked to
some of the basic concepts of the traditional engineering fields. They borrowed the idea of
interchangeable parts from mechanical engineering and transformed it into the concept of standard
program libraries. From civil engineering, they took the ideas of standard practices and standard
handbooks and used them to define a standard body of knowledge. From electrical engineering, they
borrowed black-box design techniques and redeveloped them as means of hiding information and
simplifying systems. As the concepts of programming in the large began to change into those of
software engineering, the advocates for this new field began to redefine its purpose and methods. Large
programming projects suffer management problems different in kind from small ones, wrote Fred
Brooks, a computer scientist at IBM who helped create the OS/360 operating system. I believe the
critical need to be the preservation of the conceptual integrity of the product itself. In their efforts to
preserve that identify of their creations, the pioneers of software engineering created disciplines for
identifying, describing, and evaluating software systems. In developing this field, they drew their ideas
not only from the older engineering fields, but also adopted ideas from the new disciplines of industrial
engineering and of quality control and process improvement. In borrowing these ideas, they modified
them, sometimes radically, to fit the new field of software development.

The term 'software engineering' was suggested at conferences organized by NATO in 1968 and
1969 to discuss the 'software crisis'. The software crisis was the name given to the difficulties encountered
in developing large, complex systems in the 1960s. It was proposed that the adoption of an engineering
approach to software development would reduce the costs of software development and lead to more
reliable software.

Key dates in the history of software engineering are:

1968:
Nato conference on software engineering.
In the fall of 1968, 50 mathematicians, engineers, and computer scientists
gathered at a resort hotel in Garmisch, Germany, to talk about the problems of
programming and large systems. The conference, which initiated formal discussions
about the methods of software engineering, was organized by the Science Committee of
the North Atlantic Treaty Organization (NATO). The members of this committee had
become concerned about the stories of a software crisis and the problems that they had
witnessed in the preparation of large military systems.
Publication of Dijkstra's note on the dangers of the go to statement in programs.
Early 1970s.
Development of the notions of structured programming.
Publication of Parnas's paper on information hiding.
(. Parnas studied the problem of dividing large systems into small pieces. He argued that
programmers could minimize the number of errors in their final product if they adopted a
strategy that hid information in the basic Subdomain Software 1122 Software
Engineering: History subdivisions of the system. A programmer should begin with a list
of difficult design decisions or design decisions that are likely to change, Parnas
explained. Each module is then designed to hide such a decision from the others.)
Development of Pascal programming language.
Development of Small talk languages which introduced notions of object oriented
development.
Late 1970s.
Early use of software design methods such as Yourdon and Constantine's structured
design.
Development of first programming environments.
Early 1980s.
Development of the Ada programming language which included notions of structured
programming and information hiding.
Proposals for software engineering environments.
CASE tools introduced to support design methods.
(CASE approach produced project management tools and machine-readable ways of
describing systems. For system design, it produced rapid prototype languages. For the
coding step, it created more sophisticated programming environment. For the last two
steps, those of debugging and maintenance, it produced symbolic debuggers and test
generators.)
Development of algorithmic approaches to software costing and estimation.

3. Characteristics of a Software Engineer:

Passionate
Determined
Team Player
Confident
Up-to-Date
Coolheaded and Open Minded
Competitive
Creative
Strategist
Original
Industrious
Realist
Independent
4. Life Cycle of Software Engineering (Phases)
Project planning, feasibility study: Establishes a high-level view of the intended project
and determines its goals.
Systems analysis, requirements definition: Refines project goals into defined functions
and operation of the intended application. Analyzes end-user information needs.
Systems design: Describes desired features and operations in detail, including screen
layouts, business rules, process diagrams, pseudocode and other documentation.
Implementation: The real code is written here.
Integration and testing: Brings all the pieces together into a special testing environment,
then checks for errors, bugs and interoperability.
Acceptance, installation, deployment: The final stage of initial development, where the
software is put into production and runs actual business.
Maintenance: What happens during the rest of the software's life: changes, correction,
additions, moves to a different computing platform and more. This, the least glamorous
and perhaps most important step of all, goes on seemingly forever.