guice

I meant "singleton" in the sense of a single value for a type shared by anything that requires one, i.e. a Guice singleton ( https://github.com/google/guice/wiki/scopes#singleton ) not a value in global scope. Or maybe a single value by type with an annotation, the salient point is that there are values in a program that must be shared for correctness. Parameterless constructors prohibit you from using these (unless you have global variables).

Guice docs: “There are many advantages to using dependency injection, but doing so manually often leads to a large amount of boilerplate code to be written. Guice is a framework that makes it possible to write code that uses dependency injection without the hassle of writing much of that boilerplate code” This is a common misconception. Guice’s docs delineate between dependency injection as a pattern and Guice as a framework that supports that pattern. https://github.com/google/guice/wiki

> Dependency injection has always been such a bad name for the concept. It is just passing dependencys as arguments. No. Dependency Injection means using tooling to "inject" the dependency, instead of passing an explicit argument. https://github.com/google/guice > Think of Guice's `@Inject` as the new `new`. Like many architecutral design patterns, toy examples don't illustrate the concept well. It's used for doing things like switching a large service-based system from using external databases and remote services for production, to in-memory everything for testing.

Bob was a nice guy. We had an overlapping tenure at Google in the 2000s. He was one of the original authors of the Guice dependency injection framework: https://github.com/google/guice. When I was earning Java readability at Google, I was fortunate to have had him assigned as a reviewer. Having the review work so smoothly alleviated a lot of the imposter syndrome I felt at the time. I felt like a million bucks afterwards. The compassion and humility he brought to the table made a world of difference. His murder represents a huge loss; he left a very positive impression on me.

Bob created Guice [1] and was involved in a number of JSR specifications. Bob also lead the initial development of Androids core libraries before moving on to the payment industry. He was a well known figure in the Java world. RIP. [1] https://github.com/google/guice

Would Google Guice count? https://github.com/google/guice

Re: static factory methods - Those are called just once (so perf isn't really the point). With respect to non-perf reasons, Factories should also be non-static. Here's why: 1. Factories that are part of a dependency injection framework (Guice, Dagger, Spring) are actually "objects" that the DI framework is moving around. These DI frameworks already enforce object creation (see: https://github.com/google/guice/wiki/GettingStarted for example -- everything is an object). 2. public static factory classes have significant disadvantages (eg. depending on another factory class is a direct, "hardcoded" brittle dependency). Avoiding this is straightforward - create factory objects (aka Modules) and register it with the DI framework (the only public static "singleton" object) - when an object is needed, ask for it and the DI framework will give it

It's been already 4 months since JDK17 was released, but Guice (one of the most popular Java dependency injection frameworks) still didn't release required compatibility changes [1]. There looks to be zero contact with maintainers at Google. In the meantime Spring was ready for JDK17 in July (3 months before JDK17 GA) [2] For years I advocated to use Guice at my companies, as it's considerably less bloated than Spring. Now I'm starting to get some heat on this as it's clear that the support is just not there. Is this the right time to accept the defeat and start migrating back to Spring? [1] https://github.com/google/guice/issues/1536 [2] https://twitter.com/snicoll/status/1420652097373188100

> it specifically guards against inheritance/factory/DI hell by offering a unique type system Many people, including Google engineers (https://github.com/google/guice) see DI as useful tool, not hell. But nothing prevents you to write your java code without DI if you don't like it.

Indeed, Guice even recommends not to use (static) final fields. https://github.com/google/guice/wiki/Injections

Because of things like: https://github.com/google/guice 4k LOC of "lightweight" garbage for... variable lookups?

Thank you, and of course you may. The backend is written in Java(8) and it is built with the following (noteworthy) components : Netty[1] - Extremely fast and stable Java networking framework, serves static files and relays traffic (both tasks are custom implementations) Guice[2] - IoC container by Google, nice for keeping the code clean jOOQ[3] - I log some statistics in PostgreSQL (file size, content type, transfer time - but no filenames). If you're comfortable with SQL jOOQ is a real breeze to use. The backend is hosted on the cheapest VM option at Digital Ocean (Amsterdam region), (which seems to be holding up pretty well so far :). I do run PostgreSQL on another $5 VM, so the Station307 server only has to worry about serving static content and moving large chunks of bytes

> First: constructor calling is not readable because Java misses named parameters. It's fine when there are 2-3 dependencies, but not more. If you have more than 2-3 dependencies, it might be time to refactor things, as your class may be doing too many things. > Second: circular dependency is not possible. Circular dependencies are possible with constructor injection when using a DI framework (e.g., using a Provider in Guice [1], or the equivalent in Dagger). [1] https://github.com/google/guice/wiki/CyclicDependencies

The specific systems I'm thinking of were Google-internal, but there's a close public analogue with Guice & Dagger: https://github.com/google/guice https://github.com/square/dagger Imagine injecting Futures into your code. Now imagine injecting them, but having the Provider record a lot of metadata about who you were calling, how you were calling it, how long it took, whether an error occurred, letting an SRE turn off the call, etc.