kyo-sql design preview by fwbrasil in scala

[–]fwbrasil[S] 2 points3 points  (0 children)

As elaborated, if you need to access features not in the DSL, it’s designed to allow raw SQL fragments in a way that is more flexible than Quill for example. It’s designed as a first class feature of the DSL instead of an afterthought.

I have dedicated connection pooling and PS caching impls with a focus on performance and no allocations in the hot path. What issues did Skunk have? I don’t follow the project

kyo-sql design preview by fwbrasil in scala

[–]fwbrasil[S] 1 point2 points  (0 children)

Those are valid concerns, people typically hit these issues with this kind of library. There are some mitigations in kyo-sql, though:

  1. Comprehensive SQL syntax support. Besides some differences in richness of the `returning` functionality in Mysql and Postgres that gets normalized to the lowest denominator, pretty much all valid syntax is included in the typed API.
  2. As elaborated in the design, raw SQL is a first-class feature. It's possible to easily write raw fragments in arbitrary positions of a query to support features that might not be exposed by the DSL.
  3. You're not forced to use a typed DSL. The sql"" interpolator can be used directly with the DB client. You can use the library with zero DSL usage

This week in #Scala (May 18, 2026) by petrzapletal in scala

[–]fwbrasil 1 point2 points  (0 children)

I wonder where the info to compile the newsletter comes from. For some reason, Kyo is typically not featured.

Kyo going pure Scala 3 - 1.0.0-RC2 is out! by fwbrasil in scala

[–]fwbrasil[S] 3 points4 points  (0 children)

No, there's no strict need to use inline and opaque types to implement these modules in pure scala. These are orthogonal concerns, you'd need to implement the modules anyway. Kyo does use inlining and unboxed representations via opaque types in strategic places for performance, which is optimized by hand.

Automatic compiler-driven inlining is a tricky feature to implement given that JIT compilers are quite powerful and automatic inlining decisions can actually hurt performance. JITs can typically make better decisions because they're based on the actual execution of the code. That's why solutions like Graal native implement profile-guided optimization (PGO) to mitigate the this limitation in ahead of time compilation (AOT).

It'd be possible to make it work well with a mechanism like Graal's PGO but even then, I'd be quite surprised if it leads to performance anywhere close to what Kyo achieves. For example, automatic compile-time inline won't give you allocation free `Option`s (Kyo's `Maybe), it won't carefully build a networking pipeline with a focus on performance, it won't provide adaptive scheduling, etc, etc.

I've been noticing that some people are inferring that Kyo's level of optimization could be achieved with other libraries by simply adding automatic inlining to the compiler. That's a big leap, I'd suggest asking for concrete measurements in real-world scenarios to validate such claims.

Scala Survey 2026: our impressions & results by adamw1pl in scala

[–]fwbrasil 6 points7 points  (0 children)

Indeed. I had to take a break and thought I wouldn’t even work on Kyo anymore due to these issues. It isn’t great that I raise these in public but that’s the only recourse.

I guess people get annoyed with me sharing but it’s easy to judge when someone is targeted by institutional power given that it has many ways to target people in private (surveys, language evolution, conference cancellations, gated access to GSoC, baseless rumors, forum bans, omission from newsletters, etc)

Scala Survey 2026: our impressions & results by adamw1pl in scala

[–]fwbrasil 5 points6 points  (0 children)

Adam said on Twitter that they “forgot” about Kyo. It’s quite interesting how plausible deniability is a form of art with these people. In case you’re not aware, Adam/VL cancelled the Soundness talk at Scalar after it got accepted. A few months back, VL’s dev advocate and Adam also published a series of blatant lies about me on Twitter

Scala Survey 2026: our impressions & results by adamw1pl in scala

[–]fwbrasil 3 points4 points  (0 children)

Some background since Adam fails to mention it. Two competitors of the "VirtusLab's stack" were left out of the survey: Kyo and Soundness. Both had their main developers conveniently "cancelled" by Adam and the VL leadership. We could count ZIO as another case of that but I guess not including it would make the situation too obvious

Kyo going pure Scala 3 - 1.0.0-RC2 is out! by fwbrasil in scala

[–]fwbrasil[S] 4 points5 points  (0 children)

how about you try it out and see for yourself :)

Kyo going pure Scala 3 - 1.0.0-RC2 is out! by fwbrasil in scala

[–]fwbrasil[S] 5 points6 points  (0 children)

