frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

How I bypassed Amazon's Kindle web DRM

https://blog.pixelmelt.dev/kindle-web-drm/
657•pixelmelt•7h ago•206 comments

Free the Internet: The Tor Project's annual fundraiser

https://blog.torproject.org/2025-fundraiser-donations-matched/
4•pabs3•10m ago•0 comments

Claude Skills

https://www.anthropic.com/news/skills
524•meetpateltech•12h ago•294 comments

America’s semiconductor boom

https://www.youtube.com/watch?v=T-jt3qBzJ4A
106•zdw•5h ago•51 comments

Gemini 3.0 spotted in the wild through A/B testing

https://ricklamers.io/posts/gemini-3-spotted-in-the-wild/
303•ricklamers•11h ago•180 comments

Cloudflare Sandbox SDK

https://sandbox.cloudflare.com/
153•bentaber•7h ago•48 comments

A 4k-Room Text Adventure Written by One Human in QBasic No AI

https://the-ventureweaver.itch.io/tlote4111
70•ATiredGoat•4d ago•45 comments

Lead Limited Brain and Language Development in Neanderthals and Other Hominids?

https://today.ucsd.edu/story/did-lead-limit-brain-and-language-development-in-neanderthals-and-ot...
45•gmays•5h ago•14 comments

Your data model is your destiny

https://notes.mtb.xyz/p/your-data-model-is-your-destiny
198•hunglee2•2d ago•30 comments

DoorDash and Waymo launch autonomous delivery service in Phoenix

https://about.doordash.com/en-us/news/waymo
231•ChrisArchitect•14h ago•518 comments

Codex Is Live in Zed

https://zed.dev/blog/codex-is-live-in-zed
194•meetpateltech•12h ago•28 comments

Hyperflask – Full stack Flask and Htmx framework

https://hyperflask.dev/
302•emixam•15h ago•95 comments

Next steps for BPF support in the GNU toolchain

https://lwn.net/Articles/1039827/
4•signa11•1h ago•0 comments

Talent

https://www.felixstocker.com/blog/talent
128•BinaryIgor•10h ago•56 comments

Why I have to buy doughnuts with cash

https://www.ft.com/content/8766ef23-3938-4de2-8a37-602c798034aa
10•hhs•5d ago•18 comments

Understanding Spec-Driven-Development: Kiro, Spec-Kit, and Tessl

https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html
49•janpio•6h ago•6 comments

Syntax highlighting is a waste of an information channel (2020)

https://buttondown.com/hillelwayne/archive/syntax-highlighting-is-a-waste-of-an-information/
230•swyx•4d ago•92 comments

Post office in France rolls out croissant-scented stamp

https://www.ctvnews.ca/world/article/french-post-office-rolls-out-croissant-scented-stamp/
101•ohjeez•1w ago•37 comments

Microwave technique allows energy-efficient chemical reactions

https://phys.org/news/2025-10-microwave-technique-energy-efficient-chemical.html
36•rolph•6d ago•1 comments

Elixir 1.19

https://elixir-lang.org/blog/2025/10/16/elixir-v1-19-0-released/
229•theanirudh•20h ago•50 comments

Benjie's Humanoid Olympic Games

https://generalrobots.substack.com/p/benjies-humanoid-olympic-games
106•robobenjie•8h ago•78 comments

A liver transplant from start to finish

https://press.asimov.com/articles/liver
13•mailyk•4d ago•2 comments

Electricity can heal wounds three times as fast (2023)

https://www.chalmers.se/en/current/news/mc2-how-electricity-can-heal-wounds-three-times-as-fast/
145•mgh2•15h ago•90 comments

How to tame a user interface using a spreadsheet

https://blog.gingerbeardman.com/2025/10/11/how-to-tame-a-user-interface-using-a-spreadsheet/
100•msephton•6d ago•24 comments

A conspiracy to kill IE6 (2019)

https://blog.chriszacharias.com/a-conspiracy-to-kill-ie6
169•romanhn•9h ago•100 comments

Lace: A New Kind of Cellular Automata Where Links Matter

https://www.novaspivack.com/science/introducing-lace-a-new-kind-of-cellular-automata
122•airesearcher•14h ago•48 comments

