Page 9 - DCAP305_PRINCIPLES_OF_SOFTWARE_ENGINEERING

Unit 1: Introduction to Software Engineering

The idea of software engineering was planned in the late 1960s at a conference held to argue what Notes
was then called the ‘software crisis’. This software crisis resulted directly from the introduction
of third-generation computer hardware. These machines were instructions of magnitude more
powerful than second-generation machines. Their power made hitherto unrealizable applications
a feasible proposition. The performance of these applications required large software systems
to be built.
Early experience in building large software systems shows that breathing methods of software
development were not acceptable. Techniques applicable to small systems could not be scaled
up. Major projects were sometimes years late. They cost much more than initially predicted, were
undependable, difficult to preserve and performed poorly. Software development was in crisis.
Hardware costs were plummeting while software costs were rising rapidly. New techniques and
methods were needed to control the complexity inherent in large software systems.
After almost 30 years of development, we have made enormous progress in software engineering.
Productivity improvements are hard to quantify but there is no doubt that our ability to produce
efficient and dependable software has markedly improved. We have a much better understanding
of the activities involved in software development. We have developed methods of software
specification, design and implementation. New notations and tools reduce the effort required
to produce large and complex systems. .
Nevertheless, many large software projects are still late and over-budget. Software is delivered
and installed which does not meet the real needs of the customers buying that software. New
technologies resulting from the convergence of computers and communication systems place
new demands on software engineers. Software engineering has come far in its short lifetime;
it still has far to go.

1.1 Concepts in Software Engineering

The goal of research in this area is to give a solid foundation for development and deployment of
software for systems with stringent requirements for security, safety, functional correctness, and
efficiency. Principal focuses are general programming methodology and program examination
techniques. Generic programming is mainly an activity of “lifting” of specific computer code to
a more widely useful level, while maintaining high principles of efficiency and other requisite
properties. This process is aided by theoretical classification of software components according
to thoroughly specified requirements. Results include the C++ Standard Template Library (STL),
which is based on joint research with colleagues in industry; new generic sorting and searching
algorithms; and new algorithm concept taxonomies. In the program analysis area, new techniques
are being developed for different software tasks, including testing, understanding, and verification
of object-oriented software. Results include new analyses that have been applied to testing
of polymorphism in Java applications, and to testing of recovery code in highly reliable Web
service applications. Future directions include greater integration of generic programming and
program analysis methodology, with increased emphasis on proof-based approaches. The long
range goal is to meet new challenges that arise from distributed software components, embedded
system software updates, Web services, and other software for modern, pervasive computing.
There are two planned meanings of the word “Concepts” in our research area’s name: the
common one, and the more exact, technical sense of “concept” as a set of abstraction, such as
abstract data types or algorithms, whose partisanship is defined by a list of requirements. In this
technical intelligence, concepts are the main abstraction and organization instrument in generic
programming. The key operation on concepts is refinement: incrementally addition requirements
to a concept description, thereby plummeting the number of abstractions it contains but at the
same time enabling more efficient algorithms or more refined analysis to be applied to the
abstractions that remain. Repeated refinement with different choices of additional requirements
results in a concept taxonomy or hierarchy, such as the one for STL.
LOVELY PROFESSIONAL UNIVERSITY 3