HN Theater @HNTheaterMonth

There's an excellent talk by Rich Hickey (I believe it's this one[1]) where he points out an obsession with how quick something is to understand immediately and be productive in—he gives the example of building websites in a single day, and contrasts it to musicians learning and mastering instruments over much longer periods of time.

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.

[1] https://www.youtube.com/watch?v=MCZ3YgeEUPg

⬐ _peeley

Another great Rich Hickey talk is Simple Made Easy, very similar message. So many of these auto-project tools are very easy to use, but in no way simple to understand and end up adding complexity in the long-term.

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!

⬐ 88913527

My actual experience with reporting the "something broke" in a large, popular OSS project was 18+ months until resolution. A crafty engineer thought it was a good idea to run their in-house optimization on third-party JS libraries to squeeze a few extra bytes out of the final bundle size (going above + beyond conventional methods like minification). Turns out that the overly aggressive optimization caused runtime exceptions, and they ended up cleaning up the feature.

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.

⬐ tshaddox

> 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'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.

⬐ stickfigure

I generally agree with your thesis (especially WRT this article) but create-react-app is a terrible example. I converted a fairly large handrolled webpack project to CRA, and it actually fixed a lot of broken things.

For most single page apps, create-react-app occupies an abstraction level "sweet spot". Webpack is too low level and changes too quickly.

⬐ jackTheMan

it was the same with GWT (google-web-toolkit) it looked nice and many jumped to the bandwagon. But when something didn't work as expected you had to know a lot about debugging javascript (the internal work of javascript) and guess about the generation logic from java and think backwards. After all, you had to know more (then simply js) for debugging! And of course if your boss wanted something custom..

⬐ potatolicious

This is a major beef I have with many modern frameworks - many confuse verbosity with simplicity or ease.

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.

⬐ skinkestek

I don't know what you do but I maintain 3 projects based on create-react-app and have done for 18 months. Together with a couple of senior guys and some younger devs (both guys and gals) I keep them updated, build new features, rewrite stuff to tsx (we got the projects handed down) and with one single exception I never even thought about the build system.

⬐ aeturnum

I don't think they were saying create-react-app is bad or unusually fragile. It's that there are problems in building increasingly complex 'quick start' setups with the goal of making them accessible to people with less experience.

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.

⬐ another-dave

I couldn't get my head around that coming back into frontend dev after a break from it — was on a project where we had some bug in the build output that seems like it'd be trivial to fix in a plain Grunt/Gulp set-up but was told "oh we can't fix that, because it's coming from within create-react-app & I don't know if we're ready to eject yet. Once you do, you can't go back"

⬐ Zababa

> 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!

It's also really really huge. Where I work, we mostly use ASP.NET with a few JavaScript libraries. A team made a new thing in React. The node_modules weight 276 Mb for a 2 Mb app. npm audit says that there are 11 vulnerabilities, but the package.json was updated 2 weeks ago (and this is with npm install, not npm ci). There are in total 1000 libraries. 165 of them are looking for funding, which means they could easily be the target of a malicious agent (take the repo, publish something new on npm obfuscated, extract credentials). I see the value of modern development tools, but this is just insanity, and going way too fast.

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.

⬐ chii

> I wonder how people deal with this.

they don't, and just stick their head in the sand. I know i do!

⬐ hackerfromthefu

Yes that's the rational assessment.

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.

⬐ chakkepolja

Yep. I was learning react and found that a router library took lot of time to install. Compared to svelte where packages are super lightweight compared to react and installed in a minute max.

⬐ Zababa

> React has changed their one true way

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.

⬐ fouric

This "obsession with how quick something is to understand immediately and be productive in" is a good concept to have around, and it's something that's been tickling the back of my mind for a while.

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).

⬐ gerdesj

It may not be for you but if you are going to take the piss, please at least give an example that does not generate a syntax error:

  ls | grep

grep needs input and something to tell it what to do with the input.

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.

⬐ eyelidlessness

> It may not be for you but if you are going to take the piss, please at least give an example that does not generate a syntax error

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 ...

⬐ gerdesj

I know but I think I touched a nerve 8)

⬐ eyelidlessness

