A frequently asked question is "where is Access for the Web?", closing aligned with "what happened to 4GL languages and tools" or "where are the RAD (rapid application development) app builders for the web?". This is an answer; they've hit $100k monthly. They have found a market where many, many similar projects (I've listed them here before) have not. The relevant and amazing thing is how? How have they succeeded where so many others have failed?
The interview gives some answers:
He (Josh) was in New York, and everyone, literally everyone, was asking him to be their tech co-founder to start a business.
We started "recruiting" users at tech meetups in New York. With the startup wave, everybody was looking for a tech co-founder, and there were plenty of co-founder-dating meetups. ... We went there and told people that while we couldn't be their tech co-founders, they could use Bubble, as it would allow them build the whole thing themselves.
The following year (2013) we did a pilot at Harvard Business School, which I had just graduated from. Their first year entrepreneurship class required students to build something under a very tight budget, and Bubble was a good solution for this.
Answer; these guys had a kick ass network and expanded it. They had direct access to people in their market who were starving for this type of app.
And in those meetups you tend to find a lot of people looking for someone to code their ideas. These guys put a lemonade stand in the middle of the desert.
When you start building a normally-complicated application that isn't going to be thrown away at the end of the semester, well, then what?
The fact is that if you can think and communicate precisely enough to describe your ideas then you can enter them into a computer fairly easily in a language like python or basic. If you can't then no matter how fancy your tools are you still need something intelligent (currently a human programmer) to pull the idea out of you and encode it.
Stuff like this isn't useful to people who are incapable of programming and is just a highly coupled mess that can't be easily automated and version controlled.
I believe this is worthwhile long range target that we can build up to on solid foundation, such as component oriented software. As the pieces come together, the harder fought wins that use and prove its foundation early on will pay off greater, later.
She did a year of com sci. She learned SQL at work. She can Excel with the best at her bank, with some VBA here and there. Still I had to coax her into learning Python for some bigger-than-Excel datasets. She wanted to for ages but just couldn't make the leap to "real" programming (her thinking, obviously not true).
Even when she tried we had issues installing things. She made good progress and almost got it. I sat an evening with her and we solved the issue. She had a lot of support to get over the various hurdles, support many don't have.
Obviously it's one data point but it highlights the issue. I think we've forgotten how hard it can be. Anything that helps should get a shot.
Programming math is high school stuff, but imperative programming is bullshit. Memory leaks. Exceptions. Callback chaining. Asynchrony. Model-change listeners. Spooky action at a distance. Legacy interfaces.
Functional programming fixes all that.
Programming excel is college stuff. RDBMS is bullshit. JOIN pain, batching vs caching, ORM, pressure to denormalize for performance at scale, eventual consistency at scale. Non-RDBMS solutions generally make sacrifices regarding ACID vs consistency vs performance. Bullshit.
Immutability in the database fixes that too.
There may be other specific problem domains where subject matter experts may be able to be productive, if given relatively basic programming tools along with specific, modular, abstractions useful to their problem domain.
I could see drone programming becoming something like this - a farmer may need to update his drone behaviour every day, but he may not be excited about learning to 'program' it.
They do some other full time job and can't invest 2000 hours per year for 5 years to become efficient at all the detailed things the programmers have to deal with.
The use case is people who can excel at Excel, but don't want to learn about dependency injection, semantic versioning, exception handling etc.
There is a large gap between what professional programmers are expected to know and the minimum skillset needed to write programs that are useful for one specific task. Many people in your typical office would benefit from the ability to (partially) automate some of the tasks they do every day. Implying that they have to invest countless hours to learn how to do that is part of the problem.
When I switched back to a shell after 20 years I realized how much a GUI hurts, how much I unlearned to work with computers. After decades of Windows and OSX, I got Arch with i3 (so no desktop environment). I am mainly using text-based software like the shell, bash, tmux and vim every single day. Then, it's a very small step to program or to get a programmer because you are already programming in little steps here and there and every day (bash scripts, vim macros, etc.) and you deal all the time with text.
Visual tools don't teach you to code, they introduce an unnecessary layer and create an even bigger insecurity when dealing with real code. Real coding with text is quite easy—and this should be the actual message. A very good example for an educative text-based coding environment which is even functional is Logo. But again, the best way to get into coding is to get an OS on your personal computer which focuses on the shell.
A story I've told before is my mum and the software that comes with her digital camera. This software is everything to her, if she want to back up the pictures she uses this software, if she want to print them she uses this software, she has no idea that the individual photos are just files on a disk. So what happens when she get's a new camera from a different manufacturer? Her knowledge is back to square one and she has to relearn all over again, this is what infantalising users has lead to.
Also, whether photographs or anything else use files stored in hierarchical directories is a historical accident. There are alternatives to file systems. For example, Squeak doesn't have files, hierarchically organized or otherwise, just persistent objects. EROS also took that approach.
I disagree. The main benefit of a visual tool (if implemented correctly) is that it exposes the constraints and the tool grammar to the user when implementing and not only when compiling.
The difference is more or less of that with clay, and lego blocks. Yes, you can design a house with both (Lego house). Clay offers an infinite shape grammar, but if all you want is a lego house, then Lego blocks are much faster.
Now, is the visual tool a cognitive crutch, or a bicycle for the mind, is another matter entirely.
I think this has rather psychological reasons. There is a good book from Seth Godin called 'The Dip' which deals with the problem why most are fast in prototyping but not able to transform a prototype to an actual implementation ('to stick to the end'). However, I think there is nothing wrong with a prototype to fully-implement rate of 100 to 1. Prototyping is how people learn as well.
Moreover, I am not saying that GUIs are per se bad. If I create vector-based graphics I need a GUI, when I browse the web I prefer HTML/CSS and a GUI's smooth scrolling over a text-based Lynx. Some programming languages like Java are better with GUI-IDEs but my main point was another one: That too much GUI in your daily life creates an unnecessary intimidation towards programming (if you are not a programmer yet).
That's a problem with this particular set of tooling then. In the past we've had drag'n'drop tools like visual basic which made rapid prototyping easy and you'd use the same tools for the final version. On the text side you've got similar tools like Qt and Gtk which allow you to slap together a prototype quickly and then use them for the final application. I always assumed react was quite similar.
The solution for this is simple, really: simply declare the prototype the working implementation, and put devs on the hook for maintaining it.
Lots of people can't code, and most programmers can't code well, yet very few people have been exposed to visual programming tools.
I'd look elsewhere for explanations:
(1) If those with more aptitude for programming are more likely to become programmers, and the demand for programmers increases, programmers with less aptitude have to be hired. (And the problem is made worse by excluding experienced older people when hiring.)
(2) Whatever the reason, very few women become programmers now compared to the past, so almost half the population is being excluded.
(3) There's less diversity in software now. There's only two operating systems (with the same user interface), and only imperative languages augmented with object orientation, mostly with C syntax, so programmers only learn to think in one way.
(4) Personal computers nowadays are basically appliances which you can just use without programming, and that's what most people do. When they first became available, there was very little software on them and a far greater incentive to learn to program so that you could make them usable. For many people back then, programming became an end in itself.
> Visual tools don't teach you to code, they introduce an unnecessary layer and create an even bigger insecurity when dealing with real code.
There are different kinds of visual tools. Some visual tools (like, if I'm not mistaken, Bubble) are code generators so aren't designed to teach you how to code. Others are programming languages in their own right with no textual substrate, so there's no extra layer.
It isn't as if you need visual tools to introduce unnecessary layers anyway. There are now frameworks and other unnecessary layers, which of course mean you need more programmers to handle the additional complexity, and then you have problem (1). If the software industry designed aircraft or bicycles, you'd never be able to rotate your plane or ride your bike uphill.
> Real coding with text is quite easy
No it is not. Programming is hard however it's done, even visually. Concurrent, type-safe programming is even harder, and it's here that visual dataflow programming would help. MIMD programming is problematic in textual languages because there's an explicit ordering of operations, and there are synchronization issues which have to be addressed. Switching to the dataflow paradigm avoids this, but dataflow is difficult to express in text. Also, textual languages make type inference and code optimization harder.
> A very good example for an educative text-based coding environment which is even functional is Logo. But again, the best way to get into coding is to get an OS on your personal computer which focuses on the shell.
I agree with you about Logo. But Logo originated and was closely associated with the Lisp community centred around MIT, which had a very different way of doing things from Unix approach you seem to favour: a listener instead of a shell, multiple windows, and a programming language very closely integrated with the operating system.
There were lots of people who can build small to medium complexity apps in Visual basic in those days when VB5/VB6 was active (Pre C#/.net). Even as a developer I was happy to hack in VB any day than VC++. But any developer I knew back then wouldn't touch VB, claiming multiple reasons ranging from "not powerful", "no performance", "messy" (don't know what that means) etc. It was like developers wanted to be associated with complex languages in order to have a respect among the community. True, VB performed slower than VC and even lacked few capabilities (like you can't write a device driver or difficult to write a custom COM component etc), but it was perfect for writing business applications.
Not sure what destroyed VB, but I believe it was the web that changed everything. Java and .Net though are well designed and powerful, but they bring a lot of complexity, requiring new developers to spent considerable time to gain even a basic knowledge. With the advent of SPAs things went even worser, current SPA frameworks like React and Angular are adding layers upon layers of complexity to build some basic stuff.
IMO if you can hack a UI in a prototype tool like Balsamic, then you should be able to make it a working prototype within at least 2-3x the time you took to prototype it, including binding dynamic data from a web service. If in 2017 we are still taking 3-4 months to build a basic website (dynamic) or mobile app, we have failed somewhere.
Projects like Bubble are providing stepping stones towards a possible future where we can build UIs almost as fast as we can imagine/sketch them in a prototyping tool.
Try "thinking and communicating clearly and precisely" the process of multiplying two numbers larger than one thousand, in Roman numerals.
For me, it was very difficult if I didn't cheat and implicitly convert everything in my head to normal (Hindu) numerals first.
Now, try to do the same thing with Babylonian numerals (base-60).
(I tried and gave up)
What I'm trying to illustrate is that the tool you use to express an idea, imposes a hard limit on how "clearly and precisely" you can think about that idea in the first place.
Hindu numerals are one tool (one notation) that make processes such as multiplication and division easy to express. If such tool wasn't invented, we'd be spending too much time 'thinking' and 'expressing' and 'teaching' multiplication, and be left with too little time to actually benefit from it.
I’d like to point out that 100k is not a lot in this market. Dev tools are an 11 figure market with tens of millions of programmers. I think the biggest change is the surface area has grown so much that the failed visual tools of yesteryear might have been able to carve out sustainable markets today. Bubble, Webflow, and Square Space can all be succeess stories but that doesn’t mean they’re a bellweather for all of coding. There are clearly a lot of small problems (simple web apps) business needs solved that are simple enough for these tools. I say hallelujah! Now I don’t have to update the pricing page every 3 days and can work on the real problems! The only caveat is to keep everyone in their swim lanes and don’t let the wise Bubble intern shard my database.
The biggest issue are always the skills required to bring their ideas into actual code. Most of those tools still require an extremely advanced knowledge of calculus, DSP theory and linear algebra. Imagine if a fashion designer wanted to display a set of generative images displayed in the background following the catwalk ground vibrations (this was a real request). Even if he/she could accurately describe their idea, that would be still several magnitudes outside their STEM Skills. Most of the times we end up hiring an external dev who will be forced to use such visual tools, making his job even worse.
You might be right, but they're still making over $1mm/year in revenue.
However it will be difficult for non programmers. The very first dialog about Google Maps has menus "API provider" and "Query". I wonder how many non programmers know what they are. They can take a guess and learn but maybe this is still too low level. The second example is about building a login form by configuring its input fields. Maybe adding a completely configured dialog would be good enough for non programmers. Programmers can edit the details. Same for every other component.
However I remember that non programmers didn't use Visual Basic, as easy as it was. Programmers did. Some non programmers built sites on MySpace some 10 years after VB, then wrote on various blog platforms and configured themes, then ended up on Facebook and other non programmable social media platforms. Outside the Web the most used non-programmers programming tool is still probably Excel. I've seen amazing stuff build there from people who couldn't write a two lines script in Python.
There's obviously a big demand for this so either you're wrong or people using it are actually programmers.
The target market is those people that sit in places like the AWS loft or places like that, listen to tech talks and wish they had a coder to build their ideas for free.
Most of them already know what an API is. Even if you don't use the external data sources, what bubble provides is somewhat enough to win hackathons and get funding provided you can present and sell.
I've seen a bunch of traders, business people and otherwise people with random ideas that fit in that group. So yes, not at all surprised they make that much money.
Ah... now, in my mind, you're getting into Software Engineer territory. Programmer, to me, simply means you know how to make a computer do what you want. That can be "knowing how to search for someone else's code that makes the computer do what you want" at times. Once you get into thinking about the problem and how that related to what computers do, you're getting out of that generic "programmer" term and into engineering.
If you are a pro, you would know the industry, the hardware, how things communicate, how and why to scale and report things at a higher level, because you've been exposed to the needs and wants of an Enterprise.
Kind of wouldn't surprise me if the user numbers had a decent sized (probably not majority) programmer contingent; these kinds of services are a good way to get a quick prototype out, before you legit build something.
But while not "F U money" $100k p/m is enough to say: Well someone must be using it then.
Perhaps, in the Hooked sense, the somewhat diffcult learning curve helps to increase long term retention?
I work with non-programmers every day who know what APIs and queries are.
There are millions of people who are technical enough to manipulate Excel sheets, talk intelligently about API integrations, and tweak SQL queries but are not programmers themselves. Non-programmer does not automatically mean non-technical.
They used it just for the tabular form.
But I agree with you on everything.
I can definitely see it as a great and useful tool for non-programmers, but having to go throw your entire skill-set and decades of knowledge out the window to use a tool like this was just a horrible experience.
Again, I don't mean to disparage it, as I can see the benefits, but for programmers, you're better off building an app with the skills and knowledge you already possess.
The upsides are obvious – someone that's not a 'software engineer' can program things that do real work!
The downsides tho are much less obvious; more 'hidden' costs really. It's easy and quick to bang out a new feature, but also really easy to inadvertently update or rollback another unrelated set of changes. As a professional programmer, I sure don't want to give up version control, unit tests, integration tests, automated builds, and automated deployments.
Tho in fairness to RAD tools, and both the code they produce and the whole workflow involved in using them, when I started my current position the non-RAD-tool code was (much) worse, and much more difficult to refactor and cleanup, than the RAD-tool code.
I'm not sure how I'd feel about using it for anything larger than that, though I've seen some worked examples of Twitter clones etc. There's probably slightly too much Bubble-specific terminology and concepts to make it worth learning if you are not going to become a Bubble consultant.
Also, kind of expensive (monthly subscription) if you want to run a large production app on it. I love the range of API s and connectors though.
1. Write code
2. Run code
3. See error
4. Google error
5. Write code to fix error
I'd like a compiler that helps speed up steps 3-5. I know IDEs do some of this, but I'd like a compiler that automatically fixes errors instead of just telling me what went wrong. One that fixes parentheses that I left off or automatically fixes typos in variable names or function calls. One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice. One that knows when I wrote an inefficient bubble sort and swaps it out with a faster sorting algorithm etc. One that can make my code run faster. I think this is a long way off, and I know it's really hard to write a program that writes code, but it's always seemed that programming simple things is way harder and takes longer than it should to me.
> One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice
This is potentially an interesting idea.
> One that knows when I wrote an inefficient bubble sort and swaps it out with a faster sorting algorithm etc.
This is also the sort of thing that optimises out your security-critical delay loop or memory wipe.
Some of the other stuff you mention is not a way long off if you use an IDE like Visual Studio, which, with or without Resharper does a lot of code analysis. You get notified if you have dead code (branches that never get ran), duplicate code (i.e., things that should be turned into a common method or class), etc.
Webstorm can do some of what you mention:
One that knows to keep things DRY and creates a function for me when it sees the same similar code written twice.
Unfortunately this is "sufficiently smart compiler" territory. I'd love to be wrong about that though.
What you request in the last paragraph is a Junior Developer to do the grunt work of implementing a spec.
If so, great work! It shows there is a need for these simple, automated tools for building simple CRUD applications, and that it is possible for these to be built and automated.
I don't know Bubble but I am skeptical about visual programming, as syntax is one of the easier parts to learn when coding, and isn't in my opinion what makes our profession difficult.
For example: Game devs build themselves sandbox environments in which they can test out their physics engine, dynamic music systems, animation playback, etc. These sandboxes are like REPLs, but for non-textual data. One can imagine how much nicer it would be if the full system's code were represented first-class inside that sandbox, so that you were introducing and manipulating system abstractions close to the truest representation of the data, rather than having to leave the sandbox to go back to your text editor to make system tweaks, far away from the data.
Still skeptical about why that might be nice? Your text editor and terminal know nothing about the full, live representation of the data, so they do nothing to help you work in that domain. The nice things you get when working with text — diffs, versioning, etc — you don't get the physics engine / music engine / animation engine equivalents unless your code is somehow present in the same space as the live data.
Critical factor here.
I could see it as an interesting solution for rapid prototyping of ideas, but I'd be concerned about lock-in and extra expense later when migrating to something more robust.
You could also likely put a layer in front of Bubble to only serve some pages with Bubble, other with your replacement.
Also from the FAQ:
So you could probably add shims and move around.
I think the most interesting way of doing this would be something like embracing Bubble for a lot of work and having the "serious" code relegated to places that are easier to manage, like complex API or some custom widgets
This is basically what I do now at work. I was hired to, in part, work with several RAD-tool projects. I pretty quickly ended-up tho working on mostly backend code that the RAD tool projects interact with via, e.g. web requests. That's been a pretty good division of labor given that most of the RAD tool project's features are fairly simply in terms of UX. They're definitely not good enough to be widely used by lots of users tho, e.g. there's no real error handling.
Programming without code...until you need to actually do something
Mostly because there have been ideas to do this for around 40 years.
In the end any non-trivial business logic is too cumbersome to make in a GUI and is build much faster in text form ( programming language) or just can't be made with your platform. At that point it requires specialization and your need for a programmer is born.
> there have been ideas to do this for around 40 years
You should be "pessimistic" – if the implied claim is that "these types of products" will replace all of the other standard programming paraphernalia!
But, as you wrote, this stuff has been around for decades. And that's because there are lots of people that can do real work with these tools, but aren't otherwise willing to pay the (pretty) steep costs to get up to speed using the 'pro' programming tools.
I have a design background ( but can dabble in css, hack at php and python) but had trouble trying to get some APIs connected and displayed with Bubble.
Please oh please, can one of you developers have Airtable and Webflow make a baby? This combo would be amazing for functional business use and data display and I would pay good money for it.
In a post-Bret Victor world, we know what such an environment might look like.
Stop Drawing Dead Fish: https://vimeo.com/64895205
Drawing Dynamic Visualizations: https://vimeo.com/66085662
As a visually-minded developer constantly hunting for such tools, and even working on some myself (in a small way — nothing that anyone here will ever end up using, surely), I can assure you that there's enough smoke that eventually we'll see something like what we desire catch fire.
If I had to guess, I'd say we'll see it come out of the world of video games, not web applications. So don't fret that Bubble looks like a step in the wrong direction. They're not building tools for visual thinkers, they're building tools for MBAs.
I'm guessing this should be October 2015, but it'd be awesome if Bubble was a product from the future sent back in time.