Software isn’t build because we can, but because there is a problem whereby computer software can provide a solution. When writing a software solution there is more to keep in mind than just one’s and zero’s. Creating software is understanding the ‘problem’ the client faces. This is the most important aspect of developing software.

Secondly is the software itself. Of course creating the software should ensure the client’s problem no longer exists, but the software shouldn’t create a new problem. This is where high quality solutions are expected.

When creating software solutions I keep the following criteria in mind.

• High quality software: Software of low quality will contain bugs and bugs cost money and result in unsatisfied end users.
• User friendly software: Software with bad user experience will not be used and is a waste of money.
• Multi-tier architecture: Bad architecture may cause early or unfixable bottle-necks, in the worst case leading to scrapping the solution entirely, with the inevitable cost.
• Quick or good delivery: Software that is released too soon has the potential of having bugs or  corner-cutting. This could eventually lead to spending more time developing/bug-fixing after the first release.

High quality software
By using technologies like unit-testing, test driven development, code analysis and agile development, I can meet the higher expectations of sturdy and stable software. ‘Quick and Dirty is not an option’ is the motto I use when developing software.

Unit-testing is the process of writing code to test your code. In other words, every little piece of code gets tested by several unit-tests making sure all scenarios this particular code block can handle will get handled with success. The size of the application grows but the tested scenarios increase as well, making sure that every block of code keeps working as expected.
Since these tests exist in code and not by some test-script a human-tester needs to follow, thousands of tests can be run on a daily basis so the developer can detect flaws at a very early stage.

Test driven development is a technique where the developer writes the unit-tests for a code block before the code block is created. This helps the developer to better understand the code he is supposed to write and helps the developer improve architecture of the code before the code is written.

Code analysis is the use of strict coding rules and guidelines used and improved by .NET developers around the world. By building code according to these rules and guidelines, knowledge is used from developers worldwide who have experienced bad coding practices and written the rules or guidelines to ensure other developers don’t fall into the same trap.
Agile development lets the client (or user) get involved in the development process. By showing the development progress to the end user in a two to four week cycle the user can

1. Better understand the application when they start to use it;
2. Change the course of the development process as the application is growing (in this way the end product is exactly what the end user expected).
3. Achieve a better understanding of how the build progresses.

User friendly software
The success of an application doesn’t necessarily depend on how ‘clever’ it can be but more so on how ‘cleverly’ the user can use it.
If the software has lots of buttons, checkboxes, settings and highly complicated calculation capabilities, then the user often backs away and hardly dares to touch it. Whereas applications that have a friendly and simple look-and-feel have more chance of being used.
Why build a over complicated and flexible application if nobody knows or wants to use it?

Multi-tier architecture
The larger software solutions mostly aren’t run on one computer and aren’t used by one user. The more complex software solutions will be used by many  users with more than one role and will most likely run on different computers in different locations. By using multi-tier technologies these solutions can be built.

Two-tier applications are application where there is a client application running on the user’s pc and a server application running on the server handling the data the users provide.

Three-tier applications have a separate application running on a server which in general is used for ‘number crunching’ that could eat up the entire server capacity. These number crunchers shouldn’t be run on a client pc or data server because it could freeze the client application.

These technologies are used to balance the workload of the software over several computers so the user-interface on the client machine keeps responding, and the data server can keep up with handling the data changes.

Quick or good delivery
There is a very thin line between delivering a software solution too soon or too late.

If a tight deadline is set in advance, there is a bigger chance of active bugs in the final product because of cutting corners. But if the developer keeps building, testing and improving the software, the development process could end up in an endless loop of recreating and redesigning the software. The software is becoming too expensive to build.

Agile development helps in finding the right time for deployment of the software solution and ‘going-live’, even if there is a strict deadline or has strict functional requirements.