I worked on a research topic in grad school and learned about holes in files, and how data isn’t removed until the last fd is closed. I use that systems knowledge in my job weekly.

A tip. Kernel development can be lonely, share what you are working on and find others.

The quantity group has a trivial way to "hack" the metric. I can just sit there snapping photos of everything. I could just set up a camera to automatically snap photos all day and night. To be honest, if I'm not doing this at a stationary wall there's probably a good chance I get a good photo since even a tiny probability can be an expected result given enough samples.

But I think the real magic ingredient comes from the explanation

  > The group never worried about the quality of their work, so they spent time experimenting with lighting, composition, and such.

I do think the message is right though and I think this is the right strategy in any creative or primarily mental endeavor (including coding). The more the process depends on creativity the more time needs to be allocated to this type of exploration and freedom. I think in jobs like research that this should be the basis for how they are structured and effectively you should mostly remove evaluation metrics and embrace the fundamentally ad hoc nature. In things like coding I think you need more of a mix and the right mix depends highly on the actual objectives. But I wanted to make the above distinction because I think it is important if we're trying to figure out what those objectives are.

> Therefore, if you push yourself to the limit of your abilities to create the most clever code you can, you won't be able to debug it.

If only advocates of LLM-based code generation understood this lemma.

He said it with a very specific idea in mind, and like most of software engineering "laws", if you know enough to know when to apply it, you don't need the law.

Never too late to try stuff out of course, but very little beats structured higher ed education in relatively small classes (think there was only about 24 people in the robotics major?)_

> I still play music, but not full time, and with the comfort of supporting myself with a day job.

Some people say;

  Pursue your dream or you will regret it.

Other people say;

  Don't make your dream a job, because all it will
  be is a job and no longer special.

I say;

  Happiness is found in neither a dream chased nor a chosen
  profession.  It is instead a choice we make each day in
  what we do, in how we view same, and if we allow
  ourselves to possess it.

  What constitutes each day is immaterial.

I think it is common for a programmer to just start programming without coming up with any model, and just try to solve the problem by adding code on top of code.

There are also many programmers who go with their first “working” implementation, and never iterate.

These days, I think the pendulum has swung too far from thinking about the program, maybe mapping it out a bit on paper before writing code.

But an easy example is "just build the single player version" (of an application) can be worse than just eating your vegetables. It can be very difficult to tack-on multiplayer, as opposed to building for this up front.

Yes and no, depending on how dependent you become on that first iteration, you might drown an entire project or startup in technical debt.

You should only ever just jump in if:

A) it's a one off for some quick results or a demo or whatever

B) it's easy enough to throw away and nobody will try to ship it and make you maintain it

That said, having so much friction and analysis paralysis that you never ship is also no good.

"Just make it exist first. You can make it good later."

You're going to write the "stupid code" to get things out the door, get promoted and move on to another job, and then some future engineer has to come along and fix the mess you made.

But management and the rest of the org won't understand why those future engineers are having such a hard time, why there's so much tech debt, and why any substantial improvements require major rework and refactoring.

So the people writing the stupid code get promoted and look good, but the people who have to deal with the mess end up looking bad.

Depends on what you do. If you build a network protocol, you'd better architect it carefully before you start building upon it (and maybe others do, too).

The question is: "if I get this wrong, how much impact does it have?". Getting the API of a core service wrong will have a lot of impact, while writing a small mobile app won't affect anything other than itself.

But the thing is, if you think about that before you start iterating on your small app, then you've already taken an architectural decision :-).

Basicaly, do you have a good foundation to build from. With more experience, you can build a better foundation.

Prototypes (start ups) rarely have the luxury of "getting it right", their actual goal is "getting it out there FAST to capture the market (and have it working enough to keep the market)"

(Some - apologies but I'm not a game dev enough to be able to say what types this applies to) Game devs - they're more or less build it, ship it, and be done with it, players tend to be forgiving of most bugs, and they move on to the next shiny thing long before it's time to fix all the things.

Once the product has traction in the market, and you have paying customers, then it's time to deal with the load (scale up) and bugs, I recall reading somewhere that it's probably best to drop the start up team, they did their job (and are now free to move on to the next brilliant idea), and replace them with a scale up team, who will do the planning, architecting, and preparation for the long term life of the software.

I think that that approach would have worked for Facebook (for example) they had their PHP prototype that captured the market very quickly, and (IMO) they should have moved through to a scale up team (who could have used the original code as a facade, strangling it to replace it with something funky (Java/C++ would have been what was available at the time, but Go would be what I would suggest now)

> There’s a lot of “theatre” in planning, writing endless tickets and refining them for WEEKS before actually starting to write code, in a way that’s actively harmful for building software.

I'd love to have a "high paying job" where I am allowed to start prototyping and modelling the problem and then iteratively keep on improving it into fully functional solution.

I won't deny that the snowballing of improvements and functional completeness manifests as acceleration of "delivery speed" and as a code-producing experience is extremely enjoyable. Depth-first traversal into curiosity driven problem solving is a very pleasurable activity.

However, IME in real world, someone up the chain is going to ask "when will you deliver this". I have ever only once been in a privileged enough a position in a job to say "I am on it and I will finish it when I finish it... and it will be really cool"

Planning and task breakdown, as a developer, is pretty much like my insurance policy. Because when someone up the chain (all the way down to my direct manager) comes asking "How much progress you have made ?" I can say (OR "present the data" as it is called in a certain company ?) "as per the agreed plan, out of the N things, I have done k (< N) things so far. However at this (k+1)th thing I am slowing down or blocked because during planning that-other-thing never got uncovered and we have scope-creep/external-dependency/cattle-in-the-middle-of-the-road issue". At which point a certain type of person will also go all the way to push the blame to another colleague to make themselves appear better hence eligible for promotion.

I would highly encourage everyone to participate in the "planning theatre" and play your "role".

OR, if possible start something of your own and do it the way you always wanted to do it.

I'm curious who is in these kinds of jobs. Because I've never seen this in practice.

Put another way, refining tickets for weeks isn't the problem; the problem is when you do this without prototyping, chances are you aren't actually refining the tickets.

Planning stops when you take steps that cannot be reverted, and there IS value in delaying those steps as much as possible, because your project then becomes vulnerable to outside risk. Long planning is valuable because of this; it's just that many who advocate for long planning would just take a long time and not actually use that time for planning.

I once worked on a Perl script that had to send an email to "Harry". (Name changed to protect the innocent). I stored Harry's email address in a variable called "$HARRY".

Later on a second person (with a different name) wanted to get the emails as well. No problem, just turn the scalar into an array, "@HARRIES".

I thought it was very funny but nobody else did.