tyrian VS effect

If you want to try TEA, but not Elm I reccomend Scala.js with Tyrian[1]. Scala.js is a wonderful, mature project and Tyrian gives you the elm architecture in a very pragmatic way.

[1]: https://tyrian.indigoengine.io/

Have you looked at Laminar and Tyrian? Especially Tyrian seems to be close to what you're looking for.

What I wrote is obviously based on my experience as backend and data engineer. I'm so happy to see an adoption on the Frontend side (with things like Tyrian or OutWatch) and would be even happier if there was a clean path to Android. Out of curiosity, what do you find appealing in Scala, compared to e.g. Kotlin?

Documentation can be found at https://indigoengine.io/ and https://tyrian.indigoengine.io/.

Yes, I have. It didn't work out. There are quite neat libs like Tyrian, but they lack any ecosystem and I struggled to integrate it with pure JS libs - yet our app has a lot of very common components/widgets that we're really hesitating to write ourselves.

Welcome to my new series about Effect. In this series, I want to discuss why I think Effect is one of the most pragmatic technology choices for most software companies. Before we start talking about the technology itself, we have to establish what all software companies seek. How do their needs change based on their size and the economic environment in which they operate?

The less uncommon are typed FP libraries like Effect or true-myth.

In this article, I want to talk about schedules in Effect and, for better understanding and fun, implement my own with Promises.

You should check out https://effect.website/

It might help you implement some of these ideas

nice post :)

I’m surprised there’s not been any mention of effect (http://effect.website/) yet, as it is kind of the next level up if you really want to model things like errors, dependencies and side effects in the type system, using functional concepts borrowed from more pure functional languages.

It would be a bit of a risk adopting this into a shared code base depending on your team and the kinds of devs you’re looking to hire, but it could be useful to some folk that feel like they want even more type safety.

7. As this is such new territory, a lot of the tooling we need doesn’t exist yet and we have to build it ourselves.

What is our answer to these? How will we win?

In short - good old software engineering.

Longer Answer:

- We’re making heavy use of [Effect](https://effect.website/), which allows us to gain as much control as you possibly can in such an undeterministic environment. Also, it will enable us to represent complex agentic workflows while keeping a deep level of observability.

And if you want more power at the type level, use effect/schema

https://github.com/effect-ts/effect/tree/main/packages/schem...

Any chance you could run this on the Effect codebase? Definitely an example of a project that can be hard to navigate due to its scope and gaps in documentation

https://github.com/Effect-TS/effect

If you have never heard of Effect, I suggest you take a look at the website: https://effect.website/

I think React would get better developer experience and performance if they adopt language coroutine feature to implement direct style algebraic effect. In fact the React Fiber system is already an implementation of algebraic effect.[1] However, it’s “suspending” a routine by raising an exception. Thus unwinding all the call stack, therefore, it needs to re-run that same routine on resume. This is the core reason why they have a performance issue and why they created the compiler to cache values on reruns.

JavaScript has language level coroutine features like async/await or yield/yield* and we have seen libraries using these features to implement direct style algebraic effect. For example Effect[2] and Effection[3]. You don’t need to memoize things if the language runtime can suspend and resume your functions instead of throwing exceptions and rerun them.

[1]: https://youtu.be/7GcrT0SBSnI

[2]: https://effect.website/

[3]: https://frontside.com/effection/