Gross

⬐ fouric

That's exactly it. I've been running Linux as my desktop operating system for over a decade and know how to use grep - I just opted for shorthand (or may have underclocked some brain cells - I was in a hurry).

⬐ mpweiher

> Text Must Be The Answer because it's just so easy to write `ls | grep`

That's actually not quite it. What's so fantastic about the textual interface in Unix is that it is the same packaging[1] 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[2] 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.

[1] https://www.cs.cmu.edu/afs/cs.cmu.edu/project/vit/ftp/pdf/Pa...

[2] https://en.wikipedia.org/wiki/Naked_objects

⬐ starfallg

> That's actually not quite it. What's so fantastic about the textual interface in Unix is that it is the same packaging[1] for both use and reuse.

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.

⬐ fouric

> That's actually not quite it.

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).

⬐ mpweiher

"text as the universal interface" is the thing that enables "packaging for both use and reuse", so it's not surprising that this is what they refer to.

> 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.

⬐ janci

Powershell cmdlets return objects that are suitable for reuse and also have their textual representation suitable for (human) use. I think the concept is beautiful, but the execution is awful.

⬐ DoreenMichele

I don't code. I would love to learn and may still someday and there's an app I would like to build.

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.

⬐ nicoffeine

I am helping a few people getting started with web dev, and I have had good success using Svelte. It's not necessarily the best choice if you're trying to start a resume to get hired, but if you're trying to get comfortable with the foundations of all of the possibilities (javascript, html, css) it's a lot less intimidating. I think it will be a big player in the future, and you can make just about anything you want with it.

https://svelte.dev/tutorial/basics

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.

⬐ pdimitar

Yes, you are very correct. The "build X in minutes" definitely assumes strong background because you know what to look for. Without that you might as well give it blank stares for a year.

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.

⬐ kirso

Aren't various boilerplates created for this which already route all the necessary libraries and tools like analytics, stripe etc?

⬐ pdimitar

Sure, there are. They do almost nothing about having to modify the generated code afterwards though. They are just a start; you don't have a command like "modify this validation to be this or that".

⬐ DoreenMichele

I do blogspot blogs and the interface is brilliant in terms of letting anyone of any skill level interact with it. They have precoded templates you can just click on. They have the option to "customize" where you can click on different colors or whatever without knowing any coding.

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.

⬐ voidhorse

I wish Hickey wasn’t in the programming business and was just a full time philosopher. In a lot of ways his observations on social phenomena, his approach to abstract concepts, and his communication style in general is more interesting than clojure and datatomic (though these technologies are still great).

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.

⬐ MathYouF

Which papers or educational resources do you recommend?

⬐ true_religion

People are okay with how long it takes to master computer programming (or science). If they weren’t we wouldn’t have 4 year degrees for it.

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.

⬐ sva_

Wouldn't building a website be more equivalent to playing the instrument? Presuming one has learned how to build a website, like a musician learned to play an instrument.

⬐ dv_dt

Learning general website building technology is like learning to play an instrument, but being asked to build a given website is like being asked to give a performance. It might be a quick rendition or it might be a major performance on a stage (with one obviously being much more prep time than another).

⬐ sva_

Maybe a coder is more like an improvising Jazz musician. Would explain a few things.

⬐ hamburga

That's what the Rich Hickey talk is all about!

⬐ HomeDeLaPot

Also, do you know the song(s) already, and do you know how to play the particular instrument requested?

⬐ dhosek

That's a good aspect of the analogy. I can play pretty much anything with strings (not necessarily well, but I can play it), but being able to play a particular song on it is another thing.

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.

⬐ dcuthbertson

Yes! We could consider JavaScript, HTML, and CSS as the set of instruments. Then by creating the Conductor framework the author has not only "practiced his instruments", but shown proficiency and created a nice performance.

As for those who wish to use his framework, it's probably not enough to use it alone. It's mostly just another instrument that can be played solo, but to orchestrate some web apps, one will have to include the JavaScript, HTML, CSS and probably a few other "instruments".

Apologies if I strained that analogy too much.

⬐ andkon

