3 ms·
> 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
by TeMPOraL 5y ago
> 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>
- ryandrake 5y agoTo 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.
- TeMPOraL 5y agoYou'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 5y agoRelevant article: https://www.oreilly.com/radar/thinking-about-glue/ https://www.oreilly.com/radar/thinking-about-glue/