I am writing this having just returned from Effect Days.
The two biggest learnings one takes away aren’t at all about Effect or even technical.
- There are no dumb questions.
- Nobody is advanced.
Though they relate to us all asking questions during the workshop where Maxwell Brown was nice enough to iterate “There are no dumb questions” and answer every question. Similarly Mirela quoted Michael Arnaldi “nobody is advanced in Effect” to reassure that yes we’re all learning here. Though I found both statements to profoundly apply to life.
Getting into Effect then. We’re all learning and exchanging knowledge what did we learn?
Firstly there was the Effect Workshop on Day 1 followed by Talks during the conference on Day 2 with Day 3 being a hack together community day. PS: We also tried to all play together agenst the Italian Chess Master at the same time him going rounds at each board. Well let’s just say we learned there too.
The Workshop. How to Effect.
The workshop was structured to start with an introductary morning covering how to write Effect today while you build up your application followed by an afternoon full of deep Effect code and guidance. That allowed everyone to catch up on how to Effect in the morning, while diving deep in the afternoon.
Though before attending the workshop Rafi mentioned to me that he learned effect by reading the docs front to back. That may sound counter-intuitive. Which docs are ever good enough and laid out so that you can read them like a book? Well effect.website/docs is.
And I felt it. I read through the Getting Started, Error Management, Resource Management and Requirement Management sections. You learn while reading! I could apply that directly when going through the workshop and when writing my applications.
The docs and workshop code as reference came in handy throughout. #I sincerely urge you to watch the recording, slides and do the exercise starting from the morning to afternoon.
Since the Workshop covers everything well I’ll spare you details and notes here. Though a summary of my doc reading notes on how to effect is available here
The Conference. Get inspired while learning
The following are the notes I took during each talk. I highly urge you to through talks matching your interests on the Effect Youtube Channel.
The notes are notes. The full talks will provide way more context. Though here they are in chronological order of the talks.
Building Effective Agents - Maxwell Brown
The talk focused on @effect/ai a package to interact with LLMS/AI leveraging the goodies of Effect.
AI being non-deterministic means in app design algorithms/statistics can help you reason. For example figuring out wether you’re AI system is a Monte-Carlo or Las Vegas experiment guides the controls your implementing. The statistics background will help you know what you’re doing and get certainty out with a cetain propability that you can directly calculate. Your applications therefore becomes les non-deterministic, they become propabalistic where you can get as close to deterministic as you wish (through repetition and careful modeling).
There are two kinds of Agentic Systems
- Agentic Workflows: execution is predetermined
- Agents : execution is self directed
What makes an LLM an Agentic System?
- You augmenting it. How?
- Tools e.g.
- Retrieval (Knowledge Base)
- Tools: Web search, accessing APIs, etc.
- Memory: Reference past conversations and context of the current exchange
Check @effect-ai to remove provider specific differences between the APIs and get insights, error handling, retries & more via Effect!
Effect Cluster - Tim Smart
The talk is focused on @effect/cluster.
- Effect cluster models businesses in “entities” to compose together. Business data can be modelled via Effect Schema.
- Cluster abstracts individual machines away allowing you to write truely parallelized TypeScript applications using Effect.
- Cluster leverages
@effect/rpcfor communication and networking. - Deployment is Kubernetges native with a ShardManager (conceptually similar to an operator, which in Effect Cluster manages the parallel workflows)
Effective Pragmatism - Attila Večerek
When writing software between fast, good, cheap you get to pick just two. The constraints forcing pick two are: Timeline, Scope, Resources, Regulations.
Over the journey of a business complexity increases as it progresses from startup to mega corporation.
- Startup: Validate “it works” - focuses on retention
- Scale-Up: Accelerate “grow” - Focus on growth
- Corporate: Optimize “profit”/efficiency - Focus on retention
- Enterprise: Scale “grow” - Focus on retention
- Mega-Corp: Diversify “different revenue streams” - Focus on Retention
Throughout these stages reliability, observability and testability are needed to certain extends. What does that practically mean?
Pragmatic Reliability is just reliable enough to
- be available for new users
- retain existing users by being there for them
- fulfill SLAs and regulations if applicable
Pragmatic Observability is seeing erros and performance bottlenecks
- being able to fix errors quickly as data is available
- being able to optimize performance quickly as degradation is visible & data helpful
- Effect-TS makes it easy and shows you what you need to see while allowing you to have a CONSISTENT format across observability data
Pragmatic Testability
- testability prevents functionality to regress, it ensures we keep functionality through out our changes
- makes sure you know your code works
- testing with effect is made easy due to great dependency injection
- Example: Effect allows you to reuse live logic in tests by easily injecting needed test dependencies like a local in memory KV that has the same API as the prod KV
How to grow? - Adoption
- Focus on people who are willing to adopt
- enable them, motivate & inspire them
- reduce friction for them
- listen to their blockers
- generally listen, build, educate
A community is a great lever. It’s an unfair advantage to have a great community.
Simplifying Forms with Effect - Jérémie Dayan
- Forms are hard with lots of validation logic to make sure we have a consistent format across forms and within the input data.
- Effect Schema is a data representation we already have for the exepcted data.
@inato-formis a library to make Forms easy leveraging Effect Schema
Rebuilding Redis for great Effect - Ethan Niser
Effect Schema has two way encode/decode support and you can pipe it for insanely custom validations.
With Effect STM (Software Transactional Memory) one can easily implement Transactions as Effect Types are immutable and TRef requires immutable data types.
The use for Typescript on the Server is business logic.
“Effect puts you on the path to more performant async code by default.” - Ethan Niser
Rebuilding Redis with Effect was a fun learning project.
Recipes for testing the easy and the hard stuff with Effect - Edouard Penin
To setup tests pipe(Effect.gen(test function), provide, runPromise) as pattern
to test failure use Effect.exit as you can now assert on the result
Tipp: always use test implementations e.g. in memory datarepo, database, kv over hardcoded mocks as it makes test code nicer and is as clsoe to prod logic wise + removes the need to maintain mocks
Effect for domains at Vercel - Dillon Mulroy
JavaScript/TypeScript promotes “happy path blindness”
- Errors are types as unknown
- JavaScript/Typescript doesn’t promote considering where something you call could error, what it throws and how it throws
- It also doesn’t promote thinking about how to do retries, backoff, etc
The JavaScript/TypeScript ecosystem is fully fractional and not designed to work together. Lots of packages do the same and we reinvent the wheel often.
Qualities of production code:
- Predictable: be able to have consistent operation, error handling and recovery
- Observable
- Refactorable: easy to add features, read existing code and make modifications
- Testable
- Intuitive: developers are naturally guided to simple abstractions doing the “right” thing is frictionless
- Scalable
On Errors with Data.TaggedError you can add internal error messages and user error messages right in the type and error throwing code. This provides max user and developer friendlyness as Effect to handle the error can show the nice error message to the user, and log the helpful one for the developer.
- Johannes Schickling annotation: use Schema.TaggedError if you want serializable/deserializable errors
Building LLM Systems with Effect - Elliot Dauber
LLM System: Agents, Actions, Workflows
Agent: Start -> Plan/Reason -> Choose Action -> Do Action -> Redo/End
Sub-Agents: Let Agents not only do Actions, but also delegate
How to add determinism? Agents go wrong at times and some things need to be deterministic e.g. Payments. The solution is workflows. Manually written code that gets executed deterministically.
Effect on the Frontend: When, Why, How - Sandro Maglione
When Effect? - everything that has business logic. e.g. RSC, Workers, Loaders, State Management
no Effect on Layout, Styling, CSS, Animations, Components. You don’t want Effect here.
How?
- create a services folder and define them (e.g. with Effect.Service)
- Runtime helper (create your Runtimes with Layers)
- Effect.runPromise in your pages
Why?
- Error Handling and Tracking Errors
- no issue running server / client code due to different runtimes via dependency injection.
How we turn the internet into a database with Effect - Tim Suchanek
Effect gives you super powers:
- Typed Errors
- Dependency requirements in the type system
- Interruptabilty
- Lifecycle management
Check out Effect.ServiceOption for optional dependencies, so you can write code that may or may not need a dependency without getting to complex!
Use ForkScoped to trigger background tasks e.g. CronScheduled Job and Scope to handle tshutdown and clean up gracefully.
Effect for AWS Lambda - Victor Korzunin
Try the effect aws package and runtime if you’re using AWS + AWS Lambda.
It provides an Effect Runtime for AWS Lambda to properly run your Effect program.
In case you want to run the AWS CLI from your Effect program, Victor has built an effectful wrapper.
Building Cortex, MasterClass’ AI Voice Chat Orchestrator - David Golightly
iOS + Web Clients are connected via WebSockets to Cortex backend service.
Effect has lots of built-in tools with Stream to deal with Websockets nicely.
Using Telemetry for event to event tracking within the Stream. Custom annotations to track performance.
TestClock from Effect is great to test for time based effects.
Tipp: assign Port 0 on Effect HTTP Api to have the OS pick a port for you. Dynamic assignment makes testing in parallel possible.
Next-gen DevTools for Effect - Mattia Manzati
use @effect/language-server for nice linting & error output in your IDE. It also includes refactor helpers!
There is an upcoming effect litner plugins with eslint first and others to follow.
DevTools VSCode Extension will have Spans too! Currently has Traces, Metrics. It’ll also come as standalone app + Chrome extensions …
Structured Concurrency, the hidden power behind Effect - Antoine Coulon
Concurrency requires guarantees of interruption as well as handling resource clean up. You don’t get that in TypeScript/JavaScript with promises.
Efect implements structured concurrency with Fibers. You get guarantees! Additionally with Effect Cluster it will be fully parallisible via distributed computing.
How DXOS uses Effect to transform AI - Dmytro Maretskyi
You can use Effect Schema to provide way better context to the AI Agent. That way we can go from unstructured data to structured data.
EchoDB powering DXOS leverages Schema for structured data so all AI tools can create a schema and strore structured data. Therefore going unstructured to structured. Giving the LLM more context on the data format.
Effect: A year of production - Michael Arnaldi
Effect 4.0 Codename “smol” available on the Github Org now!
- reduces bundle size dramatically e.g. in Frontend that’s great!
- Migration from 3.X to 4.0 should be mostly seamless as it’s mostly API compatible.
- Queue becomes way faster as it has been fullly rebuilt!
- Streams are becoming ~20x faster!
- Batching & Concurrency unified -> Batching way faster & more flexible.
- Transactions (STM) will be directly supported in Effect vs being in the STM module.
The end
To learn more about what we at dTech do check our casestudies