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.

009 - Safer Releases, Better Tools, and Getting Hired
Broadcast by