Learning to play an instrument is usually about learning many many tiny discrete skills that build on one another and can be combined in creative ways to express what's most important and vital at that moment.

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).

⬐ Teknoman117

I don't understand why there are downvotes on this comment.

Learning more about and practicing in your field will make you more skilled at it, whether you're a FAANG software engineer, a plumber, metal worker, musician, etc.

⬐ Too

Yes. Almost every single app framework has a shiny hello-world-todo-app pitcher that takes 5 minutes to write.

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.

⬐ hardwaregeek

Except…are most apps that creative? Let’s face it, a lot of programming is boring variations of CRUD. Yes there’s creative code and I’m sure Rich Hickey does a lot of it, but there’s a lot of boring, banal code that we shouldn’t be real precious about.

⬐ cies

There's always challenges.

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.

⬐ iammisc

In my experience, 99% of every app is CRUD. Then there's the 1% that is your differentiation that takes six months to build.

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.

⬐ TillE

The vast, vast majority of playing an instrument well is about deep technical skill, not creativity. That's what we're discussing here.

⬐ dgb23

I make those. And yes, it’s 90% boring in terms of tech. The exciting part is to make something that my users like to use, that fits them like a glove. And polish. Polish is hard and endless, there is always a tension between pragmatism and perfectionism.

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.

⬐ yangikan

I guess what would be useful is a "Visual Basic for the web". Back in the day, one could bring up pretty large applications quite quickly using Visual Basic and Delphi.

⬐ discordance

Check out https://anvil.works. Feels like VB6 for the web, but all in Python.

⬐ wolpoli

We kind of do with ASP.NET Blazor. It still isn't as simple as the VB back in the 90s through.

⬐ TuringTest

What would be useful is an "Excel for web apps". The spreadsheet runtime model is much better adapted to the way non-developers think than what VB6-style visual programming provides.

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.

⬐ ilkan

That's some food for thought. My issue with programming courses is they ask you to memorize the commands then use them; most programming is about creating the logic then QA'ing with some data. Excel is data-first and becomes more like a game, trying different approaches with a clear picture of the end in mind. It's easier to persevere.

⬐ TuringTest

Quite true, and too often developers are not aware of how important data-first is for their own work in the exploratory part of programming.

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.

⬐ madflame991

I come back to this article every now and then http://www.loper-os.org/?p=861

⬐ TeMPOraL

> obsession with how quick something is to understand immediately and be productive in—he gives the example of building websites in a single day, and contrasts it to musicians learning and mastering instruments over much longer periods of time.

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.

</rant>

⬐ Karrot_Kream

Lol I ran into this just the other day. I've been trying to get a personal project finished before I head out on a trip in a few days, and due to lots of bad reasons (and I want to emphasize that these reasons are bad, not the language, partially because I made the choice while intoxicated) I chose Rust. The thing itself is just supposed to spawn a few other processes, check success statuses, and write some logs. I got caught choosing between accepting strings, PathBuf, Path, and AsRef<Path> for spawning subprocesses. I had to write my own error type, with `thiserror`'s help, in lieu of a stack trace to understand why my code was failing in portions. If I had done this in Python it would have taken a third of the time. Now obviously by choosing my types, ownership semantics, and data structures more carefully than Python's stdlib+runtime results in a much lower memory overhead and less CPU used, but I find myself constantly asking myself if it was really worth it (especially since I'm frustrated with my upcoming trip deadline). I'd love a world where I didn't need to make such a stark choice; where I could get the convenience of stack traces, errors, and fast iteration, without the performance hit that a heavily dynamic language like Python gives you.

</another rant>

⬐ spinningslate

not sure I agree with your 'wants' at the end, but I do want to frame the earlier paragraphs. I feel that pain too. Fred Brooks thought we'd largely have eliminated accidental complexity by now [0]. The "out of the tar pit" paper [1] tackles that and shows it's hard.

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.

[0] https://en.wikipedia.org/wiki/No_Silver_Bullet [1] https://github.com/papers-we-love/papers-we-love/raw/master/...

⬐ kitd

Just setting up a front end dev environment is a lesson in complexity theory

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:

https://modern-web.dev/

