Understanding the Software Crisis
Uploaded by
ScribdTranslationsUnderstanding the Software Crisis
Uploaded by
ScribdTranslations14/02/2018 What was the Software Crisis | Computer Science
What was the Software Crisis and the beginning of
Software Engineering
Article published by:Thiago Gabriel Gomes da S. Paiva May 15, 2016
(adsbygoogle = [Link] || []).push({});
The software crisis was a term that emerged in the 1970s. The term expressed the
difficulties of software development in the face of the rapid growth of demand for
software, due to the complexity of the problems to be solved and the lack of techniques
established for the development of systems that functioned properly or
could be validated.
In the early 1970s, when the third era of software was taking place, there were many
deadline and cost problems in software development due to low productivity,
low quality and difficult software maintenance.
Much of the projects continue to have these problems even today, so
It can be said that the crisis continues to be present.
The most common problems in software development.
[Link] 1/3
14/02/2018 What was the Software Crisis | Computer Science
Uncertain estimates of time and cost.
The productivity of people in the software area does not keep up with the demand.
Deadlines exceeded.
Costs above forecast.
The ease of maintenance was not emphasized as an important criterion, generating
thus high maintenance costs.
non-fulfillment of user requirements.
1/3 of the projects were canceled.
2/3 of the projects exceeded the budget.
Hardware cost vs software
1970 = 8:2
1991 = 2:8
Today = 1:9
Example of Software Development Failure
Ariane 5 - European Agency Space Project
Cost US$8 Billion.
10 years of development.
Explosion 40 seconds after takeoff.
Destruction of the rocket and cargo estimated at over $480
Millions.
Solution to the software crisis
Utilization of techniques, tools, and systematized processes to produce software.
Training and education in conjunction with the paradigm shift about what it is
developing software and how it should be done.
Creation of Software Engineering.
The creation of Software Engineering emerged in an attempt to overcome the crisis of
software to provide engineering treatment (more systematic and controlled)
the development of complex software systems.
[Link] 2/3
14/02/2018 What was the Software Crisis | Computer Science
The term Software Engineering became known after a conference in 1968,
when the difficulties and pitfalls of designing complex systems were discussed
frankly. The search for solutions has begun. She focused on better methodologies.
and tools. The most important were the programming languages that reflect the
procedural, modular, and then object-oriented styles. The engineering of
software is closely linked to the emergence and improvement of these styles.
Also important were the efforts at systematization, automation of
program documentation and testing. Finally, the analytical verification and evidence of
corrections should replace the tests. only after the conference the difficulties were
discussed openly and confessed with unusual frankness, and the terms 'engineering
"software crisis" and "software crisis" were created.
Software Engineering focuses on the practical aspects of producing a system.
of software, while computer science studies the theoretical foundations of
computational aspects.
References
1. PRESSMAN, Roger. Software Engineering: A Practitioner’s Approach, 6th edition, McGraw
Hill, 2005
2. .Ariane-5GGunter's Space Page. Consulted on September 6, 2014.
3. Naur and B. Randell, Eds. Software Engineering. Report on a Conference held in
Garmisch, Oct. 1968, sponsored by NATO
4. [Link]
Did you like it? Share! Thank you, sincerely, computer science team.
Share Print E-mail
What was the software crisis and the beginning of software engineering? 3/3
Common questions
Powered by AIThe key objectives of creating Software Engineering were to develop systematic, controlled methodologies for software development to mitigate the risks and issues revealed by the software crisis. These objectives were achieved by adopting structured programming styles, advancing methodologies for analytical verification, automating testing and documentation processes, and fostering a professional discipline that emphasized practical applications over theoretical research. This approach supported creating reliable and efficient systems that met user and market demands slightly more consistently than before .
Software Engineering diverges from Computer Science in its approach to addressing the software crisis through its emphasis on the practical, systematic processes required for producing reliable and efficient software systems. It leverages engineering principles for the structured and controlled development of software, while Computer Science primarily explores the theoretical underpinnings of computation. This distinction was crucial for establishing methodologies that enabled overcoming the software crisis .
To address the software crisis, efforts were made to establish systematic techniques and tools for software production, leading to the emergence of Software Engineering. This included the introduction of programming languages that facilitated procedural, modular, and object-oriented styles, as well as systematized processes for documentation and testing. Moreover, Software Engineering was distinguished from Computer Science by its focus on the practical aspects of software production, rather than the theoretical foundations of computation .
Software maintenance costs were indicative of ongoing challenges in the software crisis, as they often far exceeded initial development costs, reflecting a failure to prioritize maintenance as a crucial aspect of the software lifecycle. This oversight resulted in high cumulative expenses when changes became necessary, highlighting inefficiencies in project planning and the need for better-maintained and adaptable software systems .
The software crisis emerged in the early 1970s largely due to the rapid increase in demand for software which outpaced the existing techniques for developing software systems. This period saw significant issues such as uncertain estimates of time and cost, low productivity, high maintenance costs, and frequent failures to meet user requirements. Additionally, over a third of projects were canceled, and two-thirds exceeded their budget. The shifted cost balance from hardware to software also highlighted this crisis, moving from 8:2 in 1970 to 2:8 in 1991, and today it's 1:9 .
The Ariane 5 project exemplified the software crisis challenges through its catastrophic failure 40 seconds after takeoff, resulting in the destruction of the rocket and cargo worth over $480 million, despite extensive development efforts costing US$8 billion over 10 years. This incident highlighted the potential for major software-related failures in large-scale projects, underscoring the need for improved software development processes and reliable verification methods .
The historical changes in the hardware to software cost ratio, from 8:2 in 1970 to 1:9 today, signify a major shift in technological advancement, where software has become the primary component driving innovation and product value. This shift highlights the intensified focus on software capabilities and complexities, reflecting both the profound impact of and the response to the software crisis. It underscores the heightened importance of efficient software processes to sustain industry demands .
The 1968 NATO conference was pivotal in the evolution of Software Engineering as it brought to the forefront the challenges of developing complex software systems. It was during this conference that the term 'software crisis' was coined, and participants candidly discussed the need for a more disciplined engineering approach. This open dialogue spurred the establishment of methodologies and the recognition of Software Engineering as a distinct discipline focused on practical application, contrasting with theoretical Computer Science .
The transition from a hardware-focused to a software-focused development paradigm occurred as the complexity and capabilities of software increased, leading to a higher demand for sophisticated applications. By the 1970s, the economic and functional roles of hardware and software shifted, with software becoming the primary driver of functionality and value in technology products. Consequently, the cost ratio between hardware and software inverted from 8:2 to 1:9 today, reflecting software's dominant role in driving innovation and application effectiveness .
Emphasizing better methodologies and tools during the software crisis facilitated the advent of systematized software development processes by promoting structured programming languages and practices that enabled more predictable and reliable production of software systems. These methodologies included modular and object-oriented programming, which allowed for more manageable, scalable, and maintainable codebases. This systematized approach provided a clearer framework for testing, documentation, and verification, contributing to a significant reduction in software development risks and uncertainties .