A friend of mine once said that it never was as easy to develop an application as it was with Visual Basic 6. It was quite an “ah-ha!” moment and she definitively was spot on! There is a lot of potential reasons to expect things to be more difficult. Primarily a more diverse computer environment with entire new class of devices like phone and tablet. Teams are much more spread than before, so we use tools like git, GitHub and VSCode live-share to work together. In many cases we expect a lot more custom looking application, whereas they used to be the exception (Remember Winamp?). We also have to deal with networking and mobility. All this complexity and niche details has lead to separate tools specialised for designers, backend and frontend developers.
When you look back at the Visual Basic Classic era, two thirds of all business applications were created using the tool. It was an overwhelming success. The simplicity to create quickly a graphical application that could manipulate a database was driving this development. It was simple to get things going because it was hiding all the Win32 APIs and database complexity from developers. You only needed to use the form builder to create your window, connect to a database and add a bit of logic to glue all of it together. It was simple and fast to get an application running.
When simplicity is forgotten
Its downfall is also interesting. The language became more complex and required to rewrite applications when moving to VB.NET. The simplicity was also lost when you wanted to start making use of the newly growing network of the Internet. Microsoft forgot that Visual Basic thrived on making things simple. The fun part is that even if Visual Basic Classic is not supported anymore, all of its use hasn’t stopped yet. I was contacted 3 years ago to migrate one of those application. Yes, in 2020!
This makes me wonder if it is possible to get that simplicity back and what needs to be done today to get there. In a sense, I think Go has that accessibility and simplicity of the visual basic language and you can come from language like Python, learn to use features progressively and not feel lost. At the same time, it brings a lot of tools I wish existed when coding with Visual Basic. You can pick up those tools as you go – leveraging some amazing test, fuzzing, benchmark and profiling infrastructure. Maybe the only things missing is a debugging mode where you can preview your app as you code… Not sure I really would still want this today! 😀 Connecting to the network or using a database is really simple and a lot of the complexity is hidden from you by the standard library and the various module you can find in the ecosystem. Simplicity is key in the Go language and ecosystem.
Building GUIs the Go way
On top of the Go ecosystem, Fyne makes it simple for developers to build a cross platform graphical application that can be distributed quickly and easily (single binary \o/). It is possible to leverage the entire Go ecosystem to connect your application to a remote API, a VPN, a database, … It is quite nice to spend just a few hours and quickly get a result that you can instantly share with tool like fyne-cross or Geoffrey on all the modern major OS and platforms.
I am starting to think what we are missing from the Fyne and Go ecosystem, at this point, is the visual editor that came with Visual Basic. It needs to be imagined into what we want to do today, with simplicity in mind.
Simplicity and collaboration
Team work is a core feature of an any modern tool and collaboration should be centre to such tool. Having one team where designers and developers work iteratively together within the same environment sounds like it would be a good step forward. Git and live-share ala Figma/VisualStudio Code are something to include in the design of such a tool.
One of the great successes of Visual Basic was the ecosystem around additional visual component that extended what you could do with the visual editor, and that seems to still be a great idea today. Maybe an improvement would be to have a way to discover those new components from within the editor and be able to customise your palette to match project needs. We should be able to design, test and adjust the application for multiple platforms right from the visual editor. And this could be delivered as an online tool or a standalone one to match designer or developer preference.
It would also be useful to provide a simple low-code way to add interactions with online API and databases. And yet the output of the tool should be something that can integrate easily with the rest of the Go ecosystem and the code generated or edited must be clean, testable and maintainable. I think it should be possible to progressively step out of the tool, moving from a low code to more complex tasks as the developers learn more about Go without losing all the previous effort.
What do you think should be the direction of such a tool? Did you have any experience with Visual Basic or Delphi? What features do you imagine would make sense to have today? What would make you and your team use a tool like this? Please leave your emails below so we can start a discussion that will shape this defining tool!