I followed their example ts+preact+esbuild setup and was very pleasantly surprised by the ergonomics.

I was expecting way worse.

⬐ pdimitar

> ...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.

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.

<long-sigh-ends-here>

⬐ bcrosby95

I think you could design a system like this if it were your goal at the outset. But it would go against a lot of layering practices which may or may not matter for a given project.

A while back I worked on a project that was as close to what you mention here as I've worked on. It was a website, desktop app, and API. The codebase was monolithic and glue code for the 3 separate parts, along with backend serialization, were automatically generated at compile time based upon interfaces that I defined by hand.

⬐ ryandrake

To add to this, for the solution that takes you 30 seconds to articulate and 1 hour to code, let me guess---About 5 minutes of that hour is writing the business logic that solves the problem, and 55 minutes are things like: 1. Boilerplate: Headers and includes, function and variable declarations, comment blocks in the right place, class this, interface that; 2. Reformatting: casts, serialization, deserializating, data marshaling, transforming from one data structure to another; and 3. Refactoring: adding an argument to function X requires manual upstream changes in all 25 places that call function X, making data Y an enum instead of a bool requires identical changes in 50 other files. Crap like this is pure brain-off typing that takes the vast majority of the time you spend "coding."

I'd love to see better tooling that automates the crap and lets us focus on the actual business logic and value add.

⬐ fifilura

This makes me smile and think back to the time I wrote business logic in pure SQL.

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.

⬐ TeMPOraL

You're exactly correct. Like reading my mind. You've itemized the exact things that take 90%+ of any code I write. I didn't immediately notice it - it became apparent only when I realized I'm writing almost the same, tiny, simple business logic for the third time, and it still takes way too long than it should.

> 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.

⬐ skydhash

Relevant article: https://www.oreilly.com/radar/thinking-about-glue/

⬐ TeMPOraL

I'm not sure if I agree fully with its conclusion. I hope we'll figure better ways to eliminate glue code, or at least reduce it in size. Part of the problem is, it might be trivial to describe a data transformation between systems A and B in words, or even on a diagram, but it's still hell of a lot of work to put this in code. Again, accidental complexity abounds.

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.

⬐ splistud

These are excellent points. But what if a musician is hired to compose a song that is to be played on a brand new instrument? Would the musician not want the instrument to be playable rudimentarily very quickly, so he can begin to demonstrate where he is going with the song, so as to get early feedback?

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).

⬐ iainmerrick

The musical instrument analogy can be taken the other way, though.

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.

⬐ f0e4c2f7

I'm going to watch that talk later it sounds interesting. Thanks for sharing.

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.)

⬐ PaulDavisThe1st

Ditto for both power- and hand-tools used for most craft.

⬐ suifbwish

More importantly there are dumb as shit C level people out there reading this that are going to think there is something wrong with their developers because they don’t make apps in a day/minutes/(fill in other dumb and obviously false timeframes for a production time allotment here)

⬐ NoGravitas

> "dumb as shit C level people"

It is preferred, stylistically, to avoid redundancy in your writing style these days.

⬐ suifbwish

Good catch

⬐ eof

Some instruments are made for beginners. I think the same correlations would be easy to find in software productivity.

C++ :: Saxaphone Wix :: Recorder; or something

⬐ zwieback

I know C++, played some sax in my youth and recorder as a child. If only I knew Wix, then I could connect the two dots in a 2D graph!

⬐ RcouF1uZ4gsC

> I think C++ is more like the French Horn

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.

⬐ shimonabi

I just learned that the right hand is placed INSIDE the bell of french horn. I've never noticed that before.

⬐ helgee

The French horn is a holy instrument. Because if you blow into the mouthpiece, only God knows what will come out of the other end.

⬐ bob229

Terrible analogy. Building a website is not the same as learning how to build a website(or an instrument)

⬐ hikerclimber1

everything is subjective. especially laws.

⬐ abetusk

Notice that the explosion of rap, hip-hop and punk were because the barrier to entry to music making through sampling and distribution was lowered. The 1980s and 1990s were replete with high profile artists that became famous by using the discarded drum machines and synthesizers of the time [0].

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 [1] [2]. It's not uncommon to see artists that are just one or two people, enabled by a professional grade studio on a PC.

