I think you are radically underestimating the perceived barriers to entry with programming. You sound a lot like the Linux advocates who think everyone should just memorize a bunch of commands, and get used to using shell. This type of insider view is often referred to as 'the curse of knowledge'.
I think you're right about perceived barriers to entry, and I certainly didn't say (nor did I mean to imply) that anyone should "just" learn to code. But I think the promise of "apps without code" is a siren song, always ending in frustration.
I'd never tell anyone that learning to code is easy (only that most people can do it with some hard work), but I would also never tell anyone that tools like this will make it easier because I do not believe that to be true.
My counterpoint (to your original point) is that it's not about writing code.
Making an app like this and putting it online (with roughly the same level of features) requires:
* Learning a backend language, like Python
* Learning how to design a data model
* Learning how to design an admin interface
* Managing authentication, security, and performance
* Learning HTML, CSS, and Javascript
* Learning how to set up a uwsgi server
* Learning how to set up an nginx server
* Learning how to set up an AWS VM and deploy the above to it
* Learning how to use a VCS
I'm an experienced programmer and sysadmin who has done all of those things and more over the last 20 years, and I still can't imagine going to the trouble of actually doing all of that if I can just log into HoneyComb and make everything nice and quick and just get it done.
There's value in learning how to do it, but there's also value in spending your time somewhere else. If you're making a simple CRUD app, bashing it together with Django and deploying it to an EC2 VM is almost definitely not your differentiated value proposition. If it's just a throwaway app to handle some mundane task, then it's definitely not wort hthe time it takes to make it if you don't have to.
> I still can't imagine going to the trouble of actually doing all of that if I can just log into HoneyComb and make everything nice and quick and just get it done.
That sounds all nice and good until one inevitably runs into limitations of the software. And then it has to be made again, this time from scratch.
> bashing it together with Django and deploying it to an EC2 VM is almost definitely not your differentiated value proposition
It never -was- the value proposition. Customers simply do not care about what stack you used in the first place. They will care when features don't get rolled out because of limitations. Or when bugs arise because developers duct-taped solutions together because of the limitations of their software-making software. Not that traditional apps are perfect, but that's one issue they don't have.
Yes, it is complicated, and if you're making a toy app it probably will suffice. But I would never rely on it for a business.
You sir have options. Every place I have ever worked has at least one app that someone hacked together through some combination of PDFs, Excel and Access. This is a tremendous opportunity for those folks. The ones who will never learn to code, never learn to deploy an application and never get enough visibility to have a developer assigned to their project.
For the everyteam, these types of tools are exceptional. I continue to be amazed by what dedicated people pull-off with these no-code solutions.
> Every place I have ever worked has at least one app that someone hacked together through some combination of PDFs, Excel and Access... I continue to be amazed by what dedicated people pull-off with these no-code solutions.
VBA, SQL, etc, which is probably what these apps are
written with, are code though.
Honeycode is a language of it's own too, it's just a trade off between flexibility/power and learning curve.
Agreed. When I was a teenager a worked at an organization whose entire business was run on internal applications built out in FileMaker Pro largely by non-programmer teenagers and young adults. It was actually pretty awesome, and I was still able to drop into a basic scripting language on the few occasions I needed to implement some non-trivial logic.
Why wouldn't you? People have used excel scripting for real business tools for decades.
I fail to see how Honeycode outright disqualifies for everything related to vast field of "business" because of its limitations. In fact, I think that is very much, where it will be able to solve a lot of problems efficiently.
All of them? No, just like any other tool. They all come with their set of drawbacks.
It's interesting to me that Excel had a low barrier of entry, but more advanced stuff gets pretty unwieldy. I'm used to wiring complex SQL queries, but some Excel stuff takes me a while to understand.
I don't understand why Microsoft (or Google) never worked on making the formula bar easier to read. It doesn't seam hard to imagine a more visual mode to help work with complex formulas.
Sounds to me like something like Honeycode is exactly what is needed then, as a replacement for Excel in a business context. It is yet to be seen of course whether or not they can achieve this, or just replace one unwieldy mess for another.
Spreadsheets are a very good model, and they have tremendous potential (which has been fully utilized) due to their "visual programming" aspect, but the excel formula language, array formulas and VBA are not the best places to ramp up to when things get more complex and advanced. There's quite a bit of horror stories of Excel gone wrong [1]
I've been positively suprised that Microsoft seems to have started to finally improve this situation with things like XLOOKUP and increasing Python support in Excel.
Disclaimer: I've published in a group doing research on Spreadsheet improvements, this is the professor's publication history [2]
I don't have any that I can share publicly, but I've had to debug some fairly horrendous sheets.
Spreadsheets are a great tool that allows people to leverage computers without knowing how to code, but they can easily get awful to debug. Even excluding stuff like VBA; which is code, but gets included via google-driven copy/paste development.
For example, excel formulas from other sheets can modify cells in the existing sheet. This modification can be logically driven from changes in a 3rd sheet. So cell 1 in sheet A gets modified for some reason when something changes in sheet C. Formulas in sheet B are changing these values, but good luck figuring out that. Breakpoints aren't really an excel thing, debugging complicated sheets is very hard. Unfortunately, most of these sorts of files aren't available online, as they are viewed as the 'secret sauce' for the businesses using them.
Your landing page is too few on details, so maybe you have solved this problem, but from your comment it seems that you haven't had to approach it from this angle. Trust me, businesses run critical decisions on excel sheets with creation dates in the early 2000's, and the amount of tweaking can turn them into behemoths. That is why the low/no-code solutions scare me- easy to start doesn't mean that you won't have an unsolvable hairball in 5 years.
I have yet to hit the issues per se, but what I am partially betting on, is that once spreadsheets are just an interface rather than datastore (where possible), some of those issues can be resolved. One will loose realtime reactivity, but what they were trying to achieve anyway was to access a "canonical" data point.
I should have a video and more details on the website in a day or two
Very interested in this concept, I just am unclear how the interface & data can be separated in a way that is easy for spreadsheet users to understand. Users see the cell as the canonical data point, after all, they see all their data in front of them. Perhaps the problem isn't the interface but the way the underlying logic is hidden.
I'd be interested in discussing this more tomorrow, my email is my hn username @gmail if you want to hit me up when you have more details to share.
Think most people are missing the point. There are thousands of Excel users who can write fairly complex formulas using declarative rather than procedural approach. They currently share spreadsheets by email. The entire spreadsheet - all data and all formulas are shared. Maybe they want to share only a subset with some folks, and maybe they will start small and keep enhancing the apps.
That's what this tool looks like will accomplish. A new class of apps will be built - that have never been built before. The so called app market will expand.
This doesn't replace the current apps, or the current set of engineers developing these apps. This grows the overall market to be 10x larger than what it is now.
Yup sharing all the data is definitely a pain point, A question I once asked someone during a customer interview is what is that employee left? what happens to the data?
1) Agreed. Writing the code is the easy part. Determining and defining what to build? That's the magic.
2) In the wrong hands, making things too easy can be detrimental. First, there's add too much, simply because you can. For instance, WordPress n00bs are notorious for adding too many plugins. Why? Because they can.
The second reason is, changing too soon without enough data, without enough user input. Yes, iteration is helpdul. But if it's borderline pivoting then that's likely to end badly. Again, in the wrong hands.
Agreed on 2), software development has become too easy, look at all the rubish people are putting online and in the appstores.
Javascript, java and python have made it too easy to write software. Would be better to return back to the days when everything was written in C and Assembly.
I wasn't talkind about engineerss. I was talking about no-code and the type of people who use such tools. That is, typically, no training, no understanding. They don't understand "Just because you can, doesn't mean you should."
I'm not knocking Honeycode and similar. I think they're great. But they are simply tools. They are at their best when they are paired with a user with some understanding and sufficient knowledge.
To add to that - Determining and defining what to build is not magic unless you write simple and elegant code that delivers on-time and on-budget.
You can have all the magic in the world upfront with planning and have it fail spectacularly without the right execution that is accurate, on-time and on-budget.
That's true. Until you realize that the accurate execution that was on time and on budget actually built something that didn't actuslly meet the business needs. Then what?
Yes. Execution matters. But it's only as good as understanding the target. Miss that target (read: meet biz needs) and no one will say "Yeah. But it was great execution."
True. I just see projects fail more often than not due to time/budget and/or shit code. Rarely do I see it fail because what was built didn't meet the business needs.
Although if you're in start-ups, they plan and then build terrible products all the time so the attention to upfront planning and the business needs is way more important in that realm.
Point of low code is to get rid of those smart ass developers who know those magic incantations and demand loads of money for their work.
What you get in low code reality are smart ass business consultants that know magic configuration options and demand loads of money for their work.
Just look at SAP, Salesforce etc.
From my point of view any barrier to entry doesn't matter because at some level you just trade one complexity for the other.
For non complex stuff excel works fine and low code is not advertised as alternative to excel.
Doing anything nontrivial in SAP and Salesforce also requires coding, only now you're doing it in proprietary scripting environments like ABAP and Apex respectively instead of general languages like Java and Python.
Presumably we would agree that writing a web app is more economical in Python, Ruby, Go, etc than in C or ASM. Both C devs and HLL (higher level language) devs are well-paid and well-versed in their tool set. The difference is that HLL devs can deliver value at a higher rate than C devs for this domain.
If we can agree on the above, then presumably it's conceivable that the same abstraction principle applies with low code solutions--yes, low code users will know their tool well and earn loads of money, but they will probably move faster than traditional programmers for this domain.
In my mind, this only holds as long as these low-code tools are really more abstract and not just a visual/graphical programming language (I'm sure there are very low-level visual programming tools that would allow you to manage your own memory, etc). It also depends on the domain being amenable to abstraction--if you have to drop out of the tool with some regularity to do things the tool doesn't support (e.g., performance, custom analytics, etc), there's a threshold at which the overhead of calling into a lower level language exceeds the benefits of the tool. I don't know where this threshold is, largely because the domain isn't well defined.
But I do think low code solutions are conceivable for certain domains. I would make the argument that Microsoft Access and Excel either qualify as "low code" solutions or they are at least proto-low-code solutions, and they both deliver tremendous value. I would perhaps even say that Access/Excel are to client-side applications what these new low-code solutions are to web applications. Not a perfect analogy, but I think there's something insightful in there.
There is nothing "low code" about work in SAP. Any time you need something remotely custom you need to blow the dust off of ABAP and code it yourself. This happens a lot.
Salesforce even requires you go write up some Apex when you want to get into heavy customization.
Now take a look at honeycode templates, those look exactly like things that SAP and friends promise you won't have to code. Inventory management and customer tracker, this looks like they try to sell the same things. Even if SAP is not marketing their stuff as low code or even if you have to write a lot of code there.
Perceived barriers are just that though. This doesn’t remove them - someone still has to learn this system, and you’ve got to pay them to work on it. With a system like this, you’ll quickly come to the cases that business people love to create anyway: you can’t do X with Honeycode but you need to make it happen anyway. And then you’ll wish you’d just done the whole thing in Python.
> you’ll quickly come to the cases that business people love to create anyway: you can’t do X with Honeycode but you need to make it happen anyway. And then you’ll wish you’d just done the whole thing in Python.
If doing the first versions in this thing meant you got to that position 6 months earlier than you would've otherwise, you shouldn't wish you'd just done it in Python from the start - your business would be missing even the functionality it has now for another six months.
You will, though, need to get creative and figure out the fastest way to get something close enough to X to make them happy in the tool, or with a hybrid tool+adhoc script approach, etc, though.
So there's still a lot of benefits there to knowing the fundamentals.
it's very hard for a business process to do with "good enough" code. in many situation either the output is complete and correct or it's of marginal utility.
it is also geared heavily toward internal software, so it has a very narrow scope, it's not really for startup, it's not really for large enterprise with their it deps, it's not really for jim in accounting with his excel honed trough year of hard work...
it will find a niche for sure, but the harder part of the use case it covers is modeling workflow interdependencies and that complexity doesn't lie in the software
The third option is a small army of temps to clean up the data - either incoming or outgoing, in order for the "good enough" code to work acceptably well. Judging from how many of these so-called second-class employees exist in the valley, I'm not convinced that it's actually possible for code to be better than "good enough" - but that doesn't stop me from trying!
Writing a first iteration fast with no code is a smart move. You can later on create a second iteration with more traditional languages and tooling like Python.
I tend to disagree here. The thing that makes writing business software take a long time (using code, to be pedantic), isn't the fact that it's in code -- it's the fact that the requirements are often so fast and complex that there's no way to capture them in the application without taking a good chunk of time. If you want an application that doesn't actually meet your requirements, but at the very least, exists, get a group of competent-enough engineers together and they'll be able to whip you something up pretty quickly, I reckon. About as quickly as non-techincal people would be able to make something of equal usefulness in a non-code tool.
If you have access to only engineers, why would they learn this new non-code tool? If you want an application that meets a very sparse, loose set of requirements, just get them to create it using their normal tools -- it won't take relatively long.
If you have access to both engineers and business folk, there's no reason to have the businesspeople write such a requirement-lax application using a non-code tool, since if all you really want is an MVP that doesn't really meet your requirements, get the engineers to do it -- I'm sure they'd be happy with the freedom to throw requirements out the window. And then when you want to expand on it and flesh out those requirements, the engineers don't have to port the whole thing over from whatever proprietary non-code tool the businesspeople could have used.
If you only have access to nontechnical people, you're kind of screwed. Sure, you can have business-savvy folks whip up an MVP using one of these tools, but then when you want to expand on it, what do you do? You need technical people somewhere in the pipeline to make this work. If you didn't have access to engineers in the first place, this is the juncture at which you could hire some to port the application, but is the technical debt you've introduced worth it?
I don't know -- tools like these seem to target aspirational nontechnical people who don't have the foresight to think two steps ahead.
It has been my experience over and over again that having a mix of engineers and business folk, does not lead to the business folk getting the engineers to do what they want. Which is why we see so many things built in Excel and Access - the business folk know what they want, but their bosses send the engineers off is some crazy other direction.
A MVP is quite often exactly what these people need to get the bosses engineers working on the right product. And often it's not enough and the business folk end up using Excel for 20 years with a string of failed products coming out of engineering.
As a programmer, I'm very lucky, but none more than here. I have access to an infinite amount of programmer time. Okay, realistically that's bounded by the number of productive hours in my life, and more realistically, my level of interest in a thing. But it's easy for me to tell someone else "oh yeah, just get a programmer to do it" - because if I had those same desires, that programmer is me.
But looking at the job market for programmers and the salaries commensurate with the demand for them (both in and out of the Valley), "access to a programmer" is something that many people still have to reach to get, and "learning to code" is not a quick or easy process. Honeycode isn't the first product in this space, nor will it be the last.
Indeed, I've observed that while programming seems easy, a large fraction of people find learning to program is utterly prohibitive. This includes many really smart people. And I don't think we understand why.
But here's what I think you give up if you don't have code. Over the past 70 years, one of the problems that computer science has studied is how to manage the size and complexity of programs and development teams. This complexity includes not just the program you're working on, but potentially the entire ecosystem of algorithms and solutions available for your use. Nothing comes close to "code" for addressing this problem.
As a result, I think if you're going to give up code, you have to accept that your projects will run out juice if they get too big or complex, or that you will have to solve some interface problems with manual steps. That might be perfectly OK.
> one of the problems that computer science has studied is how to manage the size and complexity of programs and development teams
Did we though? Can you point out some books, or PHDs or whatever slightly more scientific and substantial than blog-post anecdotes?
I honestly believe as an industry we completely don't know how to scale development and I would love to read something that helps understanding this challenge.
Well... I have to admit that I'm not a CS'ist, and I just assumed that a lot of the progress has come from CS.
But I'm just thinking of something like the transition from BASIC to Pascal (which I experienced in 1983). There were rules of thumb that we learned in BASIC (avoid global variables and GOTO's) that were formalized in Pascal, and Pascal also let you create much more elaborate named structures, and control the scope of names more precisely.
That's just one really simplistic example, but it rather profoundly improved my programming. On the other hand, I can believe that scaling is still a struggle -- there is still a point where we run out of juice, but it's a lot further than you'd get with BASIC, or with Excel-sans-macros.
> You sound a lot like the Linux advocates who think everyone should just memorize a bunch of commands, and get used to using shell.
But they should. People aren't stupid, shells aren't horrifically complicated if you try a bit and once you climb that hurdle you're suddenly a "tech genius".
Just like some developers should learn that developers are users too, and not all of us enjoy doing the stuff the hard way just because it feels better somehow.
I hope you don't really believe that people use the terminal because it is "the hard way". That simply isn't true. There are things where the shell makes it _easier_ to do things - the most common being batch operations. There have been attempts to build GUIs around such tasks but they actually take more effort to understand than using the terminal.
Just like every tool, the terminal has its place. So do GUIs.
I agree. The shell, just like all other programming languages, allows you to trade the time spent learning a domain specific skill for an easier method of doing things.
Using the batch operations example -- if you know shell scripting, you can save yourself time doing things manually -- but you need to have already traded in the time to learn Shell scripting.
GUIs allow you to reduce time spent learning a domain specific skill at the expense of overall efficiency.
Yes I do, my UNIX experience goes all the way back to Xenix and I have used most of the UNIX commercial clones, and also did porting across multiple platforms.
Whatever the UNIX shell provides, can be more comfortably over an interactive graphical REPL, which even allows for proper graphical debugging tools when pipelines don't work as they are supposed to be.
Secondly, since UI/UX has always been one of my focus, I have seen too many throw away CLI tools that don't respect the users of the tool, because "hey they are developers as well, they can fix it, deal with its issues".
Grandparent said "that learning to actually write Python or Java or whatever is not the hard part of being productive in a business context". I think that my response was reasonable, and directly addressed one of their most important points.
writing a good (english) novel is not just about learning the english language and grammar. But it is required that the novelist understands the english language well, but it's not sufficient - the novelist also needs a good grasp of more abstract concepts and have creativity as well.
I think he's partially right, and you're also partially right.
Learning to code is an extremely high barrier to wntry, but its also highly transferable. If you can write Python, there's tons of jobs you can get writing Python, and with a little extra work, you can pretty easily transition to another language with a whole other world of opportunity.
The problem with these "visual" languages, is its a lower barrier to entry, but its still takes a detail oriented person, and ends up being very specialized, so there's less opportunity to leverage that to another job. So if you're a person than can learn a visual language effectively, you might as well go the extra 30% and learn to code in a "real" language.
The only thing low-code solutions do is lower perceived barriers, not real ones. A low code solution has done it's job if it got you to sink enough time into it that you're stuck with it. They're great for prototypes and simple tasks.
Low code solutions work by presenting a simplified view of the world to the user. Once your vision doesn't mesh with their abstraction, you end up having to dive under the hood if you're lucky enough to have a solution that lets you. In the best case, you've now had to learn the underlying tech and the abstraction.
There are enough bariers in the earlier steps for those barriers to entry with programming not to matter.
1. Understand the problem
2. Break the problem into subproblems. Goto 1 till subroblems
are small enought to be tackled.
3. Develop the algorithms for each of the subroblems you got
after step 2. No handwaving allowed.
4. Implement the algorithms.
I'd say for majority it ends around the step 2. Programming only matters at step 4.
I think you are doing software engineering at step 2 as well (base case and build recursion for example). The reality is, CS skills are useful even in low and no code scenarios.
I think the emphasis here ought to be on "perceived".
Having taught people to code, there's a lot of "perception" about what is hard that you need to overcome, but in practice, people learn that part comparatively easily.