Show HN: Inkeep (YC W23) – Agent Builder to create agents in code or visually

https://github.com/inkeep/agents
64•engomez•15h ago•47 comments

Hacker News – The Good Parts

https://smartmic.bearblog.dev/why-hacker-news/
119•smartmic•7h ago•132 comments

A stateful browser agent using self-healing DOM maps

https://100x.bot/a/a-stateful-browser-agent-using-self-healing-dom-maps
110•shardullavekar•15h ago•54 comments

VOC injection into a house reveals large surface reservoir sizes

https://www.pnas.org/doi/10.1073/pnas.2503399122
91•PaulHoule•5d ago•79 comments
Open in hackernews

Elixir 1.19

https://elixir-lang.org/blog/2025/10/16/elixir-v1-19-0-released/
228•theanirudh•20h ago

Comments

crbelaus•20h ago
The progressive introduction of automated type checking in Elixir should serve as a reference on how to improve a programming language gracefully without breaking changes.

So many examples of programming languages have huge breaking changes between versions that end up creating a split in the ecosystem that takes years to resolve.

Thankfully José has been very clear about Elixir being done since at least 2018. The language is stable and the language/core foundation is not changing anymore.

https://www.youtube.com/watch?v=suOzNeMJXl0

Truly outsanding work and stewardship.

TomBers•18h ago
Completely agree. I feel no pressure to constantly upgrade my Elixir versions. I just look at the changes and there is often useful features that make me want to upgrade, as opposed the feeling of dread when I am pushed to upgrade.
burnt-resistor•16h ago
Elixir still seems kind of rough and missing creature comforts, needs stabilization and guides to accomplish goals. There's a lot of broken/under-maintained packages and unhelpful guides that don't work because there's so much Phoenix ecosystem churn. It could get better but all the things™ need curation and approachable documentation. Not everyone wants LiveViews or to use their component system, and the learning curve for compatibility with other tools and technologies is still way too steep.

Python 3 was really, really needed to fix things in 2. Hence 2 became 3. They managed it pretty well, vaguely similar to Go, with automated update tools and compatibility-ish layers. It had its speed bumps and breakages as not everything went smoothly.

OTOH: Ruby 3 went the wrong way with types separate files and fragmentation of tools. And that's not mention having to opt-in with boilerplate to change how String literals work. Or: gem signing exists but is optional, not centrally-managed, and little-used. Or: Ruby Central people effectively stole some gems because Shopify said so. PS: many years ago Hiroshi Shibata blocked me from all GH Ruby contributions for asking a clarifying question in an issue for no reason. It seemed agro, unwarranted, and abrupt. So the rubygems repository fragment drama seems like the natural conclusion of unchecked power abuse lacking decorum and fairness, so I don't bother with Ruby much these days because Rust, TS, and more exist. When any individual or group believe they're better than everyone else, conflict is almost certainly inevitable. No matter how "good" a platform is, bad governance with unchecked conduct will torpedo it. PSA: Seek curious, cooperative, and professional folks with mature conflict-resolution skills.

It's a good idea™ to think deeply and carefully and experiment with language tool design in the real world before inflicting permanent, terrible choices rather than net better but temporarily-painful ones. PSA: Please be honest, thoughtful, clear, and communicate changes in advance so they can be avoided or minimized to inflict least net pain for all users for all time.

Honestly, I hope more development goes into making Phoenix/Elixir/OTP easier, more complete, more expressive, more productive, more testable, and more performant to the point that it's a safe and usable choice for students, hobbyists, startups, megacorps, and anyone else doing web, non-web, big data, and/or AI stuff.

Plug for https://livebook.dev, an app that brings Elixir workbooks to a desktop near you. And https://exercism.org/tracks/elixir

_susanoo•14h ago
> PSA: Please be honest, thoughtful, clear, and communicate changes in advance so they can be avoided or minimized to inflict least net pain for all users for all time.

> Honestly, I hope more development goes into making Phoenix/Elixir/OTP easier, more complete, more expressive, more productive, more testable, and more performant to the point that it's a safe and usable choice for students, hobbyists, startups, megacorps, and anyone else doing web, non-web, big data, and/or AI stuff.

Seriously, this has been the case all the time. It's a great fit for AI, web (Phoenix), non-web (Nerves), students (Pragstudio), hobbyists (hi), megacorps (Discord, bleachereport).

