Hacker News Reader

linkddon Show HN: Sphinx – A hook that quizzes you on your AI's code before shipping

Your slop generator should check if a name exist before claiming it.

linkddon GitHub Actions leaking secrets when Miri output is cached

    The Rust Security Response Team was notified that Miri stores all environment variables to target/,
    allowing secrets to persist in caches.

Then proceed to blame Github Actions.

All CI platform that provide caching and would naturally cache the build folder that is target/ would have this security hole. The culprit is cargo miri, not Github Actions.

linkddon Ask HN: Who wants to be hired? (September 2026)

  Location: Lille, France
  Remote: yes
  Willing to relocate: no
  Technologies:
    - Devops: Kubernetes, Docker, Ansible, Terraform, Netbox, GCP, AWS, ...
    - Backend: Python (Django, FastAPI, ...), Go, Rust, C, C++, Elixir
    - Frontend: TypeScript (React, Vue), HTMX
    - Databases: PostgreSQL, MongoDB, FoundationDB
    - MQ: RabbitMQ, Kafka, Amazon SQS
    - Monitoring: Prometheus, Grafana, Nagios/Icinga, Zabbix, FlowG, Splunk, Datadog
    - CICD: Jenkins, Github Actions, Gitlab CI, ...
  CV: https://linkdd.github.io
  LinkedIn: https://linkedin.com/in/linkdd
  Email: david.jose.delassus@gmail.com

10+ years of experience as a Software Engineer and DevOps engineer, 20+ years as a hobbyist.

I'm passionate by big challenges and available immediately.

linkddon Ask HN: Who wants to be hired? (August 2026)

  Location: Lille, France
  Remote: yes
  Willing to relocate: no
  Technologies:
    - Devops: Kubernetes, Docker, Ansible, Terraform, Netbox, GCP, AWS, ...
    - Backend: Python (Django, FastAPI, ...), Go, Rust, C, C++, Elixir
    - Frontend: TypeScript (React, Vue), HTMX
    - Databases: PostgreSQL, MongoDB, FoundationDB
    - MQ: RabbitMQ, Kafka, Amazon SQS
    - Monitoring: Prometheus, Grafana, Nagios/Icinga, Zabbix, FlowG, Splunk, Datadog
    - CICD: Jenkins, Github Actions, Gitlab CI, ...
  CV: https://linkdd.github.io
  Email: david.jose.delassus@gmail.com

10+ years of experience as a Software Engineer and DevOps engineer, 20+ years as a hobbyist.

I'm passionate by big challenges and available immediately.

linkddon Ask HN: Who wants to be hired? (July 2026)

Location: France

Remote: Full Remote only

Willing to relocate: No

Technologies:

  - Development: Python, Javascript/Typescript, Go, C, C++, ...
  - Automation: Ansible, Terraform, Gitlab CI, Github Actions, ...
  - System: Linux, FreeBSD, Docker, Kubernetes, ...
  - Cloud: GCP, AWS, Azure, OVH, DigitalOcean, ...

CV: https://linkdd.github.io

Email: david.jose.delassus+hn@gmail.com

Software Engineer and System Operator, self-taught, with 10+ years of experience professionally, and near 20 as a hobby.

Looking for remote freelance missions in development, or devops.

linkddon Ask HN: How do you feel about posts about GenAI taking over the HN front page?

I do apprehend this kind of ideas. It would make it easier for models to be trained to bypass that filter, making it even harder for humans to detect slop.

linkddon Building a Procedural Hex Map with Wave Function Collapse

This is not Wave Function Collapse. This is a constraint solver.

The goal of the original algorithm ( https://github.com/mxgmn/WaveFunctionCollapse ) is to infer the constraints from a sample, and then run a constraint solver.

Hard-coding the constraints skips the whole point of the algorithm (which is also badly named by the way).

linkddon An Interactive Intro to CRDTs (2023)

Last-Write-Win CRDTs are nice, but I wish the article talked about where CRDT really shine, which is when the state truly converge in a non-destructive way, for example:

1) Counters

