In my experience, Java has a lot fewer breaking changes with upgrades compared to other languages. Compared to Python or even PHP and Java looks slow, steady, and predictable.
I'm somewhat confused by your statements, so perhaps I don't understand.
Function/objects that allow changing their behavior by passing different objects into them, based on some interface, is called dependency injection. Some subset of behavior is determined by this passed behavior. E.g. To keep a logger class from having to understand how to write logs, you could create a WriteTo interface and various implementations like WriteToDatabase, WriteToFile, WriteToStdout, WriteToNull.
When you create this example logger, you'll need to make a choice of what object to pass when you write the code. e.g. new Logger(new WriteToDatabase(config)) But maybe you don't want to make that decision yet -- you want to let a config file decide which writer(s) to create. The pattern to pick between dependencies at runtime is called a factory. In this case, you might make a WriterFactory to pick the right writer, or perhaps a LoggerFactory to hide the creation of both Writer and Factory objects.
So, a factory is only really a facade to hide the runtime switching of how an object is created.
Also, the term dependency injection often gets confused with what you see in various Java / C# / and various frameworks in other languages -- those usually use what's called a "DI Container" or "IoC Container". These manage and facilitate how dependency injection happens within the project, often with various annotations (e.g.@Autowired). These containers are powerful, but sometimes complicated.
However, you can absolutely still do DI without DI containers, and I think advocating for not using DI generally (and related patterns like factories) is rather misguided.
There is a version mismatch. lemmy.world is having trouble upgrading, which I believe also causes federation between instances to fail between these versions.
They have a thread about it here
I've found pair programming to be fantastic, but only when used rarely in certain situations.
If you've got a good rapport with a teammate and a legacy project has landed in your lap neither of you understand, I've found pair programming to be the fastest way to figure out how it works. As you work together, you'll both understand different parts of it better and be able to quickly figure out what's going on. I guess this is probably less pair-programming and more like collaborative dissection of code though.
I've also used it to help onboard people on a project fairly quickly. This is more tricky and much less comfortable to do, so I do my best to stay in tune with what they need from me, and tends to be me coding for a bit and them following along and asking questions. Eventually, they want to start writing some code, and a day or so of switching back and forth is as far as I've usually taken that. I think it's useful to break down barriers when working with (especially new) people, to make mistakes in front of them, and build good rapport.
I've not used it much beyond those situations, but I'd definitely use it in these ways again.
I've watched so much good code written professionally die because of the whims of leadership in the past.
I'd like to be added to c/pico8 as well.
I'd be happy to help with c/java
Which they could have done a much better job with.
It was basically just hosted SVN if I remember right, and they never added git support when it became the de facto version control system.