What do you mean it's not testable, productive, expressive enough? Do you mean the entire elixir community is just fiddling about with unsafe software?

This comment seems just like a giant ragebait.

bmitc•14h ago
The Phoenix churn is definitely real. It's so much so that I've never gotten into it. It's also extremely macro heavy, and so it's its own DSL or collection of DSLs. A concrete example of the churn is that the LiveView book has been "about to release" for five years now.

Although, what parts of Elixir itself are rough or missing creature comforts? I generally feel it's stable and fine, but I admittedly haven't written Elixir code in a couple of years, sadly.

giraffe_lady•12h ago
> It's also extremely macro heavy, and so it's its own DSL or collection of DSLs.

I mean this describes every full stack web framework right? Like sure if the underlying language doesn't have macros or macro-like tools that limits how perverted the syntax can get but the line between "DSL" and "API" gets really blurry in all of these massive frameworks.

bmitc•11h ago
That's true for languages that have macros. I just don't like macros, as they get over-abused in every language that has them. I'd much rather deal with just boilerplate and tedious syntax but still straightforward and completely in the language over macros, for the most part. Some macros are indeed useful, like in Rust with `println`, but they still get thrown everywhere.
giraffe_lady•10h ago
Frameworks in langauges that don't use macros have this problem too that's what I was getting at with the DSL vs API thing. I don't want to litigate the worthiness of macros for a given purpose here. But if you don't use them for this you have to use something for this the problem doesn't go away.

Wherever rails or phoenix has macro-defined syntax to handle a specific task, laravel or whatever will have a collection of related functions that need to be used in very specific ways to accomplish the same thing. Whether this collection is a "class" with an "api" or whether it is a "language" defined around this "domain" you will have the abstraction and the complexity.

Having a preference for one approach of managing this abstraction & complexity seems fine but "a collection of DSLs" is pretty much what a web framework is so that can't be the problem here.

bmitc•4h ago
> Frameworks in langauges that don't use macros have this problem too that's what I was getting at with the DSL vs API thing.

You mean in the sense that the language's built-in syntax and available abstractions get abused so much that it approximates a DSL?

zdragnar•2h ago
It really depends on how good your inspecting tools are. Using runtime methods and functions instead of macros mean the code is all right there, and what you're debugging is what you see in your editor (setting aside silly things like reflection shenanigans).

With macros, even language servers may need customization if they introduce new syntax. The code that runs doesn't exist until it runs, so you can't see it ahead of time.

This doesn't sound like too big a problem if you're familiar with the tooling already, but trying to figure out where some random method comes from in a rails code base when you're new to Ruby is somewhere between a nightmare and impossible without debugging and using the repl to tell you where the source is.

React has a JSX macro, and I love using it, so there's definitely room for them. There is a world of difference in developer experience when macros are used versus when not, however, and it is wrong to say that it is all the same.

josevalim•6h ago
LiveView was still before v1.0, hence the churn, but Phoenix itself did not introduce breaking changes since v1.0, released more than a decade ago. Our skeleton for new applications change, as best practices around web apps are still evolving, but it is completely up to you to migrate. As a reference point, most other web frameworks have gone through several major versions in the same time, changing how new apps are built but also breaking old ones.

The idea that Phoenix is also mostly macros does not hold in practice. Last time this came up, I believe less than 5% of Phoenix' public API turned out to be macros. You get this impression because the initial skeleton it generates has the endpoint and the router, which are macro heavy, but once you start writing the actual application logic, your context, your controllers, and templates are all regular functions.

ch4s3•2h ago
“It’s all regular functions” should be on our collective bumper sticker.
dnautics•7m ago
> The idea that Phoenix is also mostly macros does not hold in practice

no, but the Framework does push you into using them. A good example is the `use MyAppWeb` pattern. That's a macro that nests other macros. the good news is that you can pretty much excise that and everything works fine, and LLMs have no problem even! (i think they slightly prefer it)

a few cognitive pain points with phoenix macros:

plug: (love it dearly) but a bit confusing that it creates a conn variable out of whole cloth. a minor complaint. worth it, otherwise.

phoenix.router: is a plug but isnt quite a plug.