While not really useful, they demonstrate this well:

  - mutations are +n and -n
  - their order do not matter
  - converging the state is a matter of applying the operations of remote peers locally

2) Append-only data structures

Useful for accounting, or replication of time-series/logs with no master/slave relationship between nodes (where writes would be accepted only on a "master" node).

  - the only mutation is "append"
  - converging the state is applying the peers operations then sorting by timestamp

EDIT: add more

3) Multi Value registers (and maps)

Similar to Last-Write-Win registers (and maps), but all writes are kept, the value becomes a set of concurrent values.

4) Many more...

Each is useful for specific use cases. And since not everybody is making collaborative tools, but many are working on distributed systems, I think it's worth it to mention this.

On another note, the article talks about state based CRDTs, where you need to share the whole state. In the examples I gave above, they are operation based CRDTs, where you need to share the operations done on the state and recompute it when needed.

For example, in the Elixir ecosystem, we have Horde ( https://hexdocs.pm/horde/readme.html ) which allows distributing a worker pool over multiple nodes, it's backed by DeltaCrdt ( https://hexdocs.pm/delta_crdt/DeltaCrdt.html ).

Delta-CRDTs are an optimization over state based CRDTs where you share state diffs instead of the whole state (described in this paper: https://arxiv.org/pdf/1603.01529 ).

linkddon Process-Based Concurrency: Why Beam and OTP Keep Being Right

You would have a process handling the calls to the postgres.

That process has as local state the database connection and receive messages that are translated to SQL queries, here 2 scenarios are possible:

1) The query is invalid (you are trying to inert a row with a missing foreign key, or wrong data type). In that case, you send the error back to the caller.

2) There is a network problem between your application and the database (might be temporary).

You just let the process crash (local state is lost), the supervisor restarts it, the restarted process tries to connect back to the database (new local state). If it still fails it will crash again and the supervisor might decide to notify other parts of the application of the problem. If the network issue was temporary, the restart succeeds.

Before crashing, you notified the caller that there was a problem and he should retry.

Now, for the caller. You could start a transient process in a dynamic supervisor for every query. That would handle the retry mechanism. The "querier process" would quit only on success and send the result back as a message. When receiving an error, it would crash and then be restarted by the supervisor for the retry.

There are plenty of other solutions, and in Elixir you have "ecto" that handles all of this for you. "ecto" is not an ORM, but rather a data-mapper: https://github.com/elixir-ecto/ecto

linkddon Show HN: Peekl – A modern alternative to Ansible and Puppet

YAML is actually tricky, especially with multiline strings and space handling.

I do find HCL to be simpler. But for things like Ansible, I'd rather have a real programming language, like PyInfra does (which I never got to try yet unfortunately).

linkddon Show HN: Peekl – A modern alternative to Ansible and Puppet

