I think #eventsourcing is a bit of a misnomer resulting in much noise and confusion. I've always used the terms "record" and "journal" and propose "record storing" (RS) instead.

While I understand the good intentions behind such reocurring statements, I am less careful and "politically" balanced: #fsharp is absolutely inherently better. The "needs" are irrelevant, objective properties are what matters in engineering. Just like precise power tools vs manual mediaval tools.

Functional programming and its idioms are the most fitting and sensible interpretation/realization of #eventsourcing. Fold multiple composable values of types provided by the layered model, alongside the use-case specific version, apply model logic, store a new record. "Aggregates" are a mistake.

Why would people use other programming languages for frontend dev when #purescript is just right there? #functionalprogramming

I think I understood the popularity of "modern" as a term. It embodies the implicit and unconcious understanding that most of the (visible online) software industry is a web of ad-hoc, anti-fundamental knowledge, hype-driven, half-assed ideas which break easily. Then its on to the next "modern".

My 5c about this, as always somewhat heretical. "Bounded context" is vague and not really interesting/useful. Vertical slice architecture is not an architecture, but a principle *within* an architecture. In particular, in the Onion architecture (my default). #DDD 🔽

Only if you are making a fat client and the back-end is merely a thin layer between it and the DB and other infra.

Maybe thou pure just followeth m, returneth to sanity of m.

Why Blog If Nobody Reads It? “You write because you think, because you observe, because you need to put it somewhere.” https://andysblog.uk/why-blog-if-nobody-reads-it/

Planning to write a blog post "Using row types for handling events raised by Web Components". #purescript

I wrote about using GADTs in a design for #eventsourcing API in a #haskell back-end. Somewhat related to the recent post by @mattoflambda.bsky.social systema10.org/posts/making...

Working on refining my #eventsourcing design/template for #haskell applications. Using GADTs we can turn on or off optimistic concurrency check using "global" journal versions. Depending on the on/off setting, the "concurrent change detected" outcome becomes impossible and need not be handled.

Streams per entity are fundamentally in conflict with the basic essence of #eventsourcing. The essence being that we can compute *anything* by folding all records. Counter-example: find all customers in a system where each customer has a dedicated journal/stream by customer ID.

I made a demo about working with different error types and the Result type in F#. #fsharp gist.github.com/Savelenko/23...

Is the cabal 'data-files' machinery useful for static files needed by a Haskell Web application, for example CSS, JS and similar? What are best practices for "packaging" together the latter and the build product of cabal? A build system on top of cabal? #haskell

Beyond basic programs, HM-like type systems can be quite mysterious and awesome. The definitions and types of the #purescript functions below look strange at the first sight. I wonder how IWSAMs will fare when ported to #fsharp.

Just uploaded a new release of the `foldl` package. This release has a bunch of new instance and utilities added by one very helpful outside contributor (Topsii): hackage.haskell.org/package/fold...

We are looking for Haskell developers for Scrive as well :) EU based dev - Remote. careers.scrive.com/jobs/5365423...

Some heated discussions below. I am working with something similar right now. In 2013 I made an in-house message broker at work with my own algorithm for historical + real time event stream generation. We are still using it now. 🔽

I am planning to write about my ES approach (which is quite contrarian compared to common wisdom) on my blog systema10.org #eventsourcing

Another suspicious property of aggregates is that they (I think) collapse the application and model layers of the application. If an aggregate is essentially the scope/boundary of everything which is allowed to happen (consistently) within a use-case, then it means that the model layer 🔽

I am following the Lit tutorial. It is striking how the combination of reactice properties, declarative event listeners and the properties object inside of the web component class are essentially like a Halogen component! #purescript

I studied Web components for the first time and succeeded in using Shoelace with PureScript Halogen. Somehow working with "raw" HTML seems too low-level now, a step forward. #purescript #shoelace

My perspective, much more focused: at its core, #EventSourcing is a storage mechanism where the application persists records about observations or conclusions and computes various values by folding them from past records, interpreting the sequence of records in different ways.