“An agent is an actor. It has durable state, an address you can send messages to, and it can say no.”
@aramallo on agents that are more than an LLM in a loop, and why the BEAM suits them. https://t.co/L2VIFdGIlX
GPUI is going to win the future, so easy to get something going quickly and if you use elixir and know how to use Heex/LiveView I have good news: https://t.co/ylbvAKXaKp works fantasitcally.
Next drop from #AshConf is out! @joshprice talks about issues that we've all faced time and time again, issues with time, dates, languages, units, measurement...some of the most surprisingly difficult problems of programming!
https://t.co/X6ioW6e7lH
#ElixirLang
The BEAM makes it easy to inspect running systems. I think that could be a big advantage for AI agents, if we can do it safely.
I've been working on Porthole: read-only SQL access to live BEAM systems via MCP.
https://t.co/kxDKOu7hkl
I will talk about Lynx, my Erlang/Elixir to Lean compiler for writing laws and proofs about your Erlang/Elixir programs today at @CodeBEAMio’s lightning talks!
Hace mucho que no veía mi nombre en la portada de diario impreso. Dos cosas me quedan por ciertas, al papel todavía le queda algo de magia y uno nunca deja de ser periodista.
Acá el link para lean la nota.
https://t.co/qHy1QIXFC5
I guess that's one way to look at it :D
On the other hand, I'd say this has been an excellent way to publicly show that we are not one bit ready to stop reading code. The specs are inconsistent, the initial one-shot of all languages were garbage, reliability is overlooked, and everyone agrees the code is below standards across the board.
If someone is looking at this mess and saying "yeah, this means I can vibe in language xyz", then I don't think there is any amount of evidence that would convince them otherwise. Maybe we can stop reading code if we put effort into building solid practices and guidelines, but this "benchmark" also showed putting those in place require real work and we cannot just vibe our way through them.
with all the dunking on @elixirlang, a quick note from someone who bet on it.
phoenix liveview is processes all the way down. that is what lets us build interactive ui without the overhead and indirection of client side state management. we ship and test interfaces insanely fast and nothing else has come close.
and that is just liveview. @elixirphoenix is one of the most productive web stacks i have tried.
the erlang runtime is the other half. agents can attach to it in dev and in prod and see the process tree, memory and cpu, not just symbols. it is a system you can interrogate.
we have not used everything it can do because we have not needed it yet. when something does need to be fast we can drop into a nif and write that part in rust, and so far that has barely come up. we optimized for feeling productive so we could get the business off the ground. @marekfort and i say the same thing every time. best decision we made, and even better with agents.
Wow. They told me Goatmire was special. Now I understand.
What @lawik and his team have created here is truly remarkable. A friendly, warm, welcoming gathering of like-minded people in an absolutely unique setting, with every detail crafted with love.
From the mythic theme to the excellent talks to the evening in a bar listening to lightning talks, it was just perfect. So glad I could be there this year. Thank you for giving this wonderful event to the community.
And, as a bowl of cherries on top of this cake: AshConf.
Thank you @ZachSDaniel1, @joshprice and your team at @teamalembic for organizing a day dedicated to Ash, which I think is a critical enabler for building sustainable applications in the age of AI.
I was so hoping for another Ash event, and you made it happen. Thank you!
Now back home, and really grateful for the last week.
Very exciting feature coming to LiveView: subscribe to a PubSub topic from any LiveView (or LiveComponent!!!) and LiveView will automatically manage the subscription for you. Simply:
subscribe(socket, "user.updates", &handle_user_updates/2)
PR: https://t.co/wX0sWMqfzB
To whom it may concern 🙃️
In abstract terms, I think of a software system (e.g. a web server, database, message queue, ...) as a collection of dynamic activities. Multiple things are happening: handling of requests, background tasks, periodical jobs, error handling, reporting, and recovery. Many of this things are completely independent, but some of them are working together.
These activities have their lifecycles. We want to be able to start the activities in the proper order. We want to be able to dynamically start more activities. We want to be able to stop the activities in the reverse order. If Bar depends on Foo, we want to start Foo first, Bar second, and we want to stop them in the reverse order. Some activities will be decomposed into smaller subactivities. So if Foo internally runs Bar and Baz, we want to be able to stop the entire subtree. For example, if a user hits the cancel button, we want to be able to stop all the activities related to that task. And we want to be able to do this even if the task is stuck in some CPU processing loop.
A software system has non-binary success semantics. Just because something fails, doesn't mean everything should stop working. But whatever is tightly coupled to the failing activity should stop too. However, the failing thing should not leave inconsistent mess (state, dangling resources) behind.
BEAM & OTP is give us the primitives that address just that. The way I think about my systems in abstract maps very closely to the way I implement them. This vastly reduces the mental overload of thinking about the code. The conceptual view of the system maps very closely to the actual physical model (process structure). This is a power of a good abstraction. For more details, see my talk Soul of Erlang and Elixir, where I tried to explain the underlying ideas.
The conceptual properties I mentioned above will have to be supported, because they are inherent to a software system. If you're building a software system without this support, these concerns will get entangled with your business logic. Whether you're doing it manually or vibe it, this work becomes more complicated. You or your agent have to deal with non-functional requirements together with the functional ones. This will make your job and the jobs of agents more difficult. Remember: code is the part of the context, perhaps its largest part.
So in the age of agentic development, my position about BEAM remains the same. If you're building a software system, it is the tool that fits the problem, and it will simplify your life. You might bump into situations where some other properties will be more important (e.g. raw processing speed), but you can then implement these parts of your system in another language, say Rust, and manage them from a BEAM-powered system.
As many of you know, I'm a long-time user of Erlang and Elixir. But I don't choose those languages for the syntax. For the record, I actually prefer C-style curly-braces syntax. I use those languages because of the runtime properties and guarantees, and because this technology reduces the impedance mismatch between the way I think about the system and the way I implement it. I also actually mostly prefer Erlang syntax over Elixir (minus some exceptions). The reason why I use Elixir is mostly tooling & some language features (e.g. macros). But the choice of the language was never a fanboy choice for me. If you're not building a system, BEAM langs are most likely not your hammers.
@bcardarella "None of that matters" when discussing a "benchmark" that is nothing but lies.
This has nothing to do with language tribalism, and everything to do with critical thinking and intellectual honesty.
You chose to support and defend the opposite of that.