Why YAML ? :(

linkddon MIT Non-AI License

You can't say you love opensource and be mad that users are using the freedom you granted.

OpenSource projects are not becoming free training material for AI, AI companies are using a freedom OpenSource projects granted.

The claim that AI can build far superior software is dubious and I don't believe it one second. And even if it were true, that does not change anything.

With or without AI, permissive licenses (MIT, BSD, ISC, ...) always allowed the code to be used and redistributed in non opensource software. If you don't want that, use the GPL or a derive. If you don't believe that the GPL would be enforceable on the derivative works produced by AI, don't release your code as opensource.

OpenSource is essentially an ideology, that software should be free of use, and transparent, and freely shareable, without restriction. If you don't buy into that ideology, it's fine, but don't claim to love OpenSource when you don't. Just like a person who eats fish should not claim to be vegan.

AI will not be the end of OpenSource, firstly because it's a dead-end technology, it has already peaked years ago and is becoming worse with each new model. It does not have the ability to build complex software beyond a CRUD app (would you use a kernel that was entirely vibecoded? would you trust it the way you trust the Linux kernel?). Secondly, because OpenSource does not discriminate who gets to enjoy the freedom you granted.

You decided to "work for free" when you decided to distribute as OpenSource. If you don't want to work for free, maybe OpenSource is not for you.

linkddon MIT Non-AI License

> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software

Key words are:

  - permission is [...] granted
  - free of charge
  - without restriction
  - use, copy, …

Then:

> may not be used for the purposes of […]

The license contradicts itself.

> Don't we have to ask for permission before feeding someone's years of work into an AI?

That's the point of an OpenSource license, to give permission.

This kind of stuff makes me think very few people really understand what OpenSource is about. The very same people who will fallback to licenses such as the BSL as soon as people/companies will use the permissions that they gave, and then will complain that "no one wants to pay for the thing i did for free and nobody asked for".

linkddon Show HN: OctoDNS, Tools for managing DNS across multiple providers

What I like about OctoDNS is its integration with the NetBox DNS plugin.

linkddon Show HN: WeUseElixir - Elixir project directory

> It's even possible to run BEAM on bare metal, (almost?) entirely in place of the normal OS.

How? With a unikernel?

linkddon FlowG – Distributed Systems without raft (part 2)

Gotcha, thank you for the clarification.

I'd add though, that the "one leader" thing was not the only reason why I ditched Raft. The Go library hashicorp/raft was quite complex to use, and I've had a lot of situations where the cluster failed to elect a leader, and ending up with a corrupted state.

This might be a PEBKAC issue of course.

linkddon FlowG – Distributed Systems without raft (part 2)

Emphasis on "one per partition", which if I understand correctly as "network partition", means that in the absence of network partition, there is one leader.

I do have only a surface understanding of Raft, and I'm learning while doing yes.

linkddon Ask HN: What are you working on? (March 2025)

https://link-society.github.io/flowg/

It's a log management/processing software, with visual scripting.

Started out of frustration towards OpenObserve and its inability (at the time) to properly/easily refine/categorize logs: we had many VMs, with many Docker containers, with some containers running multiple processes. Parsing the logs and routing them to different storages was crucial to ease debugging/monitoring.

It was initially built in Go + HTMX + React Flow encapsulated in a WebComponent, I then migrated to React (no SSR). It integrates VRL using Rust+CGO.

It is by far easier to use than Logstash and similar tools, and in fact it aims to replace it.

Contributors are welcome :)

linkddon Show HN: FastOpenAPI – automated docs for many Python frameworks

You should take a look at AnyIO, which unifies asyncio and Trio (it can use both event loops as a backend).

Two big deals of Trio and AnyIO are channels (similar to Go's channels), the ability to return data from starting a task in a nursery/task group:

    async def my_consumer(task_status = anyio.TASK_STATUS_IGNORED):
        tx, rx = anyio.create_memory_object_stream()
        task_status.started(tx)

        async for message in rx:
            ...

    async def my_producer(tx):
        await tx.send("hello")
        await tx.send("world")
        await tx.aclose()

    async def main():
        async with anyio.create_task_group() as tg:
            tx = await tg.start(my_consumer)
            tg.start_soon(my_producer, tx)

linkddon Shef

> Shef is a powerful CLI tool for cooking up shell recipes.

I only see a YAML DSL. Where is my "shell"?

linkddon Ask HN: Alternative to VS Code?

I will try IntelliJ then.

Zed isn't available yet on Windows I think (at least, not prebuilt binaries?)

linkddon Ask HN: Alternative to VS Code?

No, not gonna migrate to Linux.

I do work and target Windows for a few other projects.

Also, not trying to start a flamewar, but I've spent too much time tinkering on Linux in the past. There is *always* some hardware compatibility issue, or some missing drivers, and especially with GPUs. Linux works best on a server, or on a VM. At least, that is my experience (and I've been on Linux for more than a decade, be it with either Debian, Archlinux, Gentoo, or Ubuntu).

linkddon Ask HN: Alternative to VS Code?

