I have about 2 YoE, and I’m sure this changes with more experience.

I often hear this idea online that programmers should follow “just-in-time” learning, meaning you should prefer to learn things you don’t know while on the job. ( The way some people talk about it, though, it sounds like you shouldn’t dare spend a single minute learning anything new outside of your 9-5. )

This seems generally reasonable advice, especially for simpler things that take a few hours like learning a specific language feature, library, or similar. But when I lean too much on this JIT learning, it feels possibly detrimental.

Many times I do something big and new to me, say, deciding how to approach auth, microservice architecture design, automated testing, containerization, etc., I end up making a big decision after a few hours or days of cursory reading on documentation and blogs, only to come to regret it some months later. At that point, maybe I’ll slow down, find a book on the subject, read it, and think, “Oh, darn, I wish I knew that N months ago.” It certainly feels like spending more time learning upfront could have avoided mistakes due to lack of knowledge. Though there’s no way to go back in time and know for sure.

I’m not asking about any area listed in particular. I feel like, for all of those, I’ve learned more in the time since, and would probably avoid some of my prior mistakes if I did it again. The question is more: How much do you subscribe to this idea of just-in-time learning? And if you do, how do you know when you’ve learned enough to be confident, or when you need to slow down and learn in more depth?

  • magic_lobster_party@kbin.run
    link
    fedilink
    arrow-up
    1
    ·
    9 months ago

    When you’re faced with a tough architectural decision, identify which option is easiest to change from. Part of the job is to make decisions with limited knowledge.

    The benefit of solutions that are easy to change is that if it turns out you made the wrong decision, you probably still have the chance to do some course correction.

    Programs are also dynamic. No decision should be final. Sooner or later you probably need to course correct the ship anyway when requirements change, and you will be grateful you chose the option that’s easy to change from.

    This principle is called ETC (Easy to Change) in the book Pragmatic Programmer, which is also the book that coined DRY (Don’t Repeat Yourself).