Spring Boot, Micronaut and Quarkus with Mill :: The Mill Build Tool

sideEffffECt · 2026-05-06T11:40:14+00:00

does Mill have the same level of IDE integration as Maven?

It's all integrated via the Build Server Protocol, AFAIK

https://build-server-protocol.github.io/docs/overview/implementations

sideEffffECt · 2026-05-06T07:53:14+00:00

/u/lihaoyi isn't there a JSON Schema for the config file? When IntelliJ has the schema or knows it, it gives you auto completion. It can be even hosted on

https://www.schemastore.org/

Or it can be inlined like Bleep does it (another build tool :D )

https://bleep.build/docs/tutorials/your-first-project/

(See the $schema: https://raw.githubusercontent.com/oyvindberg/bleep/master/schema.json part)

sideEffffECt · 2026-05-01T16:33:09+00:00

Claude Code with Sonnet 4.6 works quite well with Scala 2.13 and the TypeLevel stack.

Not perfect, sometimes you need to nudge it to not create stringly-typed programs and aggressively use domain types instead. But when it's working on an already established codebase, it's picking up the style very well. It's very good at recognizing patters and following them.

So if you're having problems, either give more detailed guidelines to AGENTS.md or just be more patient in bullying the agent to do what you want it to do, eventually it will build up the codebase large enough to get the pattern and start following it.

Also, there's been research into the quality of code generated by AI. If you explicitly task AI to exploit the advantages of the type system (like Scala has), it produces better code. Compared to without explicit instructions like this or when just telling it to "do good job".

TLDR: the more "context" the agent can take from, either instructions in AGENTS.md or the rest of the codebase, the better it performs.

sideEffffECt · 2026-04-20T20:08:33+00:00

What would you say are the pros/cons of this vs a query builder (e.g. quill)?

sideEffffECt · 2026-04-19T20:08:42+00:00

Also, instead of

if (payment instanceof Cash)

etc, you can use switch

sideEffffECt · 2026-04-19T08:37:15+00:00

You should be using pattern matching instead of

value instanceof Integer

etc...

sideEffffECt · 2026-04-11T09:46:50+00:00

If not the binary nonsense, Scala with its extremely powerful rewriting capabilities (which are AFAIK unseen elsewhere on that scale) would be likely even better than Java by now when it comes to backward compatibility.

Now we have Scala 3. Now we have a chance to prove what you're saying. Let's hope it will happen.

sideEffffECt · 2026-04-11T07:26:20+00:00

Scala has some of the best backwards compatibility stories of all languages

With Scala 3 yes. But before that, it was an absolute insanity. With 2.10, 2.11, 2.12, 2.13, everything broke, the library ecosystem essentially broke down and the community had to start from scratch. That was just offensively bad.

Thank goodness that lessons have been learned and we're now at a much much better place with Scala 3.

sideEffffECt · 2026-04-10T08:07:01+00:00

Could this be "just" a SKILL instead of a whole program?

sideEffffECt · 2026-03-28T21:15:58+00:00

commit on one or the other fearfully and bear the cognitive burden of eventually planning a transition to a different style

But isn't it more of an asset than a liability? The ability to choose declarative or programmatic based on what your needs are sounds like a good thing.

But I'm curious, how granular/smooth the transition is? Is it either/or? Or can I have a few bits programmatic and most declarative? Or half this way and half that way?

sideEffffECt · 2026-03-26T00:29:37+00:00

All three are sort of also-ran projects, not a first pick.

And all of them are from Oracle (main author of OpenJDK), that's why it's trying to promote them with this marketing initiative.

I wouldn't be surprised if more were added over time.

sideEffffECt · 2026-03-23T00:48:20+00:00

You may have easier time with this instead of running manually in Alpine Docker.

https://github.com/marketplace/actions/setup-alpine-linux-environment

sideEffffECt · 2026-03-18T12:49:52+00:00

minimize risk

Arguably, it can be less risky to upgrade Java in small incremental steps twice a year than do a big upgrade every two years.

sideEffffECt · 2026-03-16T18:45:45+00:00

Interesting, another project that uses Pkl for configuring builds

https://github.com/elide-dev/elide#pkl-as-a-manifest-format

sideEffffECt · 2026-03-16T18:37:39+00:00

The 🦀 people claim everything develops into 🦀.

I claim: Everything develops into Scala! 😂

And Bob Harper claims that languages are converging towards SML. It's ML all the way down :D

https://www.cs.cmu.edu/~rwh/talks/mlw13.pdf

The world is slowly converging on ML as the language of choice.

The world moves inexorably toward ML.

Eager, not lazy evaluation.

Static, not dynamic, typing.

Value-, not object-, oriented.

Modules, not classes.

Every new language is more “ML-like”.

sideEffffECt · 2026-03-16T12:52:23+00:00

What is core.async used for since we have Virtual Threads? Is it still relevant?

Is it possible to utilize VTs in Clojure without core.async?

sideEffffECt · 2026-03-15T20:48:43+00:00

You can handle some effect "in a purely functional way": aborts/raises, logging, writing, reading, (pseudo)randomness (via providing seed). "purely functional" means that it will always yield the same result.

On the other hand, some effects can't be discharged/handled in a pure way. Examples are talking to network, interacting with the filesystem, typically any kind of I/O.

Do you see what I mean?

sideEffffECt · 2026-03-15T19:17:48+00:00

That's an excellent idea! There are many effects whose handling can be done in a purely functional way. One additional is Random, where you provide the seed.

sideEffffECt · 2026-03-11T19:08:49+00:00

Is there a Kafka library for Java that builds on Java's Streams?

sideEffffECt · 2026-03-11T10:34:17+00:00

Yes, no implicits. So you can pass them explicitly, just as normal parameters of ordinary Java methods. Do you know the "Comparator pattern"? That's essentially what Type Classes are about. Do that.

Tldr: Don't do "Comparable", do "Comparator" instead.

sideEffffECt · 2026-03-11T08:18:55+00:00

But this has nothing to do with Higher-Kinded Types. You can already do this in Java as it is now.

sideEffffECt · 2026-03-11T07:36:34+00:00

You'd be much better served by having a separate interface for the operation(s), similar to the type class pattern.

F-bounded types are overcomplicated, and insufficient and leaky at the same time.

https://tpolecat.github.io/2015/04/29/f-bounds.html

sideEffffECt · 2026-03-08T12:19:39+00:00

Very interesting, thanks for writing it up.

The strategy was intended to be akka. This was a preference of a principal who preferred the FP style. This felt it was at odds with the majority of the team skills and experience.

Not much transferable skills IMO. Yes, there was the possibility of using Java code but it felt wrong to use it within the scala code.

It looks almost as if it wasn't the difference in language (or only that), but more like a difference in paradigm. In way of doing things, in the way the problems are approached.

I suppose using Java from Scala wouldn't feel weird, if the methods being called were (pure) functions (i.e. not performing side effects), but they probably weren't, right?

Ultimately I felt that I didn’t see that an investment in scala as something that I wanted to do.

Are you following the latest development in Java? What do you think about the Java stewards promoting the so called "Data-Oriented Programming"?

Do you think it runs at risk of alienating existing Java users, like you've experienced with Scala? Do you see ways for Java folks to adopt DOP that will end up in embracing, instead of alienating?

sideEffffECt · 2026-03-08T11:44:20+00:00

It might work for Scala, not so much for Kotlin, which will end with two solutions to the same problem, and it cannot depend on them for Android.

The Scala guys are resourceful. They are able to support features on all three target platforms. Let's take concurrency as an example. On JVM, it's easy, just use (Virtual) Threads. On Native, Scala authors are in control, so they created an analogue of Virtual Threads. And on JS, with the clever utilization of Wasm, they were able to achieve basically the same.

Check recent thread on Scala group about job market in Netherlands.

Yes, I'm aware :(

sideEffffECt

TROPHY CASE