Future Trends of Software Engineering

In the software development industry, the academic and business worlds are drifting ever further apart: The gulf between the ivory towers and office desks continues to widen. Both sides would benefit from working more closely together. Our ‘Future Trends of Software Engineering’ (FToSE) initiative is designed to highlight this unwelcome development and to stimulate a discussion. It aims to increase mutual understanding of key themes and developments by improving communication on the major trends in software development.

The potential of agile software development is still far from exhausted.

• Practice: We are currently witnessing the development of ‘two-speed IT’: Critical systems are still being developed in the traditional way, while companies take a radical, agile approach to everything else.
• Research: Procedural models for software development still make as much sense as they always did. Agility is not a fundamental change, but it offers some useful features which should be integrated into procedural models.
• Synthesis: Agility shows huge promise for software development; it must not be wasted. Triggers for changes are appearing at ever shorter intervals, and they will eventually lead to IT departments taking on a completely new role within companies.

They’re no cure-all, but they do give IT departments new capabilities.

• Practice: Microservices are a big step in the right direction. They allow specialists to connect varying architectures with each other.
• Research: Architectural paradigms are actually quite stable. What started out as modularisation and became service-orientated architecture is now known as microservices.
• Synthesis: Microservices are brilliant for integration paradigms and new developments, but they are not a foundation for rebuilding existing landscapes.

Cyber-physical systems are a digital transformation you can get your hands on

• Practice: Cyber-physical systems are leading to new business models. And that’s not all: What with the arrival of the Internet of Things, the complexity of systems and interconnections is increasing dramatically. That is giving rise to new challenges.
• Research: From a structural point of view, cyber-physical systems are nothing new. Mixtures of information systems and embedded software have always existed.
• Synthesis: CPS Engineering can build on existing knowledge, but it’s really a new specialist area.

Success is determined on the interface

• Practice: Users want nice-looking interfaces. If they don’t get them, they will dismiss the software as useless and move on to something else.
• Research: Usability is actually quite important. That’s why usability engineering has to be integrated into the software process.
• Synthesis: For applications that rely heavily on interfaces, as well as mobile and other unconventional apps, usability is the key to success – which makes it an important factor.

It may not be a nice topic – but it is hugely important

• Practice: As long as software is made by people, it will contain errors. There are a variety of reasons for them and, in socio-technical systems, they are not always predictable, either.
• Research: In recent years, the academic world has developed a number of frameworks for solving the problem of errors in software projects. If we stick to these frameworks in practice, there will be no more errors.
• Synthesis: Errors can be reduced significantly, but only by working in a consistent, systematic way.

The big picture has to be right down to the last detail

• Practice: Complex software landscapes develop in an evolutionary way because companies build (or buy) each individual system on the basis of what is quickest and most profitable for them.
• Research: Specialists implement complex software landscapes as ‘systems of systems’, meaning a uniform standard architecture which ensures that stand-alone systems can be connected to each other for specific applications.
• Synthesis: Integration scenarios are rarely clear in advance. Each individual system must be designed to be integrated, and be capable of making its own contribution to the evolution of the system.

From data comes knowledge

• Practice: The cloud is good at dealing with calculation complexity, so the key is usually gathering larger quantities of relevant data.
• Research: Processing vast amounts of data – and the associated increase in calculation complexity – in modern application scenarios requires fast, efficient algorithms.
• Synthesis: More attention must be paid to data gathering in big data applications. Companies can rely on proven infrastructure for processing. Optimising algorithms is really about doing the fundamental research.

In the beginning, the end is just a vague idea

• Practice: The initial phase of software development is still decisive. This is where you have to gain a general overview of the requirement – and it’s got to be good. As the project progresses, this allows the people in charge of it to recognise what’s important.
• Research: It is impossible to produce a comprehensive advance description for socio-technical systems (i.e., an organised quantity of people and technology). That’s why we need procedures to deal with requirements that only arise once development has started.
• Synthesis: It’s worth taking plenty of time to study the big picture. Small details can become more important as development progresses. This requires constant re-prioritisation, and willingness to make some brave changes.

The focus must always be on how the software will be used

• Practice: If everyone knows what they are doing, they produce valuable software that also represents value for money for the customer.
• Research: There are plenty of metrics for software productivity (starting with function points), but only a few approaches to value-orientated development.
• Synthesis: Software has to be developed with value in mind. This means that there must be a systematic focus on value in development projects, and it must be integrated into procedures.

The revolution is coming

• Practice: Dealing with large volumes of data, finding patterns in them and making the right changes automatically are important drivers of digital transformation. But just how technology should be combined to do these things is not always fully clear.
• Research: As calculation capacity increases, the promises artificial intelligence made in the 1980s are slowly becoming reality.
• Synthesis: Cognitive computing techniques must be integrated with traditional information systems.

The Future Trends of Software Engineering are far from a purely hypothetical exercise. The approach allows us to determine concrete requirements for how companies should deal with software engineering in practice. Let’s talk about your situation, requirements and ideas – and develop your future IT together.