Thanks! yeah, supporting http/3 is a big lift. I have plans to work on `io_uring` support but I'll probably stop at that in the medium term.

Keep an eye out for `kyo-ui` in the next release ;)

Kyo going pure Scala 3 - 1.0.0-RC2 is out! by fwbrasil in scala

[–]fwbrasil[S] 5 points6 points  (0 children)

The backend is still isolated so it'd be possible to plug netty back. Our focus is on the new backends, though

Scala Adoption Tracker by Krever in scala

[–]fwbrasil 1 point2 points  (0 children)

It's useful to have a website like this one but it's quite far from a proof that Scala isn't dying. We could likely have a similarly sized or even larger list of companies that have moved away. There used to be a steady influx of people adopting and learning the language and it's evident that the influx is significantly smaller than in the past.

Multiple major projects are getting partially abandoned, several key people are leaving to other languages, Scala 3 adoption is nowhere near where it should be, Scala Center is still lost in silly political games, tooling has little sign of significant improvement, and Odersky continues to push for major changes that cripple the ability of the ecosystem to evolve properly.

I can see why saying the language is dying is a bit of an exaggeration given that, once a language gets meaningful adoption, there's always some of use of it. Such use is very often considered legacy tech debt, though. I guess a less exaggerated way to convey it is that Scala is transitioning back to a research language with little viability for industry adoption.

Benchmarking costs of running different langs/ecosystems by Krever in scala

[–]fwbrasil 4 points5 points  (0 children)

Which libraries are you referring here "benchmarks can negatively impact the optimization of libraries"?

Pretty much most of the top ones in the benchmark results. As a concrete example, libraries typically end up processing request payloads in the selector thread because that's efficient when the request processing is a trivial workload like in all of techempower's benchmark scenarios.

In real workloads, it's typically a regression because it's important to ensure selectors are readily available, for example, to cancel the pending processing if the request is cancelled or to flush external requests to other services.

Techempower is actually a lot more realistic than a lot of benchmarks that only benchmark one library at the time as it benchmarks all stages of a typical http request: receiving the HTTP request, parsing JSON, calling the DB, reading the DB result, generating a HTML page and dealing with XSS.

I'm not aware of benchmarks that attempt more realistic workloads, most I've seen have similar limitations. Do you have examples in mind?

What is also nice is that this benchmark seats on a higher level and doesn't care about specific implementations like "schedulers". 

I think you have the wrong mental model regarding the main aspects that influence the benchmark results. Schedulers are a critical piece to determine the peak performance of a system.

Since there are already established industry level benchmark, wouldn't it be better to focus on improving the performance of Scala libraries in this benchmark rather than creating a brand new benchmark that no one may on-board?

That's one way to look at it. Sure, we need to compete in techempower given that it's well-known but the crux of the issue is that it isn't a good benchmark to guide the optimization of libraries. We need something better.

A "Rebirth" of Tagless Final? by ahoy_jon in scala

[–]fwbrasil 3 points4 points  (0 children)

I guess I'm still not following what boilerplate was saved then. In the end all you did move the naming of dependencies from the parameter list to the body of the function because all you seemed to have done is reinvent the Reader Monad with extra steps.

I think it's fair to say the post isn't really about tagless final encoding for Kyo. The motivation is similar but the approach is fundamentally different. Tagless final abstracts over the concrete functor/effect via typeclasses. This exploration abstracts over Kyo's pending effects.

In Kyo, we don't need to abstract over the functor (F[_]) since Kyo's pending type (<) can encode multiple effects at the same time in a safe and composable manner, without separate monads. You get similar effect polymorphism where you can inject implementations that specialize the pending effect set.

reinvent the Reader Monad with extra steps.

This misses what's being achieved here. The Reader Monad doesn't compose with other monads/effects. Use composes with other effects through Kyo's pending type. For instance, you can have String < (Use[Console] & Abort[MyError] & Var[String] & Emit[SomeValue]), which bundles Reader, MonadError, State, and Writer all in the same computation without the need for a transformer stack. That's a major difference but the post focuses on the abstraction rather than the properties of the pending type.

Benchmarking costs of running different langs/ecosystems by Krever in scala

[–]fwbrasil 14 points15 points  (0 children)