[0] https://www.theverge.com/2017/4/3/15162488/roland-tr-808-mus...

[1] https://ucladatares.medium.com/visualizing-trends-and-patter...

[2] https://www.r-bloggers.com/2017/12/clustering-music-genres-w...

⬐ zarzavat

You could say the same for the piano. For most musical instruments, the first months or years of study are spent just trying to get a good sound out of the thing and to be able to play all of the pitches in its range. Then keyboard instruments came along and suddenly anybody could produce a sound with zero effort at all, just by pressing a key.

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.

⬐ dbattaglia

I’m not sure I understand the point. While the economical barrier to entry for producing music is lower with electronics and computers, it still requires time and dedication to be proficient in it. Most DAWs and synthesizers reward practice and dedication the same way a guitar or Clojure does.

⬐ ehutch79

These artists didn't get good overnight either. Samplers and drum machines are very much instruments that take time to learn how to use 'properly'

⬐ skrebbel

I disagree that this is a good analogy, because you're referring to a financial barrier to entry and the GP is talking about effort, not money.

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.

⬐ abetusk

Synthesizers provide a wide array of different types of instrument in one housing (brass, strings, pads) in addition to effects and sequencers. This means a synthesizer can supplant what would have classically been one or many different people in a band. The same goes for drum machines.

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.

⬐ teebs

As much as I love hip hop and electronica, and as difficult as it is to make excellent music in those genres, it really is very easy to make okay music. Have you ever used FL Studio (formerly known as FruityLoops)? I remember downloading it freshman year of high school and being able to make a catchy-but-derivative hip-hop beat in minutes. That's not enough to make a hit song, but I think luck is a bigger factor than effort for a lot of underground hits.

Today, it's still how a lot of hip-hop and electronica gets made: https://en.wikipedia.org/wiki/FL_Studio#Notable_users

⬐ filoleg

>As much as I love hip hop and electronica, and as difficult as it is to make excellent music in those genres, it really is very easy to make okay music.

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.

⬐ triska

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.

Is that really the case? Take for example Paid in Full by Eric B. & Rakim from 1987:

https://youtu.be/E7t8eoA_1jQ

To me personally, it does not sound any less mature or less complex than most of the hip hop we hear today. In fact, many subsequent productions seem like poor copycats, less complex versions of older songs that set a very high initial bar.

I find the Wikipedia description from https://en.wikipedia.org/wiki/Paid_in_Full_(album) quite telling:

"Rakim's rapping, which pioneered the use of internal rhymes in hip hop, set a higher standard of lyricism in the genre and served as a template for future rappers."

Yes, it served as a template. But was the new standard ever truly exceeded?

⬐ radicalbyte

The funny thing reading this post is that you can replace "music" with "software" and your point still holds.

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.

⬐ skrebbel

I'm an amateur electronic musician myself. You're not wrong, but I've found the gap between okay and good extremely hard to cross.

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.

⬐ kevinarcher

from 2013: https://www.infoq.com/presentations/design-composition-perfo...

⬐ vlaaad

Composition, not compilation

⬐ nanna

Drats. Apologies. Too late for me to fix :(

⬐ marzuqohanis

I think it's cool one

⬐ bherrmann7

I think Rich is an amazing presenter. He has clear and simple ideas, he has humor, his energy is directed to help the listener. He clearly enjoys helping others. He reminds me of Richard Feynman, in his earnestness.

I think work he has taken time to prepare, is worth thoughtful consideration.

I would say Clojure more than substantial returns of invested time. Not just the language itself, but also the wider approach to software composition, feature accretion vs backward compatibility, schema'd dynamic typing seem benefictial no matter what your development tools you use. Maybe check out the talks below and see if they don't enRich you as software engineer.

https://www.youtube.com/watch?v=ROor6_NGIWU The Language of the System

https://www.youtube.com/watch?v=MCZ3YgeEUPg Design, Composition, and Performance

https://www.youtube.com/watch?v=oyLBGkS5ICk Spec-ulation

https://www.youtube.com/watch?v=YR5WdGrpoug Maybe Not