There’s an interesting trend in the second decade of this millennium. Things once declared “dead,” are experiencing a resurgence. For example, animated GIFs, once relegated to cheesy ads for home refinancing or losing belly fat in a month with acai berries, are back in Slack channels, social media and blogs everywhere. Email newsletters have returned after many corporations abandoned them as sales and marketing tools in 2008 or so. Podcasts were declared to have peaked sometime around 2010. Now, they’re back and there are almost too many to choose from. The consensus about the return of animated GIFs, email newsletters and podcasts is that they’ve improved in quality and offer more to people who use them.
Visual programming environments and platforms were also hot in the 1990s and the early 2000s. Then the noise they generated seemed to die down. And, now they’re back, very likely for good. Let’s look at why.
Too fast, too choppy, too inwardly focused and…it’s complicated
Visual programming has been around for much longer than we think. It started quietly enough in the 1960s with Bert Sutherland’s interactive programming language. The idea built up steam in the 1970s and 1980s (Smalltalk). The idea of moving away from text editing, compiling, writing down the errors, and debugging with the eyes was alluring. And, so it came of age in the 1990s with Visual Basic, Xelfi/Netbeans, Visual Studio and the height of the CASE tools hype.
So, there you have it. A whole slew of tools that could make programming so easy a child could do it. So, what happened? Why did visual programming virtually go gentle into that good night?
I think it’s because so much was still new in the 1990s and early 2000s. A whole lot of great digital and online stuff came out of that period very quickly. Take the World Wide Web, for example. It was going mainstream, but parts of it were more like the World Wild, Wild West. But I think that, in the rush to show the world the cool stuff the web and digital were bringing us, some steps were missed.
So, the visual programming tools of that period were really more about “look what we can do,” rather than “look at what you can do.” So, the end result of that philosophy is shaky extensibility (if there’s any at all), slow code generation and little to no cross-platform capability. In addition, in-depth programming skills and mindset were still the name of the game.
The only thing that’s constant is that nothing is constant
If there’s one thing I’ve learned since I started writing about programming languages and development trends in 1998, it’s that nothing is constant. When I invested in my first Mac in 1996, I had no idea I would replace it with a laptop just a few years later. And when I upgraded to one with an Intel Core i7 processor, I had no idea that it would end up gathering dust in my home office while I played with my smartphone and tablet in my living room.
In this mobile world, people want apps for almost everything. In addition, there are the other trends that are in the backlogs of today’s developers. These include solutions for cloud, machine learning, data science, artificial intelligence and IoT, as highlighted in “The State of the Developer Nation, Q1 2017,” the report compiled by Developer Economics. So, all of a sudden the already significant amount of knowledge you need to build software and applications in this brave new technological world has skyrocketed.
Now more than ever, we need to move away from the slow pace and nightmares of hand coding to something visual that makes development as easy as GUI interfaces make almost any computer task. But we don’t need the visual programming of the 1990s; we need something new and improved. And now we have it: it’s called “low-code.” An easy-to-understand name that Forrester coined in 2014.
Low-code is visual programming of the 1990s on steroids
Although low-code development includes visual programming, I want to be clear that this is not your father’s visual programming. Yes, it’s true that common code elements, workflows and business processes are turned into components so you can drag them around and drop them into a visual IDE. But there’s even more to it than that. Application deployment, updates and generation are automated. You’re doing more than building applications visually using things that have survived the tests of time and software battles.
More specifically, rather than starting a project by hand-coding, some basic routing or writing a set of failing tests, you draw the shape of your application. You define the precise workflow your application needs to address each possible scenario. You draw the UI. You specify the data your application will store and how the database will store it. And, you use your visual IDE to integrate REST APIs with your application or integrate your applications with other systems, such as an SAP ERP.
What about low-code platforms gives visual programming staying power?
The ability to leave the choppy, inwardly focused, released-too-fast ways of 1990s visual programming is becoming easier all the time. That’s huge. In the Forrester Wave: Low-Code Platforms Q2 2016, they rated the top 14 vendors of low-code development platforms out of a much bigger number. The fact that Google has thrown its hat in the low-code arena is another sign, as is a recent article in InformationWeek about low-code.
Here are the reasons I think low-code has brought visual programming back to stay:
- Flexibility: You work in an IDE for visually defining the UIs, workflows and data models of your application but you can still add your own hand-written code (code you already know) where necessary,
- Automated database integration. Low-code platforms transparently convert your data models into relational tables and SQL queries. And, data from external APIs is automatically made available from your application. This is not your typical ORM. It includes change management from the database all the way up to the UI.
- No more deployment, maintenance and change nightmares. Automated tools build, debug, deploy and maintain the application in test, staging and production—sometimes with just one click.
Basically, everything that anyone ever complained about in forums related to visual programming is gone, and the parts people loved are still here.
And, while low-code platforms do require a little training, I’m not talking months of schooling here. More like a few weeks. Plus, low-code makes it possible to avoid having to know more languages and technology than I can count, all of which are needed to meet the demands of web and mobile application development. What’s not to love about that? You get to take a concept and build it into a working app without going back to school to learn six more things that have popped up in the last few months.
Conclusion: Low-code keeps the heart of visual programming beating
So, Justin Timberlake might have brought sexy back, but low-code has brought the heart of visual programming back. It takes what was good about the early days of visual programming but adds a big advantage. You can jump right in and start describing your solution to a problem. You don’t need to learn a whole bunch of arcane details. Deployment, updates, integration, all are fast and easy, mostly because the majority of those things are done for you automatically.
As a result, when a request comes in for an app that uses fitness and heart rate data to propose a specific exercise program for a heart patient—in 2 weeks—you can get right on it. How cool is that?