The Principles of Our Software Development

In our SaaS solution future, we place great emphasis on maintaining high standards in software development. In this blog post, we show how a modular structure, code reviews, and continuous integration ensure the long-term quality of our software and ease maintenance.

In the forecasting software future, we have combined our many years of expertise in forecasting and made it available to users as an SaaS solution so that they can easily generate really good forecasts. To ensure that everything works reliably, high standards in software development are essential. In this blog post, we would like to outline in some detail a few approaches to software quality assurance and how we put them into practice.

The different stages of software development

First of all, we distinguish between prototypes and enterprise solutions. Prototypes vary in their level of development depending on the requirements. They range from a simple mockup to a fully functional prototype to production readiness. Each of these stages differs in regard to functionality, documentation, and testing. For example, a mockup only exists as a model solution to a problem. This may be software code or merely a sketch. The problem is not yet solved, but it supplies a foundation for further requirement gathering. On the other hand, the production-ready prototype is fully functional and has been tested with an extensive list of cases. Additionally, the code is prepared and documented for future extensions.

An enterprise development, such as future, represents an even higher level of quality and sustainability in software development. Aside from the actual functionality of the developed solution, quality criteria come first.

A modular design has its advantages

In contrast to the prototype, modular code can be tested and its parts replaced independent of others. A modular software design means that the implementation is divided into several logical blocks. Such a solution offers decisive advantages: It avoids duplicated source code and ensures an efficient medium- and long-term maintainability of the application. Moreover, as the code is divided clearly into modules, it is possible to replace one module without having to replace other modules in the software.

Code reviews and conventions made the code cleaner

Another important aspect to ensure the quality of our code is the so-called code review. Here, code written by one colleague is independently reviewed by another colleague or with the help of a tool. We primarily rely on the former variant, which often demands a considerable amount of time but offers several advantages: On the one hand, functional and stylistic errors in the code are eliminated; on the other, know-how and awareness of the current state of the solution are shared within our team. This allows us to avoid further errors and sustainably improve development. During the review, the reviewer adheres to so-called conventions, which guarantee that the code is understandable and maintainable. Our team members internalize these conventions from day one.

Code reviews are an important tool because the error rate of source code that has been reviewed by at least one other developer is noticeably lower than if only one person works on it.

Consistency through continuous integration

Another aspect of quality assurance is continuous integration. Every stage of development is fully automated, compiled, extensively documented, tested, and packaged. The functional tests range from slim unit tests to extensive integration tests to tests in different runtime environments. In the case of future, a unit is usually a single function or method; in an integration test, however, several units are tested together. For example, the entire system is called with a multitude of sample time series. Integration problems can thus be recognized and fixed quickly. Continuous integration reliably ensures the functionality of the application at all times and new adjustments are possible without affecting the previous functionality. Additionally, in this process, compliance with conventions is also automatically checked in the form of so-called style checks.

Continuous integration pipeline with style checks, unit and integration tests, and continuous delivery

With continuous delivery, we go even one step further and ensure that the software is automatically deployed to the development, test, integration, and production environments after integration. This way, we can significantly accelerate the delivery of patches and updates.

Effort earlier pays off later

Without question, the execution of tests and code reviews requires a lot of time and effort. Ultimately, however, these measures lead to higher quality software, reflected in early error detection, low error rates in operation, and smaller efforts in adjustments. Even in software development, it’s like so often in life: Quality and precision always pay off in the long run.

Interested in taking a look at future and starting to create forecasts right away?