Software engineering is an engineering discipline that is concerned with all aspects of software production from the early stages of system specification to maintaining the system after is has gone into use.
It uses the appropriate theories and methods to solve different problems that we might face. It also considers organisational and financial constraints too, obviously you can’t magic $1 billion from thin air, so limits must be taken into account. Additionally, all aspects of software development are included, even project management.
Generally, software engineering involves teams, especially when larger more-useful software applications are being built.
Take a house, for a example, you could probably build something house-like by yourself, but frankly you need architects, plumbers, builders, construction workers and other people involved if you want to live in it.
Larger buildings need many more people involved. A skyscraper is going to require specific skills that aren’t used in the average semi-detached house. An incredible amount of planning is required.
When things go wrong in software, lots of real world problems can occur. Read about History’s Worst Software Bugs.
One of software’s biggest advantage is also is biggest disadvantage. Software’s mutability makes it so we can continuously improve it over time. However, this means that many more bugs can spawn and ruin everything. Whereas hardware on the other hand, tends to be “perfected” before it’s manufactured and shipped to consumers. However, when hardware contains bugs huge recalls occur which are incredibly costly to the businesses that manufactured and distributed the hardware. Software can usually get an upgrade, which is usually pretty easy to solve.
Successful software applications require planning, some useful elements in a plan include:
- Specification; requirements, customer-oriented planning
- Design; developer-oriented planning, organisation
- Development; implementation
- Validation; testing
- Maintenance; evolution, improvement; modification reflecting consumer and market requirements
The software crisis is a term used to describe the impact of rapid increases in computational power and the increase in the complexity of problems that we need to tackle. This generally refers to the difficult of writing correct, understandable and verifiable computer programs.
The major cause of the software crisis is that machines have become several orders of magnitude more powerful! As long as there were no machines, programming was no problem at all; when we had a few weak computers, programming became a mild problem, and now we have gigantic computers, programming has become an equally gigantic problem.”
There are many methods used to tame the software crisis, but we tend to believe that there is no “magical methodology” that will will save us from it. The reason behind this is because software projects are large, complicated, often poorly-specified, involve unfamiliar aspects and are thus vulnerable to large unanticipated changes.
As time goes by, we are becoming more and more reliant on software systems. We need to be able to efficiently produce new systems that are well coded, because maintenance takes up the majority of deployed software’s life-cycle.