New ways to make software are not new, but it is only now that the true potential is being unlocked. It has taken many attempts to find the right formula, but new low-code tools are now finally delivering on that promise of enabling the creation of great software safely, quickly, and without programming. The first generation of low-code tools was the proverbial faster horse — it worked in much the same way as existing developer tools but with a few shortcuts. The next generation tried to let almost anyone build an app quickly, but without consideration of any potential risks: a classic example of the dangers of power without adequate control. 2021 heralds the arrival of the third generation of low-code tools that balance speed and governance to truly transform business software delivery.
Let us explore the factors of why 2021 is the year that it happens. Learn how low-code tools can modernise your IT estate and deliver the advanced software that your enterprise demands, faster than even before.
Matching development supply to growing demand
We all know that software has been seeping into every activity and process for a long time, boosting demand for software of all kinds. Advanced organisations are already automating their collaborative business processes via the internet while the COVID-19 pandemic has forced even the most recalcitrant organisation into adopting digital processes. Digital is no longer the preserve of the internet giants; it is mandatory for all businesses.
But digital skills are in notoriously short supply, limiting the rate at which software can be built. This is where third-generation low-code tools come into their own, allowing the creation of complex business software without
the need for hand coding. This saves time throughout the whole software development lifecycle without taking any shortcuts. Allowing domain experts to capture business processes directly saves the need to elaborate requirements in text and explain them to developers. Automating app creation and safe deployment cuts out repetitive coding and installation tasks while significantly reducing the need for manual coding and scripting. The
whole digital supply chain is accelerated.
The low-code conundrum
Agile has done much to streamline how software is specified, encouraging continuous collaboration between stakeholders and developers, however there is still a base assumption that less technical people must tell the experts
what they need and let them get on with it. This way of thinking has restricted the use of low- and no-code tools such as Betty Blocks to simpler, single-user applications or restricted the tools to accelerating developers, as with
This is the conundrum: building anything more than an absolutely basic app is the domain of the professional developer because the business professional is presumed to not understand the complexities of software, while the professional developer is presumed not to understand complex business processes. Tools that merely move the barriers to delivery without eliminating them reinforce this perception.
Wouldn’t it make far more sense for a tool to enable the business processional to capture the business process directly, without having to explain it to a developer who can focus on any technical aspects? This is exactly what the latest generation of low-code tools does, enhancing collaboration without compromising governance or performance.
The importance of intent
Programming languages capture how to implement a process, not what that process does. This is because they largely evolved from build operating systems. Low- and nocode tools address this by providing visual interfaces that capture the intent of the app, for example Microsoft’s simple PowerApp tools, but most miss the point that you need multiple visual styles to fully define the intent of all but the simplest processes. This has caused many tools to be self-limiting to the same absolutely simplicity to which the professional developers consign them. For example, Alpha Software Transform is great for converting PDF forms into mobile apps, but doesn’t support significantly more complex situations.
But low-code tools need not be limited to just one way of expressing things. Just as some programming languages include the ability to create problem-specific subsets, different visualisations can help different user groups to
express their requirements clearly, concisely and, above all, correctly. A process modelling tool is ideal for a business analyst to capture the logical flow, a relational model diagram is ideal for a data manager. Indeed, there are good visual ways to capture many specialist activities from case management to visual design.
Combining multiple visualisations onto a common core model of the application is an incredibly powerful mechanism. All too many tools keep the different perspectives of an app separate, with the information siloed and not linked in anyway, usually because that is just how it evolved. Consistency is guaranteed between the different views when they are intrinsically linked, reducing errors and rework. Expect to see more tools working with multiple abstractions all based on a common, core structure.
Focus on what you do best
Another huge advantage of capturing intent directly is that it eliminated the need to manually build all the scaffolding code that is necessary but adds no value and is repetitive. A vast amount of software development is building stuff that users never see. Low-code tools help developers deliver more code, more quickly by automating the repetitive grunt work.
Expect many more tools to look at how automation, smart or not, can help businesspeople, analysts, developers, designers, architects, testers, and others to be more productive by eliminating tedious, repetitive work. Some of these may claim to use artificial intelligence, however the greatest advantage is gained from tools that have a focus on letting humans do the creative work whilst making all the rote tasks invisible.
Moving to the new world of computing
Moving the focus away from how software is built to what it does has another, perhaps surprising advantage: it makes it easier to benefit from all the advantages of modern architectures. While cloud hosting has removed the need to manage physical servers and networks, these new architectures have enabled many software architectural innovations.
Elasticity is one of the most important capabilities of the cloud, allowing apps to scale up or down to match demand. Not only does this same money, but critically it reduces carbon emissions by reducing compute load. Adding elasticity conventionally requires skilled engineering whether retrofitting it to legacy apps or when building new apps. The most innovative low-code tools can enable elasticity and other cloud-native capabilities without the need for complex engineering.
Containers, serverless computing, microservices, open APIs, distributed ledgers and other advances in software architectures are all transforming how the best software is built. Adopting any of these new forms of deployment demands time and knowledge, both of which are always in short supply. This is why new tooling is needed, simplifying adoption to the point where the person specifying the software doesn’t need to understand any of it. The expert developers of the low-code tool itself do not just take care of the technical aspects, but keep them constantly updated.
Connecting the real-time world
The internet and its protocols have been instrumental in connecting the world, but it is the next generation of connectivity that is connecting the world. Business protocols, defined by businesspeople who understand the
protocols, contracts and uncertainties of business collaboration. That the underlying mechanisms are TCP, REST APIs or blockchain does not matter when the person with the knowledge of how to work with a partner can capture that directly. Enabling the specification of digital supply chains by intent can transform not just information flow, but how businesses operate, financial mechanisms and above all, how quickly goods and value travel around our planet.
Time to give governance a makeover
While governance is an essential part of delivering solid corporate IT systems, it often slows innovation, restricts access to development, and hampers the adoption of new techniques. It is time for governance to be given a makeover.
Far from preventing innovation, modern governance can enable a wider constituency of software creators by embedding the principles of reliability and contract obligation into the deployment pipeline. By providing a legitimate, controlled path to production deployment, users do not need to find ways around irksome restrictions.
Modern low-code tools are building proper deployment pipelines with flexible permissions, configurable approval stages, and multiple deployment environments into the process. Businesspeople can use push-button deployment for simple apps for their teams and use the same button to push updates into pre-production for validation by the professionals.
Islands of automation
Automation is not new in software development and has been widely adopted in areas such as test. Numerous tools and frameworks, including open-source framework Selenium, have largely replaced the tedious use of repetitive manual scripts. Build tools and scripts have been eliminating manual steps for decades.
These opportunistic islands of automation have, however, operated independently with human intervention needed for projects to through the stages of the build process. Continuous integration and deployment tools such as Jenkins have streamlined delivery into pipelines that automatically move changes from code check in through test to build and deployment, linking up the pockets of automation to the right of the process.
Low-code tools are now adopting a holistic view of the whole development lifecycle by automating the left-hand side of the process. Automation flows from project inception to delivery. This is an incredibly powerful step, not just for speed of delivery, but because it eliminates so many potential human errors along the way, reducing debug time and improving delivery quality. Automation wins at all levels.
Towards sustainable, collaborative development
Bringing all these elements of modern tooling together enables us to make a sustainable approach to development. Current approaches and tools are at the limits of what they can deliver, as is the software development community. Enabling all stakeholders to work together to deliver correct software, reliably, built on modern technologies has to be our goal as an industry.
One company has been building all these best practices into their tool, Aurachain, enabling a whole crew of talents to work together to deliver. Aurachain offers 360 coverage and is based on a modern, containerised microservices architecture, unlike many other tools that are locked in a previous generation of software architecture. In Aurachain businesspeople can engage with a visual process editor to capture intent, analysts delight in a dedicated data modelling tool, while granular permissions and a configurable multi-stage deployment mechanism enables a range of governance mechanisms. Operations and professional developers are not ignored either, treated as they are to pro-grade monitoring and debug tools. Aurachain is a tool designed to support the whole professional software development lifecycle.
It is time to break out of the classic mould of software development and explore new approaches. Legacy systems are due for replacement, data center
hardware is reaching end of life, and customers and partners are constantly demanding new integrations. Microsoft has even just open-sourced a low-code language, Power Fx.
The trends in the low-code tools emerging in 2021 are all destined to help overcome these obstacles, quickly, while maintaining a reputation for solid, reliable delivery. Difficult to ask for a better outcome.