SAP AppGyver has arrived and with it comes our vision of the no-code future. We’ve come a long way to get to this point, and we’re thrilled to be another step closer to making no-code the new standard for software development. As SAP AppGyver co-founder, I wanted to share our definition of no-code, how it became the next paradigm shift, and what lies ahead.
What is no-code?
Traditionally, no-code has not been viewed as a true equivalent of programming methods, but rather a way to build small things and baby apps. It was considered something for those who don’t know anything about developing software to experience the feeling of creating.
We see the next generation of no-code that SAP AppGyver represents as a form of visual programming. It is a full-blown alternative to writing code, made visual and accessible. You can achieve all the things you would when writing code, but instead of memorizing and writing syntax, you see the user interface you’re creating, and you see the flow of logic in a sequence. As we’ve seen with AppGyver, it’s an important part of no-code to have a built-in aspect of programming, as in a power of expression to tell exactly what you want the machine to do. Without this it becomes no-code for baby apps, and not the futuristic vision of what no-code will be like—what we have made no-code to mean with SAP AppGyver.
No-code is a natural progression to create further and further levels of abstraction for programmers to write more complex, sophisticated and nuanced pieces of computer software. It’s part of many decades of the evolution of programming languages, and it will not end there. There will be still further abstraction levels down the road, whether it is highly visual or even something beyond that; but in our view, no-code is the best method for writing software. You can create more complex software than you ever could with any programming language because you can manage much bigger things, have a bird’s-eye view, and build everything faster.
Think of writing code like laying the bricks of a building. You place each brick one by one, carefully layering cement in between. If you’re highly skilled like Leonardo da Vinci, then you would also know how to design and architect the building, but very rarely can you do all those things with the same intensity, at the same time. With no-code, you can assume that each brick is placed in the best possible way. You can zoom out and begin to visualize and understand the bigger picture. You can build something sophisticated, but if you ever need to, you can zoom back in and go back to look at an individual brick.
What no-code isn’t
No-code is not a way to build baby apps or inferior software. It’s not a way to build software only by those who can’t code. On the contrary, those who have years of experience in coding will likely benefit the most from no-code because they can create even bigger things. Someone who has been a frontend developer can now work on the backend, and solutions being worked on by teams of 20, can now be placed in the hands of one person.
No-code is a way for the citizen developer to contribute and build something, but it is not just a citizen developer tool. If no-code is done right, and organizations understand the benefits, then no-code will become the de facto standard way of creating almost all software by IT and non-IT.
The next logical step in software development
Considering how far we’ve come and how our expectations have evolved, it’s become obvious that no-code is the next paradigm shift. The requirements for modern software are wide and complex, from different form factors to new opportunities and new technologies that you can utilize if you know how. This doesn’t just include no-code, but also all the libraries, frameworks, and levels of abstractions—these can all help you navigate the jungle of complexity that you face as a programmer. No-code continues to do that and makes it possible for smaller groups of people or even one individual to create a complete software that works on all devices, is secure and enterprise-grade.
We’re also at a point where writing code has become very easy. It’s come a long way, starting from machine code of zeroes and ones to small symbols and letters, then to C++ that was almost writing English, and further and further. The tools have gotten simpler, to the point where you don’t need to manage the memory of the computer anymore. You build software and assume that the programming language or framework manages the complex things. However, managing large amounts of written code is complex and it’s almost foolish that memorizing syntax is still needed nowadays, when visualization is so much clearer.
When you write code, you’re almost always reinventing the wheel. You’re writing a lot of boilerplate, and not focusing on unique aspects of your software or designing the experience. Consider this example of a basic feature:
You want to build into your app a logic that does offline queuing of data, so that if you try to make a post, it will stay in queue until you become online, and then it synchronizes and sends the data to a cloud service. If you gave this task to five programmers with different backgrounds, they would show five different ways to program it, each with their own approach to syntax and code structure. However, if you ask the same five people to draw a sequence diagram of what needs to happen in this feature, they will pretty much draw it the same way.
It shows just how much additional interpretation and thinking happens when writing code, and why a visual approach to building logic is valuable. With a sequence diagram, other people can easily look at the programming you’ve done and contribute to the result.
Staying agile in a changing world
Our expectations of software and how sophisticated something is are growing every day, including security, speed, offline capabilities, the list goes on. Code needs to be optimized for all these things that make good software work perfectly. If something in your app changes, you need to reoptimize and rearchitect, whereas with visual programming, you can simply move some things around. There is a lot happening behind the scenes that you don’t need to care about, but at the same time you have control over them.
Almost nobody wants a super long project, and so we need something better. Code languages are pretty much at the end of the road. They are as simple and optimal as they can be, and they are still way too complex and full of boilerplate. It makes sense that if those things can be done at a higher abstraction level and performed visually, but you can go to the lower level if needed, there would be no downsides.
Steve Jobs famously said that software is about managing complexity. If one group of people has the capacity, time, and resources to build a three-story high building, and the boilerplate, the framework—if all those things they need are taken care of, then the same group could build a 50-story high building. Managing complexity is the key, and it’s obvious that anything that can be shown visually, should be made visual.
Next steps as SAP AppGyver
This is the beginning of a very exciting journey. We’ve taken no-code to where no-code has never been before. We created a professional-grade no-code platform that non-coders can use, but also coders can do everything they need. What we’ve seen with our community and enterprise customers has proven that no-code is here to stay, and you can in fact build business critical modern applications.
Yet this is still the very early days of no-code, and there’s so much more that can be done. I believe that around these no-code products we’re building now, there will be ecosystems with third party vendors creating plugins, extensions, and additions. Likewise, there will always be a need for an ever-growing developer community to contribute to that ecosystem.
All the great tools we’ve created in SAP AppGyver, from dev ops tools, login services, analytics, and debuggers, will continue to be pushed further as all these technologies start to mature. We are marching towards this now, becoming more secure and more enterprise-ready to provide the most stable no-code platform in the world. There are many levels of compliance in enterprise scenarios, and, as part of the SAP product family, we are fully committed to it.
Our vision is to work together with the different teams at SAP, providing full-blown drag-and-drop easy integrations to many of the core systems and products at SAP. We want to ensure that if you’re an SAP customer, if the question is Could we use no-code? Could we use SAP AppGyver for that? The answer will be yes to almost any situation. We’re committed to providing an insanely great experience for all of those who want to integrate SAP products into their applications, build extensions into existing products, or create something entirely new with SAP AppGyver.
Similarly to all of you, who are students, independent developers, and other non-enterpise users – we warmly welcome you on this journey with us as well. Join our fast-growing free developer community and let’s create the no-code future together!