MethodologiesIn engineering, dealing with complexity is a major issue and in software engineering it is the ground for many development methodologies. Although each methodology has its success stories, there are a few problems with all these methodologies.
- They do not take into account the nature and process of design.
- They can seldom be related to a more abstract framework for design.
- Failures in software development projects are never related to a particular methodology.
- They miss the way in which there is dealt with complexity.
Formal MethodsThis is from the FormaliSE (Formal Methods in Software Engineering) 2015 web-page.
- There is no mention on why formal methods are or could be the solution, other than that it is meant for greater precision in both thinking and documentation in the software creation process.
- What is it that they want to formalize?
- The applications of formal methods in the methodologies do not take away the problems with these methodologies.
ApproachesIn the different forms of development one can identify four approaches.
- application of scientific method -
systematic observation, measurement, and experiment, and the formulation, testing, and modification of hypotheses.
- application of scientific and technological knowledge, methods, and experience in a systematic, disciplined, quantifiable approach
- application of skills and proven solutions
- everything goes
- It is mostly thought that software development is done with an engineering approach, but the thruth is that it is mostly takes place with an approach somewhere in between fiddling and craftmanship.
- The way of working typically is to come up with a low level solution for a part or the whole system and fix any problems with and shortcomings of that solution. For small problems this may work out well, but for more complex problems this inherently leads to bad solutions or failures.
Level of AbstractionAn implementation in a programming language (source code) can easily be translated to an executable form. This process is fully automated, therefor it is cheap and can be done over and over again.
- This makes it possible to test the design on the level of the source code and often results in a race to the lowest level of abstraction to start testing early in the design process.
- A step up to a higher level of abstraction to repair design flaws is easily replaced by fixing the design on the level of the source code. In that process, the higher level design is discarded and complexity is taken into the lower levels instead of dealing with it on the higher levels of design.