009 - Safer Releases, Better Tools, and Getting Hired
Welcome to another episode of Macro Mayhem. My name is Peter
Ullrich, and this week I am not joined by my co-host and good friend
Gus Workman because Gus is on a business trip in China visiting
family and visiting his suppliers for the most sought-after
modern latest hardware for Neurs. So stay tuned,
and hopefully next week or in 2 weeks, Gus is going to give us a
little update about his trip. But that means that this week I am doing this
solo. So excuse me if you have to listen to me now
rambling on without the pauses
or the relief you sometimes get when Gus takes over my ramblings.
So generally this week I'm gonna give you the
regular updates, news, blogs, maybe a joke, conference updates, and then eventually
I thought I would give you my thoughts on how to get hired
in 2026. So generally now with AI writing
a lot of code for us and people struggling to get employment,
I thought I'm going to give you a couple of my thoughts about how to
make yourself more hireable in 2026.
But these things, they have never really changed. Like, I think they're
still the same as 5 years ago, but I'm just going to give you my
little thoughts on that. But let's jump
into the news first. The first news item is about the
Hex 2.6.0 release.
And this is a major step forward in security
for the Hex package manager because the release includes
workflow identities, AKA trusted
publishing. And this means that if you
want to publish a package version from your GitHub
Action, right now Hex only supports GitHub for this,
but if you want to have an automated release from your action to
Hex, Previously, you would need to provide an API token to
the runner that then would authenticate with the Hex package manager and
push your release to Hex. Now, package managers
are probably the most,
not vulnerable, but targeted part
of an ecosystem. Like if you look at the npm package manager,
for example, it is under constant attack by attackers.
Because it is the single most
impactful attack that they can make, the most lucrative
payoff, so to say, when an attacker can compromise
a package manager or just simply release malicious
code. The reason for that is that if you want to,
let's say you want to infect the whole industry, a whole, like the JavaScript ecosystem
or the Elixir ecosystem, right? If you wanted to do that as an attacker,
you could either go off and target each developer individually,
But that would take a lot of time and effort, and you would not reach
everyone. You have a much higher impact if you
actually manage to release a malicious package on the package
manager. And to be honest, that's not too hard. Even today, you could
just push something malicious to Hex, and then it would be in the package manager.
But nobody would download that library, right? Maybe you could market
it somewhere and people would poke around with it, but they might also run their
own LLMs over it and see that the code is actually malicious, and then
they would flag it, Hacks would take it down, that kind of stuff.
So that's why attackers usually like to go after
well-established packages that have a lot of downloads
a week, and yeah, a week, and that also have
been active in terms of development. So they actually have
regular releases coming out, that kind of stuff. They're not legacy packages that
haven't been updated in years. And the reason for that is that attackers,
when they can compromise such a very popular and active package,
can push malicious code that then gets distributed to potentially
millions of machines or developers or CI runners
that also have other secrets and so on and so on. So by targeting
a package manager, your reward of publishing
some malicious code is much, much higher than if you would
do it in any other way. That's why package managers are
the most, yeah, attacked parts
of an ecosystem. And the Hex package manager is not different,
right? So we are a little bit lucky because the,
the BEAM ecosystem is much more niche than JavaScript. So maybe
that's why the attackers look at us and don't see a plentiful
bounty to go after. But that doesn't mean that the Hex
core team sleeps and thinks, oh, you know, we're not vulnerable.
Because we very much have the same issues as other
ecosystems and we need to mitigate them and make sure that we have safe
procedures in place. So that's why the new Hex release is so interesting
because the trusted publishing, AKA workflow identity
thing, allows your GitHub runner to exchange
a temporary token to Hex that then verifies
that that token is actually allowed to push to a certain package,
yeah, to a certain library. And then once that is authenticated,
only then the runner can publish that release,
the new release, and has like 15 minutes to do so.
So after 15 minutes, the temporary token is gone and so on.
And that means that if an attacker would get ahold of that token afterwards,
it is expired, right? So this makes it
again safe to publish releases from
your GitHub runners, which also makes it easier to collaborate
with others and just generally have your release process go through GitHub.
Now, this is, if you are releasing
packages from your local machine, you are also pretty secure already
because HACS now also has a 2FA step enabled.
And that authenticates you in that moment with the HACS package
manager when you press HACS publish.
So that is also a safe way of publishing a release,
but yeah, that's not an automated way and you can't do that inside your
Git Action. So that's why Workflow Identity is really interesting because
that allows you again to publish automatically from your
GitHub Action. And next to Workflow Identity, the HACS 2.6
release also has 3 other really interesting features.
One of them is staged publishing. And that means that even after
you release a, or you publish a new release to HACS, you can
hold it back until an official person from,
like a dedicated person from the project can then
verify it and approve that
new release. So you might have a GitHub Action
that pushes a new release to HACS, but then you personally, as the main maintainer
of the project, want to go in and in HACS,
press a button to say, yes, I approve this release, please publish
it. And yet again, you can enable this for extra
levels of safety, where if even an attacker would somehow get
hold of the temporary token to publish a new release, you can
then go in and would need to do a manual verification step so
that even then the attacker couldn't publish their
malicious version of your package. So staged publishing is really
interesting there as well, especially for larger projects, but also for you personally, if you
just want to be extra sure that nobody publishes a release without your approval.
Now, the next 2 features of the new release are also interesting.
The API keys are getting permissions. So previously,
one API key had access to everything on Hex on your behalf.
Now you can choose which permissions it has. And really
tailor it down to what's absolutely necessary.
And the last version, the last feature that I wanted to mention is
now Hex has an emergency publishing mode.
And yet again, I gotta say the Hex core team is way ahead
of the time and just preparing for the worst
possible situation, which luckily we yet haven't
had, but you know, they're prepared if it happens. So the
emergency publishing mode is something that the HACS team can enable globally
for the HACS package manager. And if they enable it,
every publish will need to be verified
yet again in HACS.
So the staged publishing rollout, so to say, they can enforce
it for every single release. If they, for example,
see that in that moment, HACS, the package manager, is under attack.
By a lot of malicious actors that got a hold of maybe the passwords or
secret keys of maintainers and are trying to publish different
malicious versions. And at that moment, when the HACS team sees, oh, we're under attack,
they can enable that emergency mode. And from then on, every published
version will be held back until the
actual maintainer goes into HACS and approves the new version.
So it's kind of like a, hey, we are in an emergency situation.
But what I wanted to say last about this new release is that
it yet again shows how impressive the work
of the Hex core team is when it comes to security and
generally mitigating risks that we
see other attackers actively exploiting in other
package managers. So you just need to look at the JavaScript ecosystem.
It is absolutely on fire right now with
malicious packages being released, people downloading them, getting compromised.
That again gives new tools
to the attackers who now have, you know, new compromised credentials so they
can release new packages and so on and so on. And I also
got to say that I think we are so safe and we haven't seen
these big attacks in the BEAM
ecosystem yet because of the work of the Hex core team.
So really big shout out to them. And as always,
there is never— actually, there's not a lot of money for these
people to do that work. Most of the security work is
unpaid and volunteered. There's a little bit of funding involved now,
but it's certainly not enough. And if I look at other ecosystems who
have entire teams paid and dedicated to making
sure that things are safe, and here we are relying on the work of volunteers,
to me, that does not sound like a very sustainable matter.
And yeah, if you wanna make sure that we are still safe, even in 2027,
go out and fund and sponsor the EEF, because with these
funds you can also support the HEX team. But now
it's time for the security question of the week.
Now for this week's security question, we welcome back Michael from
Paraxial.io. Michael, I'd like to ask you, what is the
landscape of security products in the BEAM ecosystem right now? And are these
products any good? And also, what should a
buyer look out for when they evaluate these kinds of products?
So I started Paraxial.io because there's really
nothing out there that's good. That was the case before
I started the company. And the reason for that's actually pretty interesting.
The total addressable market for companies
using Elixir specifically is pretty low. So every security
vendor that you go to will essentially say, oh, Elixir support
is on our roadmap, or it's something we're thinking about. In reality,
that company will have zero experience with it because
the market dynamics just, just don't favor it. If you're a
big software-as-a-service cybersecurity company,
your annual contract value has to be above a certain amount
to to satisfy your investors. So you're
not gonna have any Elixir expertise there. And the
reason people use Paraxial, it comes back
to the structure of the business because it's bootstrapped. So I
own it. There's no outside investor money,
so there's no pressure to kind of rapidly expand
in a way that's harmful to customers. And that's really the
only way that the business works, where the outcome is the
customers actually get true security.
So, and when you evaluate a cybersecurity vendor,
especially if you're an Elixir programmer, you should ask them directly, like, what's your
experience with Elixir and Phoenix or whatever language
you're using? Have you published any work related
to it? Could I see your public materials?
And that goes for both software that implements security controls,
as well as now we're seeing kind of like AI pen testing is
getting very hot. And I would not use
a company that claims to, oh, like, you know, we're the best at AI pen
testing, but we have no idea what Elixir is, and we
don't need to because the models will just get better and it won't matter at
all. And, you know, maybe that's true in 5 years or
1 year or 10 years. Today, I can tell you that
if you're using a frontier model for cybersecurity and you know nothing
about Elixir coding, it's not
a good outcome for the customer. I think especially Elixir programmers,
you know, listening to this understand how that
could go poorly when someone doesn't have that expertise.
Right. So, don't trust the output, evaluate the products.
And if you have any questions, maybe reach out to Michael. Yeah. I mean,
would you send an AI-written email that you didn't read?
Yeah. Maybe people have experience being on the other side of that, but in my
opinion, you should, you should be involved in the work. True.
All right, Michael, thank you very much for your answer on this week's security question,
and we will see you back next time. Moving on
to the next item, uh, my good friend Alex
Kutmos released a new version of the MJML EEX library,
and the new version is 1.0.0 RC.
So the first release candidate for version 1. And this one's quite interesting
because MJML is really cool. If you don't know
about it, if you ever want to send HTML emails
from your server and not just text emails, but if you want to make them
nice and pretty, please, please, please don't use raw HTML
and inline styling CSS. That might work,
But there are so many edge cases on all the
email clients that are out there, like Gmail and Outlook and
so on. They all represent the HTML
of your email slightly different, especially when it comes to layouting, like when
you have grid layouts or columns or tables,
that kind of stuff. Like all of them will show it slightly different
and sometimes broken. So if you want to make sure that your email looks
good in the most email clients, you should use
MJML. And the MJML-EX library by Alex
makes sure that you can just write it inside your Elixir
application. It kind of looks like Heks or like an HTML
template. But yeah, it just makes it so that when
you send out your email, it actually looks good in all these email clients.
So Alex has done a lot of work on MJML-EX,
and he also added, I think, 1,500 templates
or something ridiculous like that. A lot of templates.
for you to use in your everyday projects.
Well, he says a ton of prebuilt templates.
And interestingly enough, Alex also ran these templates
through Email on Acid. That is a
paid tool. I think it's now owned by Mailgun,
I think. So this is a paid tool, the Email on
Acid tool. where you can feed in your HTML of
the email and then see how it looks like in these different email clients.
So Email on Assets renders the email
how it would look like in all these different email clients. And Alex used
it to run the templates he provides for free now as part of this library.
He ran it through that tool to make sure that they look good, these templates
look good in all these different email providers. So if you want
to send pretty emails that look good in most email clients,
give the latest version of mgmlex a try.
Now, moving on from this, I'm quite excited about this one because
there is a new library out there called Roadrunner,
and Roadrunner is a pure Erlang HTTP
server. So in Elixir, we have Bandit now, which takes
over that work. Previously, we were relying on Cowboy.
But in the Erlang space, you so far only had Cowboy as an
alternative. And Roadrunner is now a competitor to Cowboy.
It is a pure Erlang HTTP server. It supports HTTP/1,
2, and even 3. So I'm quite interested in understanding how they
got that done. Because as far as I understand,
HTTP/3 with QUIC and everything support is really not easy.
And I see in Hackney and also in Cowboy that there's
some work done on this, but it's definitely not 100%
yet. So I'm quite interested in how they support HTTP/3.
But they say that they run the library.
And actually with they, it's also just one maintainer called William Frank
Tomei from Brazil. And yeah, he wrote this in
Erlang and it supports HTTP/1, 2, 3, and WebSockets purely
built in Erlang. And somebody also posted a comparison
to Bandit and it seemed to be faster, but I don't know how that benchmark
looked like, but you know, it's fast. So that's good enough.
And yeah, this, I hope, will give you, will give
the Erlang folks a good alternative to Cowboy.
So if you want to move away from Cowboy in your Erlang
application, you can now give Roadrunner a try.
Next, we have the release 0.6.2 of
TypedStruct. TypedStruct is a quite interesting
library that I wanted to highlight here because it brings
you the typed validations of Acto
schemas to non-Acto maps
and structs, right? So imagine you have, for example,
some parameters coming into your API, like you have an API endpoint
and you have like pagination and sorting parameters that you
have exposed on many different API endpoints.
You could use like a schemaless changeset for that,
but then you would rely on Acto to validate these parameters,
right? Like you get the API request and you want to validate the pagination
and the sorting parameters, that kind of stuff. So if you wanted to do
that without having to rewrite the validation functions
and just rely on something proven, You could use an actor schema-less
changeset for that, but then you would have a direct connection or a dependency
on actor for something frontend, really. So you might not want that.
And types struct comes in here quite handy because they
also, they look very similar to an actor schema.
They have fields and types and required flags and that kind of stuff.
And they also have validations for that, but they
are not actor schemas. So they might be more lightweight. And maybe
more extendable than Ecto. And they, you know,
they don't feel backendy like that. Like you wouldn't necessarily
use an— yeah, you could use an Ecto schema for these things, but generally,
like, you'd want to have something more lightweight. So that's where typed struct comes
in. And I just want to highlight it here for you to
just give it a try if you are looking for typed maps,
basically, or typed structs in your application. Wow. Well, TypedStruct,
that's the name of the library. All right, moving on.
The next library I wanted to highlight,
and I just realized they're by the same person, TypedStruct and this one
are by the same person who is called,
let me make this, oh, sorry, I'm gonna
look this up while I'm talking. Now I have to do both at the same
time and GitHub is not making it easy. Search Alenikov.
Serge Alenikov. He wrote both the TypeStruct
library and now also the one that I want to mention, which is called ErlExec.
So Erl execute, basically. And that
library, ErlExec, makes it really easy for you to manage
OS processes from your Erlang VM.
So imagine you have an Erlang or Elixir application and
you execute a lot of OS processes, like system commands,
and then you execute some CLI or something like that.
If you do that, it's, yeah, you have to handle like
failures and crashes and the responses of everything,
and especially the lifecycle of that process. So you have to start it. If it
breaks, you might want to retry that, like restart it.
So that is very much what you also have with a regular
process lifecycle, where you start a process and it might crash,
so you want to restart it. That kind of stuff. And Serge,
he wrote a, well, it's already
quite old, the library. I mean, it has been around for quite a few years,
I believe. Yeah, 11 years I see here. There's one 14 years,
one commit. So it has been around for quite a while.
But url_exec, it's a library that gives you an abstraction over
these OS processes that makes it easier for
you to manage them. Right? So if you want to spawn up a
lot of operating system processes, you know, FFmpeg is
always a good example. If you want to do something with FFmpeg,
like video encoding or decoding, that kind of stuff,
these are long-running processes that might crash.
So you kind of have to manage them somehow. And url-exe
gives you nice tooling to do so. So I just wanted to highlight
this because there is a new release,
2.6.0, released, I think,
2 weeks ago. Unfortunately, there's no changelog here, so I can't tell you what
changed, but just that release showed me
that, you know, this library exists, so I wanted to highlight it here.
All right, moving on from url_exec, I want to move to Transmutr.
And Transmutr is another yet interesting library that was recently
published by George Guimarães.
And Transmutr is quite exciting
because imagine you want to run a
model that is on Hugging Face. Like you just go to Hugging Face
and you find not an LLM, but just any kind of model
that you want to run. Like for example, some classifications,
or we also have seen demos of YOLO models
that like you only see once, where you only look once,
that classify objects in images and videos.
Right. So there are all these different kinds of models out there that you can
look at in Hugging Face. And the problem with most of them
is you can't natively run them with Elixir,
with the Nx backend. Because in order to do so,
you would need to rewrite their pipeline,
so to say, like their layers and their structure of each
model. And then you would need to Well, I'm not
an AI expert on this, but what I understood
is basically you need to rewrite the APIs
or the way of running these models. You need to rewrite that in Nx,
and then you can take the weights and feed these weights into
the— oh, okay. Let me rewind here a
little bit. So if you train a model, what you usually do is
you first set up the architecture of that model, right? So you might have
a neural network where you have different layers layers in that neural network. And then
you train the model and you receive weights from that
training. Now, if you want to apply that model to a use case, you take
the weights and you take the architecture of the neural network and these
2 things together, you take and then you feed some
input and you see what the result is, right? So on Hugging Face,
you can download the weights and you can download the architecture,
but that architecture is not written in Elixir. So you can't
run the architecture. You can't, you know, you can't use that code that
they have there. So you would need to rewrite that in Nx,
and only then you can use the weights together with the architecture built in Nx
to run the model. Okay. Sorry, again, I'm not an AI specialist. So if this
is wrong, please correct me, but that is my general understanding of the problem
here. Because what we've seen is that there are popular models on Hugging
Face, but you can't just take them and run them in Elixir because you're
missing that translation of the architecture into Nx
layers. Now, long story short,
this fix, Transmutr, the new library by George
Guimarães, fixes that to a certain extent.
And it fixes it for a particular protocol
that some models are stored
in, which is called ONNX. Okay. And that kind
of is, you know, imagine like JSON, like you store data in a certain
format. Well, ONNX is something similar to that.
And ONNX has all these different functions
that it has, like to explain the architecture
of the model, right? And what George Guimarães
did in Transmutr is he reimplemented these functions in
Nx so that you can simply take the ONNX
model and Nx with Transmutr understands
how to build that architecture and run that
model. So you don't need to build that Nx layer,
like the architecture again in Nx, but Transmutr understands
the ONNX protocol and just
gives you, you know, just runs it for you basically. Yeah. Okay.
Sorry. I'm really not good at explaining this, but the cool thing here,
like why you should care about this is that with Transmutr,
You can now run many, many more models than you could
previously run on simply Nx.
I think George gave a couple of examples
of models that you can— oh, actually, he explains it really
nicely in the README, where Elixir has 3 ways of running Hugging
Face models. One of them is Bumblebee, but that only runs on
all Nx backends. You got Ortex. that runs ONNX
models, but it doesn't run— it
runs outside of Nx and so on. Sorry, I'm not going to reread this thing
again, but generally, Transmutr now gives you access to
many, many more models you can simply pull down from Hugging Face and then
execute without having to write anything yourself.
Okay, enough about Transmutr.
And the last news item here, Jesus, really,
when Gus is not here, I just keep rambling on. I'm really sorry about
that, but You know, it's just stick with me. I'm only,
the last news item here that I would like to highlight, because you might've seen
that if you are scrolling Bluesky these days,
and I found it incredibly funny. It's not written in Elixir or anything,
but I wanted to mention it here, which is somebody
rewrote the vocal tract that humans
have. So like with the windpipe and your
tongue and the lips. And your jaw, your lower jaw,
like all these components of your body,
they create sound when you sing or when you speak,
right? It's a very mechanical setup. And somebody named,
I think he's called James, he rewrote or he simulated
that tract in Rust and
some of TypeScript. So there's a frontend here, but he rewrote
that thing. He created like a simulation of that.
tract of creating sound in the human body. You create a simulation of
that in Rust. And with that simulation, you can
let it sing, speak, beatbox, and more.
And you might've seen it on the Bluesky Atmosphere where there's
like a 3D head and it sings, you know, in a very synthetic
way, but it does so by simulating how a
human would sing or use that. that track.
So it's called the Chimera Vocal Synth,
the vocal synthesizer. And if you give it a try,
it's actually pretty simple to set that up. It's just a bun install
and a bun run. And then you can have a little simulated human
vocal track on your computer. Anyway,
that concludes the news section. And I don't think I'm going to do a discussion
section today, honestly. I'm already at half an hour. So So let
me just quickly go through the blog section here. Let's see how far we get.
Now, blogs. The first blog I would like to highlight is by
Dan Schulze. It's called Simple Feature Flags. And I'm
not going to get into the details, but Dan gives you a very nice
short blog post about how to write your own feature flags
without using Fun with Flags, like the library or anything. This is
a very simple, like a module setup and then just a configuration.
So it makes it simple to have a simple feature flag. All right.
So if you're interested in that, check it out. The next blog
is also by Dan Schulze. It is about HTML email
templates in Phoenix. And yeah, I wanted to highlight this
after talking about MJML EX earlier,
because what Dan did here, he created a new library called Premail EX,
and that takes any CSS styling. So with
Premail EX, you can write an email HTML template
In regular HTML and CSS,
no JavaScript, just HTML and CSS, and you can style the email with
it. And then what this library does is it takes the
CSS that you have maybe defined in a global app CSS
somewhere, and it puts it inline on every single HTML element.
And that's important because one of the first things you learn when you try to
render HTML emails. in an email client is that
email clients, they do not like, and they usually don't respect global
CSS variables or classes, right? So you
can't have like a style template, a style
tag in your HTML and just create classes and then reuse these
classes. No, you need to inline with a style attribute
every single CSS attribute
on every single HTML element. Yeah. And again,
MJML takes care of that for you. But if you don't want to use MJML,
but regular HTML, you can now use premail-ex
to design your emails with regular HTML and like a global
CSS styling. So you don't have to copy paste the font size
onto every text element, for example, you know, you can define that once.
And then premail-ex takes it and inlines the CSS styling
on every single element. So that should get you further
than just writing normal text emails. But again,
I wanted to point out that if you run this through Email on
Acid, like the tool, yeah, maybe it won't render
every time like you expected. So if you want to be really safe
on rendering good-looking emails with HTML,
I would still suggest maybe use MJML, but Premail MX already
gives you A much smaller, much simpler solution to get
started. All right. The next blog is
by Clemens Lukaszczyk.
Okay, I'm sorry. I think that's a very Polish last name with more consonants
than vowels. I think there's only 2 vowels and 10 consonants.
But Clemens, he wrote a nice blog post about a 1 millisecond
partition is enough to corrupt your node. AKA at least once
pub/sub. And this one's quite interesting because Clemens,
he explains, and I didn't think about this earlier, but it's true.
If you use pub/sub in Phoenix, for example, and if
you have 2 nodes, like you broadcast across 2 nodes,
your events, and you have like a super short
1 millisecond partition where the 2 nodes can't talk
to each other. In those situations, any broadcast you
would send from one node to the other would just not arrive
and not propagate and not notify the users on
the other node. And this might also happen
on the same node. Like if for whatever reason a process can't receive
the message, I'm not sure how that would work, but yeah. Anyway, but this is
more focused on multi-node setups. So yeah, you have 2 nodes that are connected through
an HTTP connection. And that connection can, you know,
miss a message or just a short break. Like there should be a short break
in the connection. And if you broadcast an event exactly in that moment
when the connection is severed, then the broadcast will not be repeated
and the other node will not receive that broadcast.
So Clemens, he wrote a library called EchoPubSub
and explains the why in the At Least Once PubSub
blog post. And it's quite interesting because it adds 2
things. It adds a buffer of messages and it adds a
cursor for the readers. So this is
a very standard setup if you wanna have a message queue. So you have a
message queue and you give every message a unique identifier that never repeats. And then,
so if you, yeah, so you can always identify the
messages and you kind of keep them in a buffer. Or at
least a queue where you wait for an acknowledgement,
right? So you don't just send them and forget about them. You actually can kind
of keep them in a queue until you know, okay, the receiver received
it, and then you remove it from the queue. Now, this is the first part
of a regular message queue. The second part is a per-client
cursor where you say, all right, I have like
3 other nodes or 3 other clients that are connected
to this message queue. And what I'm going to do is I'm going to keep
one cursor, which is basically just a pointer to
the queue that says client A has received message 3,
but client B has only received message 2,
which means that client B needs to receive message 3
in order to be up to date at the, at the latest message,
at the last message in the queue, right? So Yeah,
you basically keep a cursor or a pointer per client. And then
if one client doesn't receive a message, you can,
you don't update the cursor. And then later on, you understand,
oh, this client is missing, you know, the latest 10
messages. I'm just gonna resend them and wait for the client to acknowledge
them. And only when they're acknowledged, I'm gonna increase the cursor,
or I'm gonna point, I'm gonna update the cursor to point at the latest message
the client received. I'm explaining,
I'm overexplaining this, but hopefully it's interesting. I don't know. I'm just rambling. Today's just
a rambling session. So yeah, anyway, Clemens, he wrote a really nice
library and the blog post about how to add such a
message queue with cursor tracking to
Phoenix Pub/Sub, right? So if that is a concern
to you, and I think that might be a concern to anyone who has a
multi-node setup, and is broadcasting through Phoenix Pub/Sub,
you should consider giving Echo Pub/Sub a try
and see whether it works for you. All right.
The next blog post is by Charlie Forêt.
I'm sorry, my French is a little rusty. Forêt. I'm just gonna say it Forêt.
With an E with a little roof on
it. Okay. And the blog post is, your Phoenix app
has 2 trust stores. Now, this is actually a
deep dive into the Emudra certificate compromise
that happened, I don't know, a couple of weeks ago already.
Like, time is not real in these months.
You know, time is very short and long at the same
time. Like, every day feels very long and then every week feels very short.
So I don't know what happened last week. It might be Emudra. Emudra might have
happened 3 months ago. I can't tell anymore. So yeah,
by the way, I'm starting a startup, if you haven't noticed already.
Yeah, that's a startup founder brain.
Anyway, but what I wanted to say about Charlie is that his blog post explains
in a lot of detail how our Phoenix apps are affected
by the Emudr certificate compromise and
what you can do about it, but also just, yeah, how it works.
And we, I think we mentioned that in the last episode that you have the
CA store library, you have the Certify library, and you have the
OS, so the host certificate stores, right? So like
3 things you need to look into. And Charlie gives a really, really nice overview
about how, if you, like,
which use case would make you vulnerable if
you don't update any of these 3, right? So you update Certify and the OS
host, but you don't update CA store. And Charlie gives you
an example of, well, if the attacker does this and this, then you would be—
there could be a man-in-the-middle attack, for example.
So he gives a really nice overview of the actual implications of that
Emudr compromise. So great read, really interesting.
Now, the next 2 are by our serious perpetrator,
Johanna Larsson. She yet again wrote 2 blog posts. I think
one of them we missed last week. But they're both really good and they yet
again dive into the ATProto ecosystem. One of
them is called Building an ATProto Account Typeahead Search Service.
That's quite a mouthful, but generally she explains
how it is quite difficult in a distributed
network like the ATProto network to do search,
right? So just search all the account names.
Well, now you have, I don't know, hundreds of servers that you need to query
for their list of usernames because there's not
a single centralized server that keeps all these account
usernames handy. And Johanna does a good job at explaining this
problem. And that also explains how the ATProto network
really is set up and works. And she wrote a nice
type-ahead search service, kind of like as a proof of concept to
show how you can still make the data that is distributed through
all these different servers how you can still make that accessible through a single entry
point. You know, so like a user just wants to, like on X
where you, or LinkedIn, where you want to find a user by username. Well,
on A2Pro2, you need to be a little bit more hacky about
how you serve that query, right? So yeah,
she does a really good job of explaining what she did here. And then
the second blog post is Tangled in a Box.
And I found that really interesting. Because what she did
here is she basically set up a Docker Compose file that
you can run, and that would start all of Tangled's
server, like containers and services that you need
to self-host Tangled, which is a GitForge built in Finland,
I believe, by a startup over there. And it's using the A2Proto
network quite a bit to to make
your code and the whole conversation, everything around it accessible.
So tangle.org is a quite interesting, nice project.
And yeah, Johanna, she had that situation where she wanted
to self-host the entire stack with many different subsystems and
services in a single Docker Compose. So she
wrote that and put it out there. And it's quite an interesting read.
Now, the next 2 blog posts and also the last 2 blog posts are
a little bit outside of our bubble. So I wanted to introduce them here
because, you know, I like to go out of our bubble a bit
more these days and just see what's out there. And one of the blog posts
is by Gianna Paris. And I met
Gianna at a conference here in Amsterdam a couple of weeks ago,
where she gave a really, really interesting talk about the,
about how she basically hacked and tries to compromise LLMs.
In different ways. So Gianna, she's an offensive and defensive
cybersecurity expert. And her latest focus
is on LLMs and how to compromise LLMs and how to compromise
other people's LLMs. So if I run Claude,
how can she inject stuff into my Claude
LLM instance? So yeah, she recently
wrote a blog post about How she can inject invisible
Unicode characters into text files that
she then hosts on GitHub, like a skill, for example. Imagine a skill set that
you can just download and add to your Claude or Codex or whatever setup.
Well, if you just download a skill like that, people can't—
even if you visually inspect it on GitHub, like you open
the skill markdown file and you read through it and you look at it,
And you think, oh, there's nothing malicious in here. Well,
guess again, or think again, because you can
actually embed invisible Unicode characters that
eventually are representing text that LLMs
then read and respond to again. Really interesting.
So you're injecting invisible text into an LLM,
and because LLMs love to read and follow your instructions,
the text instructions in a skill. Yeah. Yeah, they might just do that.
So yeah, Jenna, she explains how she embeds
invisible Unicode characters into these skills and then has
the LLM basically scrape secrets and send
them off to an attacker server or iterate through all the
secrets in your system and then delete them from your key management
storage, from your KMS, for example. Like if you're running on AWS,
You know, you have some secrets in like a key, in the keys managed
storage, and the LLM can just go in there and delete them.
You know, if you don't have the right permission set or if you have too
many permissions. Anyway, long story short, it's quite
an interesting read if you just want to think about how your LLMs
are vulnerable to things you might not expect.
All right. And the next and last blog post here is by Chris.
Chris. And I never really fully understood his last name, but he's
known as Chris. And he wrote a nice blog
post about how to keep loving tech.
And I wanted to share it with you because I think many people these days,
they're a little bit, let's say,
well, depressed maybe even about how our
industry and how the job as a software engineer has changed
in the last year or 2 because of AI, obviously. And Chris,
he has gone through that process
of understanding, like he was always a passionate
software developer who loves to write code, who loves to understand technical
problems, work through them and share them with others.
He's streaming a lot. So that's how, so I saw him once on a
stream. He's a really nice person, I believe from Canada, French speaking
though. So he's a
person who loves to learn and to write code. And when AI
arrived, yeah, he was a little bit sad. He was very sad actually,
because he couldn't write code by hand anymore.
And this blog post walks you through his process
of working through this, talking to people, and then eventually finding
something that's, yeah,
like putting it into a box that makes him interested into the project again.
Right. And I'm not going to spoil it too much,
but basically, yeah, Chris says, well,
I can still in my free time write code by hand.
Nobody's forcing them or him to do, to use AI in
his free time as well. So that's point one. He can still do what he
loved before. And the second thing is AI enables him to
go into new areas that he previously couldn't get into, like 3D
modeling and hardware engineering and that kind of stuff.
Where he can just do things that he always wanted to do,
like projects to build your own hardware, for example, NERF stuff, right?
And now he can just do these kinds of things because he has AI helping
him doing these things. So yeah, it's a very interesting
read. It's a very emotional read. And if you're in a similar situation,
maybe give it a try. All right.
Getting to the end here. Next up, the conferences.
Just one. I just wanted to mention that ElixirConf EU They
have a call for proposals or call for speakers, and that
closes December 15th. So that's about
a month away from today. If you're interested in speaking at
ElixirConf EU next year, the conference is going to be on April 22nd
and 23rd in Lisbon. So if you're interested in speaking
at that conference, please don't forget to hand in or submit your
talk proposal. And that's it for conferences
this week. Let's see, we have next up the joke
of the week. Now I'm all by myself, so let's
see. I actually,
I don't remember what I told you before.
Let's see. Why did the Mexicans start taking anti-anxiety
medication? For Hispanic
attacks. Okay.
It's even weirder if there's nobody
you talk to, you tell the joke to. But anyway, second one, why can't
you make a reservation at a library? They're always fully booked.
That one's a better one. Okay. And folks, we're now
in the last leg of this podcast. I'm going to take it
super short. There's a A little bit of a discussion about how I think
you can make yourself more hireable in 2026. I originally wrote
this down because I thought I'm gonna go through the news and the blogs in
like 20 minutes tops. Haha, think again.
After 45 minutes, that has proven to be wrong.
But yeah, let me give you my— just dump my thoughts
on how I think you can get hired in 2026
and '27 now with AI. Writing most of
the code and junior jobs not existing anymore.
Basically, I think juniors are just really screwed
these days. So first
of all, a couple of things. First of all,
I think we should realign our expectations
around what a healthy hiring
market looks like, how a healthy tech market
looks like, because many of us might still have
the expectations of how it was
5 years ago, 8 years ago. So like the end
of 2018, 2019,
2020. No, sorry, what did I say? Like 2015
to 2020, right? I mean, that's when the hype of the
tech market already started. And then 2020 was the craziest
year ever, '21, '22 as well,
when everyone was hiring tech people left and right. So that
was definitely not a healthy market. And we can now see all the,
like the implications and the consequences of that where, you know,
Amazon, the big companies, Microsoft, they're constantly
laying off thousands and tens of thousands of people.
And most of that is because of the hiring spree 5
years ago, you know, 3 years ago. And now that we're in a very
different time, plus AI on top of it, these companies
just realized that they have massively overhired.
And that's not great for either the company or the people. Obviously, it's a very,
very bad situation and it sucks, honestly. But I just wanted
to say that as a As a preamble to say
that I don't think looking at the hiring market 5 years
ago and wishing that to come
back is a realistic
expectation or even a healthy expectation, right?
So I do think that what we are experiencing now
is maybe closer to the true bottom
line, the baseline. of how a tech market looks like
than definitely 5 years ago.
And to be honest, like nobody really knows that
anymore, like how a healthy baseline looks like because
the, you know, the years between 2015 and
2023, these 8 years or maybe the
10 years from 2013 to 2023,
like Those were definitely not healthy times,
like normal baselines that we could compare this to,
right? So what I mean basically
is that now we're trying to figure out what is a healthy
baseline again in terms of hiring, right? Nobody knows.
Nobody really that is still in the industry, or very
few people that are still in the industry know how it was 20 years
ago. But even then you had the dot-com bubble and all that kind of stuff.
So maybe there was never really a healthy, calm time
in the tech market where like a normal amount of people were hired, you know,
so we might not have that historical reference that
we can compare ourselves to nowadays. So that's
why I'm saying generally like these years feel like we are
getting back a little bit to normality more or less, but also
not fully. And You know, of course, that's also a thought on my mind.
Like now with AI, we have fewer people
being hired than we would have without AI.
I think that's safe to say that now fewer people are getting hired
because companies can increase the productivity
of the engineers they have by giving them access to LLMs and that kind
of stuff. So in that regard, we might be lower
than a healthy baseline without any AI,
without hype, right? So,
and it still is
difficult. I would like, I definitely understand that it's still
a difficult market to get hired in. So I'm not downplaying
it, but I'm just saying, yeah, like it's,
we won't go back to the old days where you were hired within 2 weeks
by a super, like a Hyperscale, not hyperscale, like a
startup that would hyperscale, right? That would hire like
500 people at once or something. So anyway, that's to say about the expectations
a little bit. That's step one. But then generally
the question that I wanted to discuss a little bit, how can you make yourself
more attractive to employers? And I
believe the answer to that is the same as it has
always been, which is to put
yourself out there and prove your worth through
projects, through projects, through learn, like writings,
material generally that you put out so that just show
people what you can do and what you're interested in and that you're a proactive
person and that kind of stuff. So, you know, if you have
side projects that you play around with, put them on GitHub
or push in, but whatever, like put them out there, make them public,
market them a little bit, at least put them on the Elixir
forum, put them on Bluesky and LinkedIn
too, right? I mean, many like companies are on LinkedIn.
Don't underestimate that reach. And if you just do it
once, that's okay. But what you need to do is a bit more of a
Yeah, like a marketing strategy for yourself. And I'm
not saying it in a way that you need to do these things in order
to have a marketing strategy. So it's not that you create the
strategy and then you build a project. I'm just saying, like, if you are a
passionate software engineer, you most likely already have side
projects and interesting learnings that you're
just making because you're interested in things, right? So just take those
things and then put them online, publish them, speak about them.
Make videos about them, go to conferences, speak about
that, right? So there are many, many different ways to share
and to highlight and show what you're working on.
And I do believe, yes, it takes more time
than not doing it, and it takes a little bit of discipline,
but ultimately it will even increase your
learning from the project that you worked on, right? Because we
all know that you can just start a project on the weekend,
be super excited about it, but then come Monday, you're back to your day job
or something else, and you forget about it, and you lose the excitement,
and then you just move on with your life, and you never touch it again,
the project. Well, in that situation, yes, you played
around with something new, you touched it, but you never went
through like the full cycle of understanding a problem,
building something for it, like a solution, or just tinkering around
with something. And then to reflect on it and actually kind of,
yeah, go back and understand what you have done and why.
And this kind of reflection moment, I think that that is really when
you learn deeply about a topic that you have
looked into, that you learned something about. And the best example
for that is like, if you read a book, you know, you have an interesting
book in front of you. It's not like science fiction or something. It's more like
a a nonfiction book, and you read the book and you read it page by
page and you really, you tell yourself, oh, this is so
interesting. I just learned something. You know, whatever the author wrote
here, this is super exciting and I'm never going to forget that fact or I'm
never going to forget this argument. Well, you know, have your partner
ask you a day later what was on that page, and then you should
try to reiterate what you've learned from that book.
I would guarantee you, I would bet with you that most
likely you forgot most of what you read.
You know, all the details that you in the moment understood,
you will have forgotten them by the next day. I can almost guarantee you that.
And you will still understand the general picture of the book and you can
maybe point at certain chapters and say, well, this problem is explained here
or whatever. Like you can still, you have highlights, like an overview.
But the details and the reasons and the arguments,
you most likely forget, right? So that's why I'm saying if
you— and that's the same with side projects too. Like you build
a side project and then you move on with your life and you forget what
you learned in that side project. But if you take the time to,
for example, write a blog post or record a short video or make a
podcast like I'm doing right now, or give a conference talk,
Like that gives you an opportunity to deepen your understanding
and to reiterate on your learning of that project,
of whatever you worked on. And only through these iterations and
like this reflection, I think you really develop an understanding of
what you have learned there, right? Yeah.
So that's why I'm saying like, I think it's a win-win for you,
for your opportunities, but also for the ecosystem.
If you learn something or you write something or you build something,
and then you share it with the ecosystem and you share it in a way
where you yourself have to sit down and reflect on
what you actually learned and why it was important and these kinds of things
or solutions, like why did you solve a problem in a certain way?
Yeah, these kinds of, with your arguments, the pros and cons of different solutions,
that kind of stuff. So I think that is, Probably the
most effective way of learning to
become a better engineer, to increase your hiring opportunities
as well, because people out there, they see
that and they connect it to your name. And please,
like, if you share something, share it under a name that is yours.
Like, you know, at least use your first name and you don't have to use
your full name, but at least use something that I later,
if I get an application in my, like I'm hiring and
I see an application and I recognize the name,
that is what you want to go for, right? So if you have
like an anonymized username, I don't know,
you use, you know, a username you made up 15 years ago, I can't
make that connection. I probably won't make that connection. And even if you are
known as, you know, the person like that username, As a recruiter,
I probably never heard about you, right? And there are very few people in the
industry who can pull that off, who made that hacker tag
or the username their brand and who are recognizable under that
username. Very few people get to pull that off. So for you,
my suggestion would just be use your real name, and if it's just your
first name, but this way, you know, if later
an engineer in a company sees your application coming through the pipeline,
They can connect that name or that face to you and
the things that they read about, like from you and the talks that they
saw from you, right? So you are a brand and
you need to, yeah, like brands do, you need to make sure that your branding
is on point, that you use the same name, the same profile picture,
maybe everywhere, everywhere where
I might see you, right? And then, yeah,
again, this is not a way of saying look
at it from the branding or from the marketing side and then think
about what you could build for it. You know, think about it the other way
around, like you're building something and then how can you market it better? How can
you go to the marketing side and make it work for you,
make it efficient for you, right? Yeah, but long
story short, you just have to share your
learnings. I think that is still the best way of of gaining a reputation.
And not only that, but also when you apply to companies and you
get, like, first of all, the CV already, the CV check, you can
put projects on there or blog posts or conference
talks that you've given. You can put that on the CV. So that already makes
your CV itself more interesting. And then when you get
to the interview stage where you've talked to people, you can point
at these projects that you've done before and they might have heard about it,
or at least they can then look at that thing that you have built
outside of the context of applying for a company, right? Like that is something you've
built like a year or 2 ago. And that kind of shows them how you
work without having the spotlight on you of an interview or
like a technical exercise, right? Like that shows the real you.
And then, you know, like just make sure that it's presentable, you know, that it's
not complete garbage. So yeah, you have
to think that it People will look at it and yeah, if you want
this to represent your skills, then also make it
representable. That's how easy, how it is. Yeah.
But yeah, generally, I mean, I did a little bit of hiring at my last
jobs. I never was like the hiring manager or anything, but you know,
I had, I interviewed people, I reviewed CVs,
and if I knew a person by name and I could point,
and in my head I already knew one or two projects they've worked on,
I most likely would have greenlit that CV to go through,
you know, to at least go to the next stage because
I just know, okay, like they built this library. Oh, I heard
about that library. Yeah, it's a pretty cool library. It's a small library, but it's
super useful and it's well-built, you know, it has a great API. Great, you know,
CV check, boom, done. You're through the CV check.
And then during the interview, the personal interview,
I might also ask you questions about that, right? Or you can tell me,
oh yeah, I built this library back then that solved a similar problem or something
like, you know, you can, you have like knowledge that
you can use in the interviews to actually prove that
you are capable as an engineer, right?
Yeah. So these are my ideas. And the
very last thing I want to say is be
proactive in a way.
Like if you want to apply to a company,
just apply to them, maybe even without
them having an open position. So that's a first thing where like
open positions, they're always a little bit delayed and they might not always represent
what the actual need of the company is. If you, if maybe you
have a lucky time where like your timing is lucky where you send
an application and in that moment there is already a manager in the company kind
of trying, you know, to convince management to give them an extra
spot in the team and then your application comes in which fits that position,
well then you're ready. You might already have that process ongoing for
you because now they don't have to open a position and have 100 people applying
to it. You know, they already have you on the shortlist, so they're going to
contact you first. So there are lucky chances like this. So if you
see a company that you really like, just proactively apply to them.
And when you apply to them, please, please, please don't use AI
to write the COVID text or anything. I mean, companies these days,
they don't require you to do a lot, you know, send in your CV,
maybe a short one-paragraph motivation letter, so to say.
But please, like if you send in AI-generated slop, it's an
immediate rejection, you know, then you might as well not have applied.
So just put in the effort. It doesn't have to be hours.
You know, you can probably write a one paragraph in like an hour,
research the company, research what they're actually working on,
and then how you might, why you would be interested
in the product as well. How you could contribute and
why they should hire you, you know, why you're a good fit for that particular
role in there. So yeah, sorry, you know,
it's very typical things, but I'm just thinking in these days of where
everyone has access to AI and LLMs, if you are the person
who writes a handcrafted, just a sentence in
the email or like a paragraph in the email, people will
recognize it and they will, you are in the top 5% already just
because of that. Because there are 100 applications that
are using AI and that are immediate rejections. And then there are
5 applications that are handwritten, right?
I would rather take these 5 any day. Like, at least they
have a much higher chance of getting through the first round, like a CV
check, for example, right? So that's my
second argument. Just don't use AI. You can sure use it to review
your CV. But when you write your CV and your cover letter, that kind of
stuff, just don't use it. You know, don't have it write the text at
least, right? So,
and I think that's it. I'm just going to wrap up here, folks.
Thank you very much for tuning in this week to Macro Mayhem.
Sorry for the long rambling. Hopefully in 2 weeks, Gus is going
to be back and he's going to hold me back a little bit, or at
least take over some of the rambling. But until then,
I hope you're well and I will speak to you soon.