anyways that's it! the rest is ~fabulous. i think to find a framework where you have two minor complaints is a blessing. remember how activerecord automagically pluralized tables for you?

dmix•5h ago
Our transition to Ruby 3 was very smooth. The actual PR was pretty tiny considering how big our project was. Nothing like the crap I dealt with in JS framework upgrades for much smaller projects. Even Rails is pretty easy to upgrade these days, both are very mature.
abrookewood•3h ago
"Python 3 was really, really needed to fix things in 2. Hence 2 became 3. They managed it pretty well".

I don't know how you can say this honestly - it was turbulent and fraught with trouble and angst. It most certainly was NOT handled well.

atonse•13h ago
Yea each time I’ve upgraded (been using elixir in production since 2017), it’s gone way smoother than I had anticipated.

I usually find the Erlang/OTP upgrades to be a bit more problematic compatibility-wise.

So I’m often in the latest elixir but one Erlang/OTP version behind cuz I wait a few months for all the kinks to be worked out.

bryanlarsen•5h ago
> So many examples of programming languages have huge breaking changes between versions

I can only think of 2: python 3 and perl 6.

Those two were very traumatic so it's not surprising it feels like more.

dgfitz•5h ago
C++11 fucking with strings also comes to mind.
laszlokorte•4h ago
php
chillfox•3h ago
Ruby 1.8.7 -> 1.9.0 caused a lot of problems in the sysadmin space that took years to get resolved.
tyre•3h ago
triggered.

There was a rails upgrade around that time that was similarly painful, at least in the humongous rails app I was working in.

jen20•2h ago
Although it was somewhat optional, adding async to Rust had a similar feel. Also various Swift versions had source breaking changes back in the day.
jameslars•2h ago
Java 8 -> anything 11+ wasn't great at scale. It's been smooth sailing for a long time again though.
ffsm8•2h ago
Uh, wasn't the only breaking change a rename/changed path in some standard lib path?
isodev•1h ago
Swift! Multiple times introduced fundamental changes that were not only breaking but required semantic rewrites of code. The most recent breakage being Swift’s latest version adding concurrency features.
agrounds•1h ago
Scala 3 has failed to be widely adopted, and now the language as a whole is more or less dead. Not that that’s due to the 2-to-3 transition entirely.
throwawaymaths•17m ago
ruby 1.8 -> 2 was miserable, especially as the linux distros kept 1.8 and gems started requiring 2.
asa400•11h ago
Just a data point on the deps compilation, on a small Phoenix app with mostly stock Phoenix deps:

  MIX_OS_DEPS_COMPILE_PARTITION_COUNT=1 mix deps.compile  32.30s user 7.23s system 320% cpu 12.336 total

  MIX_OS_DEPS_COMPILE_PARTITION_COUNT=5 mix deps.compile  0.37s user 0.49s system 12% cpu 6.970 total

  MIX_OS_DEPS_COMPILE_PARTITION_COUNT=10 mix deps.compile  0.38s user 0.50s system 12% cpu 7.236 total
Machine is a Mac M1 Max, `rm -rf _build` in between each run.
asa400•5h ago
Anyone downvoting care to comment on why a benchmark of a feature in this release is downvote worthy?
BAPHOMETA88F•5h ago
Application specific type inference to compile ad hoc reporting using Elixir's Standard Library

dynamic() > boolean()

integer() > boolean()

mcdeltat•5h ago
Elixir just keeps chugging along steadily releasing great features and improvements. It's an astoundingly well designed language and the creators have a solid approach to its development. It's a shame I don't get to use Elixir day to day.
recroad•4h ago
I quit my job and started a company just so I can use Elixir.
behnamoh•5h ago
Elixir is still confusing, not the language, but the ecosystem, tooling, and philosophy. Is it dynamic or static? Is it compiled or not? If it's not, then why do we have Elixir scripts, which have different file extension? If it uses BEAM and you'd inevitably need to know Erlang when you hit the edge cases, then why not just learn Erlang? If it solves concurrency the "right way" due to supervision trees, why not use Python libraries that also implement the actor model, making Python code concurrent the "right way"? I just don't know which niche applications Elixir targets and excels at.
radiospiel•5h ago
> If it solves concurrency the "right way" due to supervision trees, why not use Python libraries that also implement the actor model, making Python code concurrent the "right way"?