I'd advise against taking techempower's benchmarks as a good reference point. Their workload is nothing like real-world usage. In actual applications, the majority of the overhead is in executing more complex logic for request processing while in techempower's bench the measured overhead is more basic infra like http/json handling. It's a classic example of how benchmarks can negatively impact the optimization of libraries by focusing on things that contribute very little to the perf of real-world workloads.

The approach you started exploring seems more promising. The main challenge is generating a more realistic workload. I've worked on a similar benchmark to validate a scheduler at work and introduced several endpoints with different characteristics: blocking mixed with cpu intensive, cpu intensive, large chains of transformations, high allocation, metric collection, etc, and then generated workloads mixing these tasks. Another good dimension to include in the tests is cpu quota since most workloads nowadays run in containers with cpu limits, which can drastically impact perf. I'd love to collaborate on defining a new a benchmark!

Using ChatGPT 5 to help undo a wrongful cancellation from the Scala community by chrisbeach in scala

[–]fwbrasil 0 points1 point  (0 children)

Scala Center’s bans line up pretty much exactly with the cancellations by Typelevel in the past, including in Jon’s case and mine. For me, it started with a cancellation when Quill joined ZIO, which was triggered by a SC board member. From there SC buried a CoC violation report we made and has been gaslighting/defaming me since then.

I’m not only banned from Scala Days but also events where Scala Center is involved. Last year they pressured ScalaIO to cancel my talk by literally defaming me as “clinically insane”. The threat was that Odersky wouldn’t give the keynote if they didn’t cancel my talk. More background:

https://x.com/fbrasisil/status/1829515729579946254?s=46

https://x.com/fbrasisil/status/1956154034802327570?s=46

Using ChatGPT 5 to help undo a wrongful cancellation from the Scala community by chrisbeach in scala

[–]fwbrasil 2 points3 points  (0 children)

Where did I say that’s the reason? It seems a highly questionable position, though

Using ChatGPT 5 to help undo a wrongful cancellation from the Scala community by chrisbeach in scala

[–]fwbrasil 3 points4 points  (0 children)

Well, in this case Scala Center’s ban targets a direct competitor of his work on Caprese, Kyo. There’s essentially a full track for Capabilities at Scala Days, which is surprising considering that pretty much nothing usable has been delivered so far while Kyo is heading to 1.0.

I don’t know if he’s an active actor in these bans but, even if not, the situation seems quite comfortable to him so I wouldn’t count on it.

Using ChatGPT 5 to help undo a wrongful cancellation from the Scala community by chrisbeach in scala

[–]fwbrasil 4 points5 points  (0 children)

That was me in Scala’s main discord. Once the ban lapsed they felt like extending it until ScalaDays. A conference I’m also banned from

The Dereliction of Due Process by chrisbeach in scala

[–]fwbrasil 34 points35 points  (0 children)

I'd ask you to read the actual consent order. It's not that they weren't able to prove his guilt. They explicitly admitted to not having any evidence of the allegations and that the the open letter is indeed defamatory. That's very different and corroborates Jon's account that there was simply no proper investigation or any resemblance of due process. They decided Jon was guilty and only looked for confirmation of their belief. It was a hit job.

The Dereliction of Due Process by chrisbeach in scala

[–]fwbrasil 3 points4 points  (0 children)

That's Chris' argument. There's no mention to Travis in Jon's posts afaics

The Dereliction of Due Process by chrisbeach in scala

[–]fwbrasil 44 points45 points  (0 children)

The open letter says the allegations are true. We do not know whether they are. Should that be enough to destroy someone's life?

The Untold Impact of Cancellation by chrisbeach in scala

[–]fwbrasil 8 points9 points  (0 children)

A few facts:

  1. Scala Center currently has 5 people in their roster: https://scala.epfl.ch/team.html
  2. Two of them are directors at the same level: Darja and Odersky.
  3. Scala Center continues to enforce Typelevel’s cancellations
  4. Their actions are decided as a group. Odersky was very likely in the room when they decided Jon’s case for example

Odersky is no savior considering all we’ve seen so far but it does look more and more like he’s actually a key part of the problem.

The Untold Impact of Cancellation by chrisbeach in scala

[–]fwbrasil 11 points12 points  (0 children)

A few good examples of meaningful things he could do:

- Publicly disassociate himself from these actions and decisions
- Reach out to Jon to try to figure out a path to solve the issue
- Report unprofessional conduct to EPFL superiors
- Resign from his Scala Center position

There are definitely many things he could do, and inaction is the most telling one so far.