[remus]

Yeah, I often wonder what threshold people use when they say they picked up a language in x hours/days/weeks. I guess it's largely a matter of opinion, but like you I consider a working understanding of the standard library, popular packages in the ecosystem etc. to be beginner level stuff, and for me it takes at least a few months to start getting a grasp on these things (especially in something like go which has a pretty big standard library).

[bborud]

As you point out there's a lot to cover. There's the language, the libraries, and the tooling. Then there's learning how different people use the language. The stylistic elements, how to play to the strengths of the language, how to deal with the shortcomings etc. All that takes time because you have to gain some experience with all of this. Even the things you figure out aren't very good.

The reason it took me a long time to learn Java is because when I started learning Java there was a certain way to architect Java systems. And to be frank, the way Java was done in the 90s was horrible. Lots of complex boilerplate, lots of structure and none of it seemed to pay off. And on top of that, most people still didn't understand OO all that well so you'd get layer violations and strong coupling all over the place. Making code really hard to maintain. (I used to ask people to read the first part of the GOF book, and forget about the rest of the book. Because at that point, the introduction contained the best explanation of OO we had found. It is probably still worth reading. Though the rest of the book led to a lot of silly dogmatism where some people suddenly behaved as if the patterns were the only allowable design strategies)

Then came the 00s with people adopting huge frameworks that in themselves took a lot of time to learn and, again, didn't produce the results we wanted. Worse yet, applications became hostages to these frameworks. Ever been faced with a few hundred thousand lines of code trapped inside a Spring-dictated architecture. That's really, really expensive to do something about.

It took a really long time to figure out a good way to do software in Java. It also took a very long time to re-train Java developers whenever we got a new hire. To teach them anything from "microdesign" (how you express things in Java) to how you design, plan and architect stuff without ending up with a lot of

[diarrhea]

Do you think you’re doing Java correctly now?

Do you have reason to believe you won’t be looking back in 10 years’ time, realising you’ve been doing it wrong in 2024 still?

[bborud]

I don't think it is about doing it "correctly". I don't think there is a "correct". There's stuff that works and then there's stuff that is a waste of time. For many years, most Java practitioners wasted time doing things that don't actually work.

It is about finding a practice that works better than the other ways that you have been exposed to and then try to figure out if you can write it down and explain it in a way that makes other people more productive and more capable of producing quality. Of course, that requires you to be exposed to a lot of practices and having the ability to figure out if they work. Not all programmers have that ability.

Some people find plateaus that are better than other plateaus. If you teach other people what you do then sometimes people think of that as the way to do it until someone else improves on it. Or someone finds an entirely new direction to go in that is perhaps even better.

> Do you have reason to believe you won’t be looking back in 10 years’ time, realising you’ve been doing it wrong in 2024 still?

A lot of the thinking that went into how we did Java evolved slowly over a couple of decades and we eventually started seeing people come around to our point of view. We just started a bit earlier than most. And it wasn't just informed by how we did Java. A lot of ideas came from how we did things in other languages as well.

Things like avoiding large frameworks that lock you in and dictate design choices, embedding servers rather than loading the application into the server (which never actually worked), or even making self-contained applications that have no external dependencies, were, to varying degrees, controversial at different points in history. Even the idea of treating servers like cattle rather than pets was controversial at some point.

Some of the things we spent a lot of time thinking about I don't see wide spread awareness of. Like designing for evolvability which is very, very different from over-engineering. Those bits are still hard to explain - and especially when people have short attention spans. But they are just as important today as they were 15 years ago. (I'm still terrible at explaining how we design for evolvability)

(I stopped doing Java around 2016. But most of the practices we developed live on in how we do Go. I think the reason switching to Go was so easy and happened so fast was that Go was very compatible with what we tried to do in Java)