At one large insurance company in my role as an architect I have tried to convince people we need Elasticsearch to speed up free-form queries to our database containing information about hundreds of millions of people and their contracts. That database was Oracle and so not really amenable to completely arbitrary queries.
I was immediately shot down that the project will take huge amount of time and effort to complete and so is completely off the table.
So I came up with fun plan. I set up an hour-long meeting which was supposed to be my last chance to pitch the project.
Rather than present slides and extol virtues of Elasticsearch, I decided to WRITE THE APPLICATION DURING THE MEETING, FROM SCRATCH.
And that's what I did. I came to the meeting, set my laptop, connected projector, put some music on, and I wrote the entire service from scratch and had time to spare to present how it works.
I cheated a little bit, of course. That 1h meeting was well rehearsed. I spent entire week preparing, finding better ways to do stuff and retrying entire process dozens of times.
I used JHipster to generate 90% of the service and the rest was just tiny bit of well thought glue code.
Unfortunately, this did not sit well with couple of people whom I made complete mockery of. I had to leave soon after.
I sometimes dream of doing something like that when there's endless back and forth about the "right" way to do something (in my experience, no one is actually looking for the right way. It's all just politics and laziness which ends up in a subpar compromise).
How did you convince people to sit through the entire hour once they caught on to what you were doing?
Always be leery of emulating such actions. No matter how much detail they give, you will never know the full context and how well your situation compares to theirs.
You are reading way to much motive and way too much power into a casual observation about how so-called courage is sometimes anything but.
People who seem "brave" may not feel they are at all brave. They may feel fed up, resigned to their doom, disgusted, defeated, like arguing or cooperating with known liars is utterly pointless, like they are screwed anyway and nothing they do will ever fix it.
Sometimes it's nice to get closure and know you weren't imagining things, it really is as bad as you feared and you can stop wasting your time and energy on a situation that simply will never go anyplace acceptable no matter what you do.
I'm glad you answered the question directly with your own opinion. (I don't know why people don't do that more often). I think that is a wise and well thought out piece of advice that should be expanded upon. I did want to get past the layers of what you were assuming this person had experienced or what you assumed naive readers would do if they copied it. One thing I've learned - a reason I used to be a bad writer, and a reason why social media doesn't work well - is that I tend to gloss over four or five assumptions about what the reader understands or knows, and jump straight to a conclusion that can come off as weird or out of step. It does help to pry open the thought process that led to a warning or a sweeping statement... often, the thought process is what people are most interested in.
On this issue, I've never worked anywhere I didn't either start with or quickly open a direct line to speak with the owner of a company. I consider it their right to know what's going on - and I never sought advancement or raises, and more often quit, but I do think there's something to be said for sticking your head up and taking the risk of having it cut off, to prove you're right about something. That derives from a different impulse than the need for popular acclaim, and it's usually dangerous.
What would you tell someone who is genuinely trying to communicate a message to their boss's boss, about how things are mismanaged or how they could be done better... assuming that person is not lashing out from despair but actually wants to help the company?
At best you put yourself into the middle of a political fight fought levels above your head.
Why put your job on the line for no reward? Who cares if their Oracle queries are slow?
That's a my take on it, anyway
That's just life right? Yes but the point is for the former type of people it is very frustrating to work with the latter type, because not only you have to do a great job, you also have to put in a lot effort to fight the politicians. It is often better to get the hell out of Dodge rather than stick around with the bandits.
I agree, 100%, but this sentence is also the problem with OP's approach. Like it or not, being effective as a software engineer isn't just about getting things done. First, you have to get the right thing done (sounds like OP has this covered, though).
But, perhaps even more importantly, if you want to actually have real impact, you need to make sure the things you've created actually get adopted in the organization. And, that's literally the definition of "political faffery."
There's a very real sense in which anything that involves more than 3 people is going to involve politics in some way, but that's not what I'm talking about here. I'm more referring to the definition in The Devil's Dictionary, by Ambrose Bierce, specifically the first part: "A strife of interests masquerading as a contest of principles. The conduct of public affairs for private advantage."
As a mid-level or senior-level engineer, if you've been at the company for a few months, you should have some relationships that you can use to navigate the political landscape. As a staff or principal engineer, it's practically your job to have these relationships. As a junior, you should be looking to your manager, or higher level engineers on your own team to help you, should you get involved in a political mess, but, the best thing to do is to loop in your manager ASAP and avoid politically sensitive issues to the extent that is practical.
But, the bottom line is really just about power and numbers. If you don't have the right person or people on your side, if you try to bypass or undermine those people, or, sometimes, if a lot of people are really against you, it does not matter how technically great your project/service/process/whatever is. It simply will not get adopted, because you threatened entrenched interests.
If you're unlucky, and either don't have sufficient political capital, or you managed to expend most of it during this whole affair, this is where ignoring politics can ultimately lead to a not completely voluntary trip out the door.
I've seen projects that were brilliantly managed politically, and I've seen ones that weren't. Brilliantly managed projects aren't generally going to be the ones you notice, unless you're specifically looking for them and watching the politics of the whole affair. These projects often just look like projects that are succeeding, to the superficial outside glance. Even if there are technical delays, the fact that there is political buy-in for the project means that if you're championing such a project, you won't suffer for having your name attached to it.
Projects that weren't well managed politically can tend to start off well, but turn into shit shows later. Best case scenario for a project that doesn't achieve buy-in is that it gets shelved in favor of another approach. Worst case, the project is radioactive, and that's where it can lead to an involuntary trip out the door.
TL;DR: You can't care about getting things done to the exclusion of politics if you want to have any actual impact within an organization. Politics can easily make or break the success of a project, and it can be hard to tell if you're stepping on a political landmine unless you know the terrain well.
Typically in these large orgs, writing an app is only one of the first steps; they also need to be maintained, updated, monitored which might require extra budget, which typically nobody wants to pay for because "everything works".
If you ever end up in a similar situation, you could consider the environment as a part of the challenge before you figure out a solution.
Nevertheless, the 1 hour meeting is a hilarious story, although I personally would avoid burning bridges on the way out: it might hit you in the face in another context when you least expect it....
Now, my cynic side of me also wonders: perhaps Elasticsearch wasn't the answer and that's why the proposal was shot down? We'll never know. What I do know is this: software engineering is as much about humans as it is about tech, so even if you know you are (technically) right, don't forget to address the issue from a human perspective (i.e., convince your colleagues that your solution is right, but don't make fun of them by highlighting how one individual (you) can make the whole project "in just 1h").
I think lmilcin won when he got to quit :-)
Was the right thing, I think (based on the info available here). There's an opportunity cost in staying and wasting years of ones life at such a place
(Note that GP wrote: "I was immediately shot down that the project will take huge amount of time and effort to complete and so is completely off the table" -- that was the stated reason for refusing it)
Honestly, I knew immediately when I joined that I made a huge mistake. My patience for bullshit is very short and I am extra infuriated by people who just don't care to do a good job or help the company (that is paying their salary) and are completely fine crippling their own project for some strange power games.
I knew that if I was going to do what they (management) wanted of me -- which was to sit quiet and do nothing, I would have to leave anyway.
So I decided to give it a shot and it did not work.
But it sure was fun to watch these people trying to gather some response before they had a chance to reach their back channels to solve the problem another way.
First of all, a good CTO would probably fire the lot immediately. But secondly, there's this human dynamic - did you ever have to work on a chem project in high school with 3 randomly assigned classmates? Were you the one who made sure nothing exploded, and then found yourself writing the paper and sharing the grade with them? Sure. Because they knew you would pull the weight. And they would go on to be middle managers just as lazy and work-averse as they were as teenagers. They prey on us... the people who think hard enough to do better. I don't know why you'd ever want to join an organization like that, but it's good you found a booming way out of it.
For example, in a development team the shared skill sets could be ability to code (so don't bother with Scrum Masters and Product Owners who can't appreciate coding).
But it does not have to be coding, I have also seen teams which were all proficient in financial markets and used it as their language.
The complementing could be:
- one with long beard who has lots of experience and knows how to and how not to do stuff, can debug the hell out of everything and acts as problem solver of last resort,
- one who knows how to make beautiful graphics and UIs,
- one who knows how to manage infrastructure efficiently and reliably and knows how to do all the tiny pesky things to make stuff happen,
- one who is good at understanding the product side and can be liaison between dev team and clients/management (assuming he understands to use "we" rather than "I"),
- one who is not afraid to dirty their hands and do the absolutely most mundane stuff that nobody else wants to touch with 10ft pole,
and so on.
I think this promotes ownership which is always a good way to get them motivated. On the other hand having people with exactly same skill set (for example due to constant hiring profile) tends to result in people who feel to be exchangeable cogs in the machine and less of ownership. At least this is my subjective feeling.
Hope you were able to find a better fit!
Group of managers wanted to choose Oracle based technology for this that would further entrench their team and they argumented they can do it faster and cheaper than the development team.
They have already succeeded getting sizeable part of business logic implemented in PL/SQL supposedly to improve performance.
ES would make all their plans obsolete in a hurry.
Obviously, they were not interested in improving the product but in grabbing power, budget and control of the development process. Also they needed to score some points to show they accomplished something during calendar year.
Of course development team was also slow to deal with problems and overworked with other projects. This only fueled actions of database operations.
So my actions angered both managers of database operations as well as development teams.
That's true. Most Open Source solutions don't work on huge workloads. You can read about Hadoop at Facebook or MySQL. They fully rewrote MySQL engine and partially Hadoop. Oracle solutions work well on huge workloads.
This company is not a software developer. The software department is just another team inside the company. The first goal of any non-software company is to reduce costs for IT infrastructure and development. It's not Google or Facebook where software development is a key factor of company capitalization.
> Obviously, they were not interested in improving the product but in grabbing power, budget and control of the development process. Also they needed to score some points to show they accomplished something during calendar year.
Or just do their job: provides a reliable service for storing data. The main goal of the DB/SysAdmin department is to show 99.99% uptime. The software department could not guarantee this uptime. Of course, if all these software developers are good SRE that's another situation. But I'm sure no one has experience of supporting huge systems for years.
> So my actions angered both managers of database operations as well as development teams.
If you really want to change something it will be better to make a virtual team from both departments and discuss all pitfalls from both teams. Maybe you are solving non-existent problem.
Most “huge” workloads are not actually Facebook-huge.
But if you agree to their rules then you must play by their rules, politics, and if you then don't put your best effort into playing politics you may find yourself on the losing side soon.
Ultimately you will lose in either situation, but one solution prolongs the paychecks.
All you have to do is not push an agenda to improve things your way. Sounds easy..
Looking at this another way if that person wanted to get fired for no cause this might be a good way.
Also you need to realize it wouldn't be very wise to run your just written code directly on prod.
And data to be indexed was incredibly complex and rich. So every detail of every car you own, family member information, addresses, phone numbers, emails, identification documents, details of your contracts, and so on.
My cluster of 6 instances could index ~20k large, complex docs per second while still serving production query traffic.
In my experience, managers aren't usually malicious, they're just risk-averse. They've seen good pitches turn into failed projects. A working PoC counts for a whole lot more than just a plan.
This sucks, but it is the only option when you only improve one facet of something. If on the otherhand you could do the whole business then it is time for you to found.
If you find yourself considering doing anything of the sort, you should just quit. And you might say what's the difference - he ended up quitting anyway. Yeah, but he also did so by ruining his reputation with a bunch of people who you might say you don't care about their opinion, but they'll talk to other people whose opinion you DO Care about, and they won't tell a charitable version of this incident. They'll just say that you weren't a team player, that you don't know how to collaborate with others, and to not hire you.
What he should have done is spent a week writing a document to senior leadership preparing an executive overview explaining the process he would follow, tools to use, and a detailed breakdown of the estimate of building this system (by someone else mind you) - in a timeframe that he understood the leadership would accept as reasonable - but longer than 1 hour.
Then he should have presented the document to them.
Except this rarely works.
For starters, senior leadership also plays games only on higher level.
Second, they don't like wild cards they can't control. And even more, they don't like people who skip chain of command because they want to control the information that passes up from their organization.
And this particular company is extra political.
In my team, there were only people who worked there for more than 10 years or less than a year.
There is special type of person that feels well working there -- one that is fine doing nothing and playing cutthroat politics game. Everybody else quits right away.
It was my mistake for not learning this before I joined. I have now a protocol to look for that kind of thing.
Sure, the ppl you embarrass might talk. But they won't say much, and likely won't have a lot of credibility.
At least this shows a grounding in reality, has the only chance of success (a white paper /proposal was already shown to go nowhere), and supports the (likely few) other people who care about reality & getting things done - ir at least shows them the consequences so they can adjust their own path.
If you are good, in this economy, you'll be in demand. So don't play the coward's game - be bold, speak (& show) truth to power.
Anyone who does this is not a dumbshit, those who get in their way probably are.
OP: would love to make your acquaintance, email is checked in profile.
While it's very intuitive to see the appeal in low barrier to entry, there's something to be said about tools that optimize for the long-term. Instruments aren't made for beginners, they're made for people who know how to play them.
Today, (I believe) most artists use synthesizers and DAWs to create full albums. Eletronica, rap and hip-hop are some of the most popular musical genres  . It's not uncommon to see artists that are just one or two people, enabled by a professional grade studio on a PC.
Of the genres you mention, only punk could reasonably be considered a low barrier to entry genre in that some of the biggest punk bands were famous for hardly being able to play their instruments. But it's also the single genre missing from your "Today," paragraph, indicating that yes, indeed, making good hip hop or electronica is hard even with a fantastic computer with fantastic software.
Today, it's still how a lot of hip-hop and electronica gets made: https://en.wikipedia.org/wiki/FL_Studio#Notable_users
I think the idea that getting good at making, say, trance with, say, FL Studio is somehow easier than learning to play, say, a guitar and making good, say, metal to be ridiculous.
You can get pretty far in FL Studio with a four-to-the-floor kick-hihat-clap beat and some synths, just like you can get pretty far with four power chords on a cheap Stratocaster. It won't be good though, not really.
Before finishing reading that sentence, i was ready to get upset, but the ending made it so that I perfectly agree with you.
Modern music production experience allows for a fairly easy way to make ok music, but to make good or great music, it is still just as difficult (if not even moreso, albeit not for financial reasons anymore, unlike how it used to be in the past). Basically, easy to learn at a beginner level, still difficult to master. Which is imo the optimum, because some of the best competitive games ever are set up like this. E.g., learning the rules of chess is easy, mastering chess is an extremely long path.
A bit off-tangent, but we also gotta understand that genres evolve from infancy to maturity as well. In terms of music production and composition, 80s/early 90s hip-hop was indeed fairly basic and primitive. Lyrics, similarly, were also focused mostly around the same cluster of topics related to living a tough life surrounded by crime and police brutality and such. But it was new, original, and covering bases that were not covered before in the same way.
Hence why it started gaining traction and popularity. As genre matured and evolved, music production for it got much much more complex and involved, where the ceiling for "well produced hip-hop" has went up massively. Just compare any track from Kanye West's "My Beautiful Dark Twisted Fantasy" (2010) to some classic like NWA's "Straight Outta Compton" (1988). Both groundbreaking albums for their time, both still enjoyable, but there is no way to compare them in terms of music production/composition in a serious manner in 2021, as it is just night and day. The sheer complexity of MBDTF is something that set the new bar for the entire industry on its own. Lyrics on MBDTF are also touching topics that early hip-hop would never touch with a 10-foot pole back in the day.
TL;DR: fully agreed, music production became much easier to enter and produce beginner level stuff, but the ceiling went up significantly as well (which is a good thing). What was groundbreaking level production in the late 80s/early 90s will get rotten eggs thrown at you in 2021. Which makes hip-hop music production (as well as most other genres that are evolving) just as difficult of an art to master these days, if not even more difficult, but only because the bar is set much higher. The actual availability, cost of equipment, learning material access, etc. has become insanely easier.
Nowadays it's very easy to create OK software - with modern frameworks, tooling and templates we've enabled an army of "high performing beginners". For web software we can even deploy it with two clicks thanks to modern cloud providers.
However making something that is good or great, as ever, requires a huge amount of knowledge and experience. The kind you only get with years of practise and learning.
DAWs provide most of the benefits of synthesizers and drum machines with the additional benefit of being a production studio.
You rightly point out the barrier to cost is being reduced but, in my opinion, this goes hand in hand with complexity. After all, I "could have just hired a band" to experiment, play around and bring my vision of music to life. Is putting a band in a computer for less than $300 "just a matter of reducing cost"? Encapsulating complexity is often synonymous with reducing cost.
Any tool, even ones that are cheap and/or encapsulate complexity, require training to use well. The question is whether they can be used "professionally" with a modicum of training or whether they need a lifetime. A good artist can probably be proficient enough with a synthesizer, drum machine and/or DAW in a year or two before starting to create quality work. It takes a lifetime to become a professional at the piano or violin, often requiring exponential more work for increasingly marginal gains.
However it still takes a long amount of time and a lot of practice to fully mesh your brain with the piano so that you can use it as if it was an appendage of your body. DAWs are no different, in fact a DAW is considerably harder to start using than a piano.
A good example is a tool like `create-react-app` (especially if you add TypeScript support). It's super easy to use and creates the project scaffold and enormous JS build system for you, but good luck trying to fix it if something breaks!
I used to be a huge fan of lots of small libraries updating often, but now that I'm in an enterprise context, it's hard to say the same. I wonder how people deal with this.
The joke gets worse!
Wait till you have to support this system over the upgrade paths for those 1000 dependencies of varying pedigree and funding, and React has changed their one true way often which effects those libraries many of which jut deprecate and you have to find alternatives.
Is there even such a thing? I know that there was class components and then function components and then hooks, but outside of that, the insistance on React being a library means that the ecosystem is very fragmented. There's CRA, there's Next, there's Gatsby. There are lots of different ways to do CSS. TypeScript? No TypeScript?
I wish there was a frontend framework focused on stability over time.
they don't, and just stick their head in the sand. I know i do!
I've never had a good long-term experience with tools that try to be or solve everything for me, and today I avoid them.
I've always found myself experiencing that same feeling, but I've come to realize that this is essentially impossible to avoid by definition. Any tool or system you're using that is built using abstractions must by definition have some limitations at the boundaries of those abstractions, and those limitations can only be circumvented by jumping across that boundary. The only real decisions you can make are which tools to use for a particular job.
For most single page apps, create-react-app occupies an abstraction level "sweet spot". Webpack is too low level and changes too quickly.
Conceptual complexity is of enormous importance to the usability of a tool. I build APIs for a living and have often needed to push back vociferously over things that would make code terser, but the underlying mechanisms harder to understand.
That said, I actually think codegens are often the right tool for the job - it removes a lot of boilerplate (at least from the developer needing to write it) but doesn't obfuscate underlying mechanisms - those are free for examination as needed.
Of course, the devil's in the details - if the codegen'ed stuff is pure spaghetti that defeats this benefit.
The worst, worst sin of all are frameworks that insert "magic" functionality. For example: name a thing in a special way and stuff will automagically happen to it? I can't think of a worse, more opaque way to design a system than rote memorization of incantation that reveal nothing about what's actually happening.
The less you know about how the internals work, the less you'll be able to intuit about what you can and can't change. For many people who just want to make "an app" this doesn't matter, but it also means that a lot of quick start setups optimize for particular approaches that are built on top of particular sub-sets of how apps are built. So people leave the experience knowing more about how a particular component library than they do about the language or the requirements of mobile, or whatever.
Or, to put it another way: increased complexity also increases the difficulty of investigation and modification. Making it easier to get an app 'somewhere' can make it harder for someone to understand what the app does to get where it's going.
In particular, I believe that this effect is strongly present in the Cult of Text Processing - there's a large group of programmers who believe that Text Must Be The Answer because it's just so easy to write `ls | grep` - never mind that each UNIX text-processing tool actually has its own bespoke input and output formats (it's not actually plain text), and so anything nontrivial quickly becomes a fragile mess riddled with edge-cases and liberal use of sed/awk. What's even more interesting is that because of the perceived ease of immediate understanding, even those that have deep experience with this paradigm (and should understand how inefficient it actually is) still defend it.
Although, I don't think that powerful tools necessarily have to have a high barrier to entry. For instance, maybe you could teach new programmers in Racket without type annotations, then introduce typed Racket as a way to allow them to much more easily learn static typing than adopting a whole new language? Such an approach might have made Rust easier to learn - just disable the borrow checker to learn an easier Rust, and then re-enable it gradually (starting with the easiest parts of your code and then moving to the more complex bits) to ease into what is usually the hardest bit for new Rust users.
Tool- and language-developers should focus on making things that are both easy to pick up (Python) and scale well (Common Lisp/Rust).
That's actually not quite it. What's so fantastic about the textual interface in Unix is that it is the same packaging for both use and reuse.
This is highly unusual, usually packaging that is optimised for use is unsuitable for reuse (doesn't compose well) and packaging that is good for reuse is unsuitable for direct use (cumbersome/inconvenient).
Using text to fill both roles comes with a ton of compromises, as you rightly point out. It's not really great at either function, but sorta/kinda gets by at both. But even with those compromises, pulling off the feat of having the same packaging for use and reuse is just incredibly powerful.
There are other ways of achieving the same result, for example Naked Objects bridges the gap by the programmer only providing the reuse packaging (an OO API) and the tooling then automatically generating direct-use packaging (a GUI).
Other ways of bridging the gap that can learn from one or both of these approaches clearly seem possible.
That's the reason CLI tools are so powerful, and the reason why json and yaml aren't able to replace them. It's also the reason why human-friendly CLI syntax like Cisco IOS is better than programatic interfaces like the default syntax in Juniper JUNOS.
That might not be the UNIX environment's true strength, but it's the only one that any of its advocates discuss. I've seen hundreds of people defend the paradigm, and you're the first one who's mentioned "packaging for both use and reuse" - everyone else talks about "text as the universal interface" and "simple, composable commands".
Moreover, I don't think that this feature is unique to UNIX. In particular, Emacs Lisp functions can both be called from other elisp code and directly (and ergonomically) executed by the user (with plenty of features to enrich interactive execution) - and these functions can actually pass typed data between them, unlike shell commands.
This appears to be the same "packaging for use and reuse" that you mention - unless I'm misunderstanding what you're saying, which is very possible because I'm reading through the (exceptionally interesting) PDF that you kindly linked, and I don't understand what it's getting at (although it seems profound).
> Moreover, I don't think that this feature is unique to UNIX.
It's not. It's not common though, and certainly Emacs Lisp code doesn't work at the OS level, it is trapped inside Emacs.
ls | grep
I think Cult is a little harsh but it is handy to simply chain stuff together to quickly get something done. Along with the nominal concept of it's all files you can get an awful lot done in a shell with minimal effort.
Anything non trivial should get the full awk and sed treatment. The sort of system that has the GNU etc toolset available normally has python and perl available out of the box and probably php and a few more too - tools for the job. I also have something called pwsh that I dabble with - handy for fettling with VMware via Power CLI.
I mean this kindly, as a person who struggles to infer implied details in a lot of circumstances: I think the quoted code was intended as shorthand, e.g.
ls ... | grep ...
This article doesn't give me any idea where I would start. At all.
I wish it did. I've looked around for quick and dirty ways to try to build the app I want to build. They never seem to do what I want them to do, the "in minutes" part fails to materialize for an outsider without a strong coding background, etc.
I think there are some wonderful tools out there and it's always good to lower the barrier to entry so people with other strengths can do their thing, but I read ideas like this and think of a book I saw written by a professional clothing maker who was decrying the shortcomings of off-the-rack clothes and the punchline was to the effect of "Why would you wear that dreck? Life is so much better when you can easily make custom pants in minutes -- like I can because of my many years in the industry!"
I didn't buy the book. My mom sews beautifully. I know something about making clothes and, no, you aren't going to replace off-the-rack clothes with teaching the whole world how to make custom clothes "in minutes" because that's so much better and easier.
But then again, I am not sure this article -- and presented technology -- is aimed at you. IMO it's more aimed at jaded programmers who are sick of hand-rolling the ever-almost-the-same 99% identical code for each project. Hopefully such tools can give them a less stressful time.
For a programming beginner who would like to build something you'd be much better off looking at something like Airtable.
You can also use your own hex codes to change colors to exactly what you want. You can add custom CSS snippets safely without digging around in the code.
If you are a serious coder, you can access the code and edit. I do everything but that last because I know some HTML and CSS (and UX etc) but I don't have the programming experience to figure out how to go into the guts of the code.
I spent hours and hours learning my way around the blogspot interface. Yes, anyone can just click a template and swap out background photos or whatever but if you don't already have prior experience with their backend and some basic design knowledge and UX knowledge, good luck making it do what you want while looking good and yadda.
I spent some time thinking I could sell my skills as a blogspot expert but there doesn't seem to be a market for it. People with money and ambition and so forth don't use blogspot. People who use it don't pay for help with it. They do it themselves.
So I have some idea of how much background knowledge someone needs to have to "do X in minutes" though I'm not a serious coder. I'm the computer geek in some circles I hang in though I would never identify that way on HN, just like I don't generally try to tell HN that I'm some mathy person.
I am often the "mathy" person in other settings. Just not here.
Anyway, thanks to anyone who suggested some entry level options for me.
In my case, I always have to do video tutorials to get started with a new stack. I use Academind ($20 a month) since their courses are comprehensive and still manage to split topics into shorter videos. When I get confused, I can usually find a good refresher on what I'm having trouble with. They have a course on Svelte specifically and 101 guides to all the technologies involved.
Obsession indeed. Everyone wants to be a master in five minutes. There’s this funny sort of paradox that arose out of the advent of digital technology where, because everything is nearly instantaneous, more people theoretically have more leisure time to plug 10+ years into mastering some hobby, but simultaneously, the instantaneousness and constant rush of digital distractions has lowered the tolerance for temporal investment (i.e. patience) in general, nullifying what would otherwise be a gain in leisure and expertise (e.g. masterclass, whose entire business model is predicated on the ridiculous premise that to be as successful as the stars only requires taking one course of their best tips and tricks and not, idk, thousands of hours of dedicated effort)
In my personal experience, I’ve found that most of the shortcuts aren’t actual shortcuts. Everything I know in the realm of computing I’ve taught myself, and, I have to say, I didn’t really progress until about 8 years in I finally buckled down and decided to read actual comp sci papers and really dwell on them and understand them, and by god use a pen and paper when necessary, rather than spend my time coding yet another example todo app from a tutorial on a website somewhere.
The fact that many resources around computing are free is both a blessing and a curse. It’s great because it allows people to learn on their own but bad since the crap always bubbles to the top.
However unlike music, there are new tools being made constantly because the practice of programming feeds the same skills one needs to make tooling.
If musicians had 10,000 instruments to choose from, each with some subtle gotcha that will only make itself known once you get in deep… then maybe they’d want instruments to be easy to play too.
A good comparison is songwriting. Lots of artists like songs that are easy to play. Piano pieces that are complicated get put down for later, unless they are classical master pieces. Guitar songs that require too fast a rhythm don’t get as much play time in anyone’s jam session either.
You can play an instrument knowing just to pluck a single note. But it's a lot more fun to play if you know a ton of different skills: you can say so much more.
I think the same holds true for coding. You can learn more skills all the time, all of which broaden the realm of what you can create when you sit down at a keyboard again (aka the playing the instrument part).
Apologies if I strained that analogy too much.
Likewise, the programming side of my work is generally pretty trivial (as is the case for probably 99% of most programming that happens in the world). It's the domain knowledge that makes things difficult/interesting/challenging.
Still, every time, two weeks later when writing your real app, you'll inevitably hit that nasty reactive-router-fluxcapacitor-synchronization dead end inherent limitation (or bug) in the framework, which is world famous and has had an open issue on github for 2 years, where the only workaround is to do things in a much worse way instead, inflicting more pain than the benefit given by the framework.
What I'm trying to say is that when choosing a framework, i don't want to see a hello world as example. I want to know how well it will scale for future development.
Those two parts demand the most seamless and direct expression, and continuous feedback. It’s not quick, it’s deliberate and diligent. That’s what I value and aspire to.
Let's say we needs some forms. Nothing to fancy. Consider 2 options: React+JS+Redox+formLib+... and Elm.
It just some banal forms, I agree. But having to come back to it may months/years later I much rather see back the Elm situation.
Typing helps a lot here. Small scope project too.
Now it seems this "build in minutes" uses JS and PHP. Sorry, but both are terrible choices for long term maintainability.
To the instrument analogy it's like Beethoven's 5th. Almost anyone can play the beginning on the piano with a few minutes of fooling around (dun dun dun da....). But to actually play the entire thing well will take years of practice because it's the other parts that are hard to get right and must be correct to work.
Having code and actual application data allows people without programming experience to build data types and simple to average functions and debug errors in the business logic, whereas with classic code they can't get pass the parser to get their poorly written syntax understood by the compiler.
Developers tend to think that writing simple code makes application development easy, but actually learning the syntax and runtime model of classic imperative code is usually the hardest part to newcomers.
The functional-reactive execution of the spreadsheet together with the intermixing of data and code provides a simple mental model of instant evaluation and exploration, similar to the benefits a REPL provides to a seasoned developer, minus the syntax errors and deep nested structures.
Notebook-style development environments like observablehq.org are almost there (specially those with a spreadsheet-like semantics), though it still keeps too harsh a separation between the code environment and the "runtime values" environment - i.e. its cells are "too large" when compared to spreadsheet cells.
Programmers have powerful interactive shells and debug environments, yet most courses center the teaching and communication of how a program works around the concepts in the finished product (a working program), more than how you arrive piecewise to the full solution by iterating small parts of the concepts in the domain problem and finding the correct parts of code to handle them.
That's an entirely orthogonal concern to what the article is about.
I agree that obsessing over the "zero to proficiency" time the way we do nowadays is very much counterproductive, for the reasons you mentioned. But you also want to be quick for a different reason - to make the tool better for the already-proficient user.
Rich also talked a lot about essential vs. accidental complexity. I don't know about you, but myself, the more I code, the more I feel 90%+ of my time spent on coding, and even a good chunk of the design/architecting time, is accidental complexity. This is not just a matter of bad APIs and overcomplicated design - the whole process of programming just takes too fucking long. The languages we use are not expressive enough, not succinct enough to capture our solutions. The tooling we use is not powerful enough to allow for an efficient exploration of the solution space.
So the other day I was writing some glue between two incompatible systems. I had my data structures well designed, I know how all the operations mapped. I would be able to write you a precise description of everything in an hour. It still took me more than a week to code it up. All the classes, functions, modules, files, syntax issues, gluing different types of error handlers, baah. Midway, I figured I made a mistake in the design. I knew how to correct it in 30 seconds. It would take a single sentence to explain the problem and the solution. It still took me an hour to implement the fix, because I had to change type signatures, move some files around, and update half a dozen places because it turns out you can't just automatically make bulk modifications in languages that aren't Java or C#. And don't get me started on how much time it takes to figure out the structure of a subsystem in a legacy code base...
Point being, even if you know your language and problem space inside out, even if you have decades of coding behind you, day-to-day coding still takes way more work than it should.
To me, existing tooling feels conceptually too low-level. Writing feels too low-level. One may counter that typing is mechanical, programming happens in the head - that's true, but at least to me, typing (and especially editing) still has enough overhead that I feel my brain slowing down. The feedback loop is too slow.
What I'd currently love to have is code editing environment operating on high-level semantic concepts. One keychord to select a function and display all its callers and callees, in a graph. One keychord to select a parameter and display a diagram of how it flows through code. One key to start inserting a class. One key for adding, deleting or editing anything that isn't a name or comment. References, files, folder structures handled automatically. Etc. Because if testing a single design variation will take me 10 minutes instead of half a day, then I might be able to test a bunch of them instead of committing to first one that feels reasonable.
I'd love to see better tooling that automates the crap and lets us focus on the actual business logic and value add.
> serialization, deserializating
I shudder when I even see these words. In the past two years, they've been the bane of my existence! A significant chunk of my coding time was wasted on countless little XML and JSON serializers/deserializers, associated error handlers, error messages, type recasting, etc. This is 100% because of bad tooling. I'd consider automatic generators for these, but they're external things that don't integrate well - which comes with more devops and maintenance hassle downstream than the time they save. If I were doing Lisp at work, I could at least macro my way out of this pain, but alas.
And the worst thing is, these things aren't just "brain-off" time wasters. In recent months I've noticed I'm getting slowly but surely burned out by this. I can see myself slowing down halfway to finishing a feature or a bugfix, out of sheer mental exhaustion from dealing with bullshit.
But beyond the data transformation glue code they're talking about, there remains the problem of boilerplate and glue code required by the programming languages and build tooling being not ergonomic enough to deal with concepts we have in mind directly.
How free from most of those things my days were.
Just pure declarative logic. I have A and B, what is the shortest path to get to C?
But eventually I got tired of that too and back to what you describe.
But if anything, accidental complexity has got worse. Go back 30 years and a useful command-line tool could reasonably be coded in a single .c file, compiled in a single command, then run.
Now: full-stack web apps are a lot more complex than command line tools. But, with contemporary tooling, the accidental complexity has scaled at least linearly, probably worse. Just setting up a front end dev environment is a lesson in complexity theory. And then there's manually crafting the UI-to-service messaging, k8s deployment templates, build pipeline, and all the other tasks that have nothing directly to do with the actual functional requirements.
I don't know what the answer is. Per other posts in the thread, I don't think it comes from conflating "0 to expert in 12 hours!" with "productive tools for skilled and experienced users". Low/no code fits into the former category (and maybe has a place, I don't have an opinion there). I don't see much addressing the latter space.
FWIW, because I've been out of web dev for a while and may need to get back into it, I came across this site today:
I followed their example ts+preact+esbuild setup and was very pleasantly surprised by the ergonomics.
I was expecting way worse.
I lately started getting very sick of web dev (which I practice since 2009; way too long). This in turn made me scared for my future income but that's a different story. :D
...I completely agree that trivial shit takes way too long to create or update. Just today I complained on ElixirForum (not to the core team members of Phoenix, just in general) that nowhere in web dev do we have stuff like "make controller.param.add" (which will not just modify the controller but everything that depends on it) or "make controller.param.change_type" (which would generate / edit boilerplate for validation) or "make template.root.change_css_kit" (ha-ha, that one will only happen when AGI is invented!).
I want a program that can modify programs, doing the text editing for me, structurally, not just regexes or even a bit semantic-more-like grouping of text (even that's not good enough). I won't reach for LISP even though I am fairly sure it being homoiconic will make this much easier, because no LISP runtime of any dialect offers transparent parallelism a la Erlang/Elixir or the compile-time guarantees of Rust. But I do sometimes wish all languages were homoiconic regardless. :(
Maybe I'll just gather some money and then just work on tooling that can do the above-described tasks.
I won't fall into the trap of thinking that detailed UML diagrams can lead to 100% correct code generation (although I am tempted to this day!). But there has to be a better way than us wrangling characters on the screen manually all the time.
And it's not even about typing. I enjoy typing.
It's about the menial nature of many tasks. They just... kill you. They slowly drain all your creativity and dreams about the future and desire to change things for the better around you. One day you catch yourself just wishing the work week passed by quicker.
We have to do something! But yeah, we're all slaves to the wage. I wish more of us were like @codinghorror; be rich enough to just one day ping a few buddies and say "hey guys, I am bored -- let's make a forum system" and boom, some years later you have Discourse that's being used more and more everywhere each day.
I wish all of us could as casually work on stuff we love as Jeff Atwood did.
While this is a tortured analogy (as a musician, I want no feedback until I'm done). I believe that wanting tools that optimize for the long-term, coupled with needing early feedback is precisely why many use certain technologies for demos, then build in other technologies.
The faster the demo can be built the better. The earlier you get feedback on the UI the better. The earlier you show a demo, the sooner you find out what the user really needs as compared to what you've been told (and the sooner the user finds out what they don't need, despite what they thought).
After you’ve spent years learning to sight read, you can play almost anything right away if you have the sheet music, even if you’ve never heard it before.
Or after you’ve spent years learning to play by ear, you can play any tune you know from memory, or jam along to almost anything.
This may be addressed in the talk but my immediate reaction is that a truly mastercrafted tool should be both. I tend to agree that where you have to make choices lean towards long term (thats what I personally prefer at least). I think I've sometimes romanticized that attitude a little bit though and reveled in complexity for the sake of complexity.
Ideally you're building stuff thats easy to learn but takes a lifetime to master (because of depth of the field, hopefully not because of the unnecessary complexity of the tool.)
It is preferred, stylistically, to avoid redundancy in your writing style these days.
C++ :: Saxaphone Wix :: Recorder; or something
Excerpts from https://houghtonhorns.com/why-is-the-french-horn-so-hard-to-...
The French horn is widely considered to be the most difficult brass instrument to play.
The modern-day double French horn is actually a combination of two horns (F, Bb) that share a common mouthpipe and bell.
Because the partials (available notes in the harmonic series) are so close together in the third octave, the horn’s most comfortable range, it is fairly easy to miss or “crack” a note. Conversely, the partials that occur in the trumpet’s most comfortable range are comparatively more spread out, allowing for a bit better accuracy and more control.
Another reason for the horn being difficult to play lies in the fact that it has the widest range of all the brass instruments: nearly as high as a trumpet and almost as low as a tuba. Additionally, the horn mouthpiece is small and deep, requiring fine muscle control and embouchure development. The mouthpipe is long and slender, creating more resistance for the player to overcome.
Because the horn faces backwards–as opposed to the other wind instruments–the horn player must work extra hard to balance and blend with the other members of the wind instrument family.
And that's okay! It doesn't need to have replaced the entire Web Developer career field, it can just be a cool UI prototyping tool. But I might suggest to the author to reduce the scope of their claims a touch, as it would engender more positive discussion.
From the developer perspective, I would not call this production ready also
I'm familiar with backend stacks but can't write a lick of CSS. This tool helped me build some small webapps.
I am in no way associated with them. Just a happy user.
To be more specific, he has the "Source" and "Detail" elements, but theres no apparent way of what piece of data is being synced across them or how theyre connected. Therefore, if I wanted to change any of that, I'd be completely lost. Did anyone else understand how the data actually flows across these pieces?
As someone who builds apps for a living, the 90% of the time is spent on the "last minute" customization and fighting the stack. This is why I pick widely used stacks. They might not be better but I have higher chances of finding someone else who had a similar issue.
Also I'd never use something that hides what is pushing/pulling from the server let alone configure the database structure for me. That would be really fun as I already spend 1/2 my time debugging what went wrong and finding it. Working with a black box is not going to help in any of that.
There is a reason why people steer to React/Redux. The world is not a Todo list app, and most of the time you need some creative work and you need something agnostic that can be programmed. Coupled with GraphQl, you can have a nice separation between your front and back ends and test them appropriately.
I am currently on a project where the initial specs worked with Adobe Captivate. Then the spec exploded and we are making tortured attempts to make it still work with Captivate.
I'm guessing it goes into a database somewhere. But I'm not sure how, what the database's schema is, or how easy it would be to interact with it from an external program.
You can't just magically disappear the complexity that is inherent to building actual applications. Synchronizing data based on unique IDs isn't special. At best this is an interesting prototyping tool and at worst this is a huge red flag for your understanding of actual web development.
Of course there is no source code, but we get to bear witness to the great development habits of this author: 105 changed files in his repo.
Pony up some source code and actual details and then we can talk. Until then, as far as I'm concerned, you just demonstrated ready-made components that are talking to firebase or whatever.
Are you implying they are a sub-par developer because they haven't committed changes to 105 touched files? That doesn't seem like a great metric to judge someone by.
It's amazing how much work you can skip when you treat the front-end of your app as a pretty interface for your database. I think a lot devs were inspired to go down this road by Meteor.js back in 2012 when it was released .
I think a tool like this is the future of web development: create the interface and boom, you're app is already working. That kind of instant validation of your work is addictive.
The problems arise when you want to change how data is processed behind the scenes before displaying it or after the user edits it. Or how it's connected to other users' data. But I think these issues can be solved either with reactive hooks or some of the innovations coming out of the GraphQL space.
I think you can get pretty far with a system like this:
* User accounts
* Automatic data syncing
* Deployment & hosting
* Form submissions
And these features, if done well, are all that 90% of businesses need to create value for their customers and become profitable.
I'm really excited about this space. My email is in my profile if anyone wants to talk about it further.
Also how generic is your ID-based sync mechanism? Can you attach it to any react component and sync whatever it has in useState hooks? Or is there magic going on in the prebuilt components that you demoed?
But the title is not wrong, a month consists of weeks, days and minutes :)
Obviously the business logic differs for every different business, and i expect that would be harder to do.
What I would like to see more of is “no backend” type solutions that allow you to just write front ends that leverage existing auth, databases, etc
eg. Sia, Gun, Dfinity, etc
I did the opposite of that, since I see the data structures are the "real" thing and the layout of the web pages as merely froth on the top.
My Frambozen framework is all backend, in that you define your database schema, and then it builds parts or all of the front end (the web pages) for you. (It's written in Python and uses the MongoDB database).
So for example, you might define a table like this:
name = StrField()
description = TextAreaField(monospaced=True)
aNumber = IntField(minValue=0, maxValue=100)
minSpeed = FloatField(title="Minimum Speed, mph", minValue=0.0)
maxSpeed = FloatField(title="Maximim Speed, mph", minValue=0.0)
favouriteDrink = ChoiceField(choices=DRINK_CHOICES,
fruitsLiked = MultiChoiceField(choices=FRUIT_CHOICES,
desc="tick all fruits this person likes")
tickyBox = BoolField()
aDate = DateField()
lastSaved = DateTimeField(desc="when this foo was last saved",
aDateTime = DateTimeField(title="A Date and Time")
anything = ObjectField(desc="can contain anything",
favouriteBook = FK(models.Book, allowNull=True, showNull=True)
How do you handle users and permissions?
There are also predefined web pages for logging in and out, and listing users. A real aspp might want ot customise the pages: https://github.com/cabalamat/frambozenapp/blob/master/app/lo...
It isn't pseudocode, it's Python source code.
> On the one hand, you have a FK field and, on the other, a TextAreaField with monospaced set to True. Is this a description of a table or a view...?
TextAreaField and StrField both define a string field in the database. The only difference between them is how they would appear rendered in HTML.
In the code snippet I included, MonDoc is a Python class that encodes the schema for a MongoDB table (MongoDB calls them collections). But MonDoc is actually a subclass of another class, FormDoc, that encodes data for an HTML form.
Using FormDoc, you can define the fields of your form, render it into HTML, validate results, etc.
The reason I merged forms and table schemas into one concept was I've used so many systems that define forms, and so many systems that define tables and they're all very similar, and I don't like having to do cut-and-paste to transform a form definition into an almost-the-same table definition. I find it tedious and error prone.
Does this reduce flexibility? It does a bit, by tying together forms and tables. But I think any rapid prototyping system is going to trade flexibility for speed of programming.
From what is shown in the video, I think the biggest limitation is that this approach would only work if the data model is stored in a document store. Each new "itemId" just becomes a property in a big JSON file and the framework knows what to update and how to update it because the "schema" is just controlled by the shape of the component tree and the type of component. That probably works for some use cases, but it's not something that scales IMO.
Check out https://github.com/lowdefy/lowdefy
There are some other low-code tools that have similar premises and offer things like ETL tools. We evaluated one called Retool https://retool.com and it seemed pretty cool, but because it's a per-user pricing model, the costs can be pretty substantial when you have a lot of people using the tool.
I'm a co-founder of the project and we started this because there was no open source project that made it easy to build highly custom admin panels and internal tools.
We created Lowdefy (co-founder here) to built web apps fast and it is really working well for us and our customers. We’ve already rolled out a few enterprise level apps in record time and the platform really scales well as apps evolve and get really complicated. Even developing apps as a team is a breeze since you are working with yaml / json which is easy to code review, copy, paste, find and replace.
Still, I believe something like this is a good future for internal apps.
- batch editing: what if you don't want your edits to save immediately, but instead as a group?
- item creation and joins: what if some fields create items that have ids that other fields require for update or their own creation?
- discarding edits: what if you want to throw away your changes?
- front-end auth: how do you verify that a field is editable before creating a text box for it?
- front-end validation: how do you make custom field validators?
- mid-edit derivative values: if you change something without yet saving it, will the other parts of the ui using that value also show updates?
Solving all these issues has been a tough project. I started off wanting to be able to just pass a rowId, tablename, and columnname, but pretending things are that easy only works for very, very flat Databases. (no joins)
A TODO list is one thing, but this isn't going to replace Mattermost or Jira tomorrow.
If I did it with a Rails template such as JumpStart I’d also have a tonne of extra features such as user authentication, payments, styling etc. out of the bag
Is it well supported,
who provides it,
are there similar templates that don’t work as well and why?
There are a few other Rails template frameworks but I think this is the most popular. It basically has a lot of the boilerplate stuff that you need to do for setting up a SaaS product. Of course because it’s rails a lot of the stuff is supplied in gems
a) I’ve been working o a similar thing…
b) Look at this other more mature project that solves the same problem…
There’s nothing wrong with a modern take on an old problem, but a naive take on an old problem that doesn’t either learn from issues with past attempts or offer anything novel…
This is a hard problem; How do you scale with easy quick prototyping and robustness for production quality.
Projects like unreal that solve this well are few and far between, and usually marked for “version 5” or “version 7”, where they’ve gotten past the early stumbling blocks of bad decisions and leaning too heavily towards no-code and complexity.
This is a cute side project; maybe it has something novel to offer (I don’t see it, but perhaps), but it’s very naive, and it’s … a fair way off from something anyone else probably has a use for.
Emacs is one of them. Linux is one of them. The web browser is another. VSCode and most IDEs are another. Rails. Flash. React. The C programming language. Of course, many unsuccessful ones too which I don't care to name...
My point is that it's good to have competition in this space. Who knows at what point the world will be ready for another higher level of coding? Even if this system fails, how many failures does this author need to accumulate before they discover something that is good?
To the author: I applaud your efforts. One question though - how can we try it out?
EDIT: I can also mention Arc, PG's custom Lisp dialect for building web applications including this very site.
It's not perfect, but ERP systems have everything that modern apps do
#2 role based authorizations
#3 Data entry forms
#4 Pages to show information from data
How well does this one fit to that benchmark?
#6 Can it generate pdf and excel reports
#7 Does it support scheduled jobs/tasks
#8 Can you choose to execute logic in the backend ( this does not seem to be the case for retool etc which only support frontend js )
#9 Can I extend with my own js, css and backend libraries
#10 Is it horizontally scalable and stateless
#11 Drag and drop ui builder that is not hard-coded to a single css framework and that generates code that can be modified.
I have not yet found any low-code framework that fits into these benchmarks
1) frontend app building (responsive)
2) backend logic builder with automation and BPM
3) pdf gen
4) add your own js, build your own controls
Disclaimer - I work at DronHQ
His blog is very interesting. Great ideas but the realized products are very similar to the competition...
This looks really cool. I like the idea behind the Source/Dataset/Detail components. I wonder how they work in practice. My first attempt at a component based rendering system (with render cbs and such) felt super clunky as soon as things got a tad complex.
But programming is about edge cases and thus, many, many rules how things should behave in every imaginable scenario.
I still haven't found tools that match those for SPA or PWA (React or other), and it seems that this is almost what the author is trying to go for.
Shameless plug. We also built a platform - Lowdefy - to develop web apps in minutes / days by only writing yaml or JSON. So far we find that it really empowers any developer to develop a web app (Especially backend / data dev who not feel like learning CSS / react / webpack etc)
Check it out https://github.com/lowdefy/lowdefy
Plumbing UI, Forms, API and db is pretty much the same for a lot of MVPs and anything that can get you to a faster prototype is welcome. The difference between what the author shows and Blitz is that the latter is similar to Rails in the sense that it scales to a proper 'Production App' rather than a quick prototype.
This is a classic web log. What blogs really should be about.
And it's a _beautiful_ site. Really. It might just be a netlify theme or whatever, but I'm really enjoying reading it.
The huge amount of possibilities in software development will usually beat the tool and eventually what helped you get a fast start, ends up dragging you behind.
1-The way we store data can be completely different from the way we present it to user
2-In only a tiny fraction of apps each user can only see their own data
3-When load (data volume/request per second, etc) increases, we often need fine control over the entire product
4-Change management can be tricky, especially when if changes shape of data store
For all these reasons, I don't expect these extreme rapid tools to gain huge success. More modest claims, like retool's (A great internal data administration tool) are more realistic.
Eventually, I think that extremely flexible and extremely rapid tools will emerge, but my expectation is that they need great vision, great execution, and when trade-offs need to be made, it's better to err on the side of flexibility rather than super fast demos.
It is hard to put into words how pleasing it is see a balance struck between code and data and how constructing the right abstraction can make solving a specific set of problems incredibly simple through the right language of expression.
I love when I solve a problem and the domain language offers me the expressiveness to solve it in a single line - even if the concept is complex, or that line fires off a hundred perfectly calibrated decisions under the covers - it tells me the universe, my problem domain, and my tools are in alignment.
I'm not sure if I am supposed to be insulted by that comment or not.
(My feature set does not include storing on a server. It purposefully only stores on local storage. It also does not allow rearranging the lists or items - which again was a design decision. It does allow you to delete lists which Alexander's app doesn't.)
The harder subjects seem like the design of complex schemas and algorithms, complex UIs, scaling, and systems-level integration.
Perhaps the easy/edge pieces will fall to automation, leaving the middle and low-level work to engineers and designers.
Many would consider that a condemnation, and probably a well deserved one too.
But I mean it in a positive sense: the democratization of development, the way DTP democratized printed expression (back when that was a thing).
Also hopefully means programmers can spend their time on more interesting and value-adding effort rather than having to take the time to simply put a button on the screen.
Of course the dream of rapid development goes back to FORTRAN.
Like HyperCard, back in the day.
Big 'if' right there.
I can see 'solved' problems being increasingly automated away (how many times do we need to write basic auth systems?), but in order to automate the entire pipeline you would need:
- a specification language so detailed that it's basically a programming language
- assumptions so strong they're liable to be subtly wrong
ML can help, but we've all seen codex... we aren't there yet.
In my experience, "easy applications" are already something you can just go buy cheap, or even download for free - other than for the learning experience, there's no point in coding one.