The ability to autocomplete, and navigate through the code (even my dependencies's code) by the click on a function, the popover showing the documentation/signature of the function i'm going to call. Those are Quality of Life features I'm not ready to give up on.

As said in a sibling comment, I often work on cross-language projects, I don't recall Jetbrains offering a "one size fits all" IDE.

linkddon Ask HN: Alternative to VS Code?

I don't have a lot of extensions actually, my VS Code is pretty much vanilla.

I'm on the latest version (1.97.2).

I can try the other memory settings indeed, but I think the culprit is the builtin file watcher. I've stumbled across some similar issues on Github, open for 5 years without a solution :(

Isn't IntelliJ IDEA for Java/Kotlin? I have a project which is cross-languages: Go+Rust on the backend, Typescript/React on the frontend, Hurl and Python (Robot Framework) for the test suite. And I'd rather not have one IDE per language (which is IIRC what Jetbrains do).

linkddon One year after switching from Java to Go

And it's fine. Why continue using something you don't master?

Yes you could try to master it, but it takes years. If another tool compensates your lack of mastery, why not use it?

linkddon Ask HN: Who else is tired of these web things?

https://how-i-experience-web-today.com/

linkddon Generating an infinite world with the Wave Function Collapse algorithm

The code is not opensource but I've written a few articles about it:

  - Part 1: https://david-delassus.medium.com/procedural-map-generation-in-c-part-1-the-slow-the-bad-and-the-ugly-4445fb15e43a?sk=2ff2c19dc5fe4c706092e83c79c72f56 (perlin noise, then wfc = fail)
  - Part 2: https://david-delassus.medium.com/procedural-map-generation-in-c-part-2-a-new-hope-with-cellular-automata-and-gpt4-6b3b52c6b357?sk=96ab3bb234c28d9f5dc2dca8f2f19f97 (cellular automata, and let's try to use GPT to write the code = GPT is nice, but not perfect I had to refactor the code a lot)
  - My own noise function: https://david-delassus.medium.com/i-made-my-own-noise-function-9e6ce4b95a9c?sk=26c5bdd7687445016216cc0b7cb10fa7

NB: Yes it's on medium, my bad :p The `sk` token in the URL is the friend link to bypass the paywall.

linkddon Generating an infinite world with the Wave Function Collapse algorithm

I was working some time ago on a 4X with an hexagonal map (not only made of hex tiles, but the overall shape was an hexagon rather than a rectangle, no wrap-around).

Using a noise function alone does not let you choose how many landmass you want to generate.

Using "wave function collapse"/constraint solvers is too slow for large maps when the amount of constraints increase (please don't put a mountain in the middle of the ocean, or a snow tile in the middle of a desert). My implementation took almost 8h to generate a single map, and the result was not even good.

In the end, I used a combination of multiple techniques:

  - voronoi to split the map into regions
  - use a noise function to make the regions boundaries a bit more natural
  - fill the map with water tiles, place randomly some island seeds
  - grow the islands from their seeds using a cellular automata
  - to create continents, simply put a lot of island seeds in the same area, to generate a bigger one
  - place mountains or rifts on region boundaries to simulate "tectonic plates"
  - generate a heat map (influenced by position of the north/south poles and equator of the map), a humidity map (influenced by leftover ocean tiles), a height map (which is influenced by the already placed mountains/rifts) using a noise function
  - using the previous heat/humidity/height maps, generate a wind map
  - using the wind map, modify the humidity map (wind carries humidity over the land)

Then, choose randomly some tiles that fit some criteria to place biomes:

  - desert on hot/dry land
  - forest on temperate land
  - swamp on temperate/wet land
  - jungle on hot/wet land
  - ...

Then a bunch of different cellular automata to grow the biomes naturally.

The result was quite nice, but it still wasn't on par to the map gen in Civilization games. I still want to continue this project, but I think in my heart I gave up.

EDIT: Some formatting because i always forget HN does not support markdown lists

linkddon Generating an infinite world with the Wave Function Collapse algorithm

The "wave function collapse" part comes from the original algorithm which inferred the constraints from a sample image : https://github.com/mxgmn/WaveFunctionCollapse

Still a misnomer in my opinion, but I noticed that this part of the algorithm was missing from all the articles that followed (mine included). People are basically implementing sudoku solvers :)

linkddon Misty: A secure distributed actor language

For the record, Elixir has been slowly introducing a set theoretic gradual type system.