check JSpecify (https://jspecify.dev) - it's the standardised null annotation package for Java. Intellij understands the annotations so you generally get decent null-checking across your codebase.

Even better, apply at the package level via `package-info.java` (unfortunately sub-packages need to be individually marked as well)

  @NullMarked
  package com.foo;

  import org.jspecify.annotations.NullMarked;

Yes - best decision we made.

Running a new startup now and choose modern Java (JDK 21+) with Spring Boot and it's been fantastic. Have previously built startups using both Haskell and Python/Django in the past. Ignore the folks talking about it not being cool, heavy, boring or whatever - modern Java is just super nice and quick to work with.

Some positives we noted,

- "good-enough" integrated type system & language features, e.g. immutable records, type inference, generics, sum and product types with exhaustive pattern matching, lambdas, streams (along with the new stream-gatherers). We feel the gain isn't enough to switch to Kotlin anymore.

- Fantastic tooling, from IDEs, build systems, cloud integrations, remote debugging, settings configuration etc.

- Massive ecosystem - there are libraries for everything, and all major vendors, including cloud providers and most startups, have a Java SDK

- Spring Boot is a great framework, especially for API backends coming from Django - setting up things likes OAuth and OIDC was super easy. Spring AI is developing rapidly, for instance it got MCP support within a week or two of it being released

- Verbosity can be tamed with annotations processors, and Lombok if you desire (we do but understand some don't like it). JSpecify helps with null-checking.

- Performance is great, you just don't have to think about it at a startup scale, and Loom / Virtual Threads makes it even easier to build performant web services without the mental overhead of building `async` systems

I could go on, and like all things there are of course negatives, but we took the plunge and have been really happy with it.

That's my feeling. For me the only missing feature is WASM compilation. It's a shame that GraalVM native compilation is not targeting it.

Technical Editor: Brian Goetz - you have my attention...

It has been awesome working with him.

There are few things as intimidating as having the Java language architect review your book on Java (haha). It's a much, much better book thanks to his involvement.

Manning let me conduct an interview with Brian a few years ago for my book with them. Here is the transcript: https://freecontent.manning.com/interview-with-brian-goetz/

He was very generous with his time and there are some good insights there for aspiring developers, as well as some info about the evolution of Java which may be relevant to the more data-oriented features that have been added in recent times.

After reading Brian's post[1] on data oriented programming years ago, I look forward for more on the subject using Java.

[1]: https://www.infoq.com/articles/data-oriented-programming-jav...

For people who're not aware: "Brian Goetz is a Java Language Architect at Oracle." (from the linked page.)

And a great technical writer. His Java Concurrency book was a Bible back in the day (idk if still relevant).

While I'm normally not a fan of appeal to authority, knowing this is what moves this from "will try to remember to check this out when I wake tomorrow" (it's 23:04 here) to "will definitely check out tomorrow".

Also it being from Manning helps. It's difficult to find good books today, so easy to self publish or get reeled in by some paper mill that banks on people wanting to have a book on their resume. So have to have something to filter out signal in the noise.

Cool to see this here, using Litestar for a new project having selected and used Django/DRF company-wide in the past. I find it provides a modern "batteries-included" stack for Python, not quite as comprehensive as Django, but also not as minimal as Flask or FastAPI. For me, the advantages over Django include typing, async-first, websocket-support, along with integrations with existing projects (including Pydantic, SQLAlchemy, Jinja, OpenAPI). The higher bus-factor and release cadence was also a factor in choosing it over FastAPI.

Currently using with the following,

- [SAQ](https://saq-py.readthedocs.io/en/latest/) for background workers

- [Nginx Unit](https://unit.nginx.org/) for deployment

- [Orval](https://orval.dev/) to generate FE definitions based on the API spec.

For non-API/SPA use-cases, there are Jinja and HTMX integrations. The docs (https://docs.litestar.dev/latest/) are solid - not quite Django-tier but that's the gold standard, however the reference example is too complex imo (https://github.com/litestar-org/litestar-fullstack).

https://github.com/litestar-org/awesome-litestar has a list of useful extensions - highly recommend trying it out if you are starting a new Python web project.

That's a very interesting stack, thanks for sharing!

Have been a big Django user over the past 10 years at my startups, but we decided to do all new projects in Litestar going forwards - typing, async, and a better REST API story made it the preferred choice for us.

+1 for django-configurations, it's been invaluable for us in helping to keep settings managable as we build / test / deploy across multiple environments and modes

For Django users, see https://www.django-unicorn.com/ - which is pretty much a port of LiveWire.

I have used Livewire in the past and am building stuff in Unicorn these days.

Unicorn is well on its way to being really good. It is easy to use and integrates with Django well.

That's amazing!

Yes, Blazor server-side is similar to LiveView, there is also LiveWire for the Laravel / PHP community (from the alpine.js creator) and Django Unicorn for the Django / Python side.

Unsure on the Rails / Ruby side, maybe stimulus-reflex, but there is also Hotwire as well ofc.

There is also Django Unicorn (https://www.django-unicorn.com/docs/), which is an implementation of LiveView for Django.

Firefox has had HW-accelerated video playback under Wayland for a few months now. Along with per-monitor mixed-/high-dpi support it is by far the best browser on Linux atm.

With NVIDIA gpu support?

Yes.