I can't speak too much about Python – but immutable vars is a core prerequisite for many of the features OTP (the platform underpinning Elixir (and Erlang)).

stanmancan•4h ago
I don’t understand why people drink orange soda. If you want something orange flavoured, eat an orange! If you want something bubbly, drink soda water!

.ex compiles to beam files to be run later

.exs compiles to memory

You don’t need to know Erlang to use Elixir; I’m a few years in now and I’ve never had to write any Erlang.

innocentoldguy•3h ago
Python has a GIL and is mutable, which makes concurrency impossible and error-prone, respectively. Elixir doesn't have a GIL and is immutable.
15155•2h ago
Python allows for memory sharing between threads - which is why a GIL is necessary.

A high-level language with a strict shared-nothing concurrency model doesn't need a GIL... but you naturally can't practically share very large objects between BEAM processes.

icedchai•1h ago
If you couldn’t share memory between threads, they’d be called something else. Many languages have threading without a GIL.
distantprovince•2h ago
these are all surprisingly specific questions that can actually be answered!

1. It's dynamic 2. It's compiled 3. Elixir script is just a file with Elixir code that compiles and runs right away 4. I've been writing Elixir for 7 years and barely know any Erlang. I even submitted bugs to OTP team with reproductions in Elixir, they're chill. 5. Preemptive scheduler, immutable data

ch4s3•1h ago
Yeah I’ve been doing elixir professionally for maybe 10 years and have barely written any Erlang, maybe a dozen lines.
Blackarea•5h ago
I really came to love gleam over the last few months. I appreciate elixir getting a type system and remember that this was the big NoGo for me when I explored it a while back. I'd like to give it another chance some time, but I'm worried that it's like typescript - looks typed on the outside but for many libs and packages the types are just a dynamic/any. Is my fear justified? Beam is amazing btw
innocentoldguy•3h ago
Gleam doesn't give you access to the full amazingness of OTP and BEAM. Elixir does.
abrookewood•3h ago
Why? Don't they all compile down to the same AST? How does Gleam prevent the use of OTP? Honest question - not overly familiar with Gleam
benzible•2h ago
They both ultimately produce BEAM bytecode, but Gleam compiles to Erlang source first (then through the Erlang compiler), while Elixir compiles to Erlang's abstract format. Gleam doesn't prevent OTP use - it has type-safe OTP bindings, but they're less mature/feature-complete than Elixir's, plus Elixir has better BEAM runtime integration (stack traces, profiling tools, etc).
Blackarea•29m ago
Profiling tools are something that I miss a bit in gleam - yes, but otherwise I had no problems with OTP bindings. The maturity of the ecosystem is a bit lower of course. But I actually enjoy finding libraries or repos with a few hundred lines. You gotta handroll some things but that's what I am here for. ffi to erlang and js for fullstack apps is as straight forward as it gets, but erlang syntax is indeed a bit crazy. For those interested in gleam but don't want to miss some necessities: https://github.com/gleam-lang/awesome-gleam (the gleam community is super nice btw).

For me some serious elixir adventure is high up in my todo list. But I remain suspicious if I can ever fully enjoy myself with a dynamic language - I think gleam and elixir do cater to different crowds. Gleam is pure minimalism (just pattern matching really), but elixir doesn't seem bloated either.

I am so happy that both languages exist and give alternatives in times of hundreds of node deps for any basic slob webapp.

cies•2h ago
Yeah Gleam. Or Kotlin on the JVM is also quite similar and has compile-to-JS if needed.
cies•2h ago
I don't program in Elixir, but I'm a fan.

I was a fan of Ruby -- because of it's pragmatism and subjective beauty -- but then I got into type systems.

Elixir now also has a type system and, so does Ruby...

Though I know program in Kotlin, which syntax-wise is very much a "typed Ruby".

ch4s3•1h ago
Kotlin is almost the jruby we always wanted.
moomoo11•1h ago
I’m currently using soketi to broadcast events using a pusher sdk on my api services.

My app is a mix of real time and rest endpoints, and there’s no heavy computation and even if there was I could just call do that one off in Go or something.

Would Phoenix make sense for me? I have some cool collaborative features in the works.