Software development is a hard task in general. Well at least for industrial strength applications, there is no question to that but some people underestimate it very well and says that it is easy implying how well the problem of creating a software has been misunderstood.
One problem in creating softwares is the exponential increase of its complexity in relation to requirements input. Leaving for now other complexities that burden the software development efforts such as communication and bureaucracy. Software development complexity as Grady Booch puts it requires a methodology in dealing and managing abstractions. Such methodology provides for a clear view of the goals and details in a blueprint like design allowing developers to map it to code implementation. Try creating a reasonable size software and just code it without a clear design, and you end up changing a bunch of codes frequently.
Object- orientation has been a good tool for abstraction both in design and implementation. It is applied in analysis and design to implementation with the help of notations such as UML and object-oriented programming. With this tool, complexities are reduced to manageable units.
Back a couple of years ago, I had written an application using object based programming language. It was a reasonably small software that has something to do with geodetics but the effort to make it work was tremendous and this was due to the absence of a methodology. Another was a set of bigger business applications written on a procedural language. Although a procedural methodology existed, it lacked the benefit of complexity management derived from object-orientation. The code was getting bigger and so is the exponential increase of its complexity. Lately, the high attrition rates of developers in my work has resulted in massive turn over of software projects. I have evaluated these applications and it turned that almost all are highly complex, buggy, and mediocre softwares. The problem was still the absence of design.
There are two (2) software projects I am currently working on. This time I decided to adhere formally with Object-oriented analysis and design using UML and implemented codes based on specifications exhibited by the notations using the Java programming language. This is how I do it:
- Start with a textual analysis on the requirements document to capture potential objects and behavior, use cases, actors, and specific requirements constraint.
- Use case analysis to capture actors and scenarios of each use cases, and to discover objects involved.
- Requirements analysis to capture specific requirements based on the textual and use case analysis, and to specify test cases.
- Structure design to specify class hierarchies, association, and dependencies.
- Sequence specification to capture sequences of collaboration between instances of the structure.
- State transition to specify structure behavior when instantiated.
- Code implementation to reflect design specification using an appropriate programming language.
Several design artifacts can also be created to further improve design:
- Package specification
- Collaboration specification
- Deployment specification
- Component specification
- Activity specification
With this stuff in your arsenal coupled with a good IDE, SCM, unit testing framework, and a development process, software development will still be hard but at least manageable in the context of its complexity.
