linkdd

5 दिन पहलेdiscuss

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: [email protected]

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.

linkdd

पिछला माहdiscuss

[flagged]

linkdd

पिछला माहdiscuss

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.

linkdd

4 माह पहलेdiscuss

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).

linkdd

4 माह पहलेdiscuss

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 ).

linkdd

4 माह पहलेdiscuss

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

linkdd

4 माह पहलेdiscuss

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).

linkdd

5 माह पहलेdiscuss

Why YAML ? :(

linkdd

6 माह पहलेdiscuss

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.

linkdd

6 माह पहलेdiscuss

> 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".

linkdd

8 माह पहलेdiscuss

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

linkdd

10 माह पहलेdiscuss

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

How? With a unikernel?

linkdd

3 वर्ष पहलेdiscuss

In the real world, there are no "good guys vs bad guys", no "white/black", it's all shades of grey, recognizing this is not "victim blaming".

But let's avoid flamewars irrelevant to the discussion.

linkdd

3 वर्ष पहलेdiscuss

> If a dev releases his work free-as-in-libre and/or free-as-in-beer, they don't get to complain if the donations are "insufficient".

Of course they get to complain. Complaining and doing nothing to change the situation is what's problematic.

Doing work without reward, even if you did not expect any in the first place, can be soul-sucking, and it is totally normal to complain about it.

You don't do FOSS for the recognition/glory, but complaining about the hatred, hypocrisy, and complete lack of respect of the industry towards FOSS is normal.

The backlash he got after he "dared" ask for help was completely uncalled for. I'd even say this, it's the user who does not get to complain, let's remind everyone of what most FOSS licenses include:

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.

You get a message during `npm install` from the dev asking for funding and a job? Tough shit, you don't get to complain because you're not paying him.

linkdd

5 वर्ष पहलेdiscuss

This reminds me of cgit[1], but the UI seems even simpler.

[1] - https://git.zx2c4.com/cgit/about/

linkdd

6 वर्ष पहलेdiscuss

From my experience, `autoreconf -i` is responsible for generating the configure script from a configure.ac file, so I assumed some platform-specific logic was happening.

I always wrapped it up in a autogen.sh script that I did commit. Also, end users generally prefer prebuilt binaries, if one wants to compile the software themselves, I expect him to have autotools installed, and mention it as a requirement in the README.

linkdd

6 वर्ष पहलेdiscuss

I never managed to get CMake to work out-of-the box on Windows.

I always end up vendoring the dependencies, because it's too tedious to find the correct installed libraries in a cross-platform way.

autotools are great, but at the same time it's a monstrosity, and easy to misuse (you should never commit the configure script, because it's the autotools that are supposed to generate it according to the platform it's running on).

For C++ dev, I did take a look at buck[1], but it doesn't really support Windows platforms.

I wish we had something like cargo (IMHO, the tooling is one of the top reasons of Rust's success), in the meantime simple Makefiles do the job perfectly.

1 - https://buck.build/

Submissions

Ccl: Categorical Configuration Language

A framework for systematically addressing undefined behavior in the C++ Standard [pdf]

Show HN: Vibecoded local Azure emulator inspired by LocalStack and localgcp

FlowG v0.59.0 with Dark Mode support

Localgcp: LocalStack for GCP, emulating 14 Google Cloud services locally

Floci: Light, fluffy, and always free – The AWS Local Emulator alternative

VRL Log Splitting – FlowG v0.55.0

FlowG – Road to 1.0

Blessed.rs – Recommended Crate Directory

[untitled]

[untitled]

SDL_mixer 3.2.0 (stable) is out

MuJS: Lightweight JavaScript interpreter for embedding in other software

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

JIT: A header-only, cross-platform JIT compiler library in C

Simulating fusion reactors in C++ [video]

Goto Considered Awesome [video]

Avoiding Modern C++ – Anton Mikhailov [video]

OSMC 2025 – Easy logging refinement with FlowG [video]

CG/SQL – SQL dialect compiler to C for sqlite3 mimicking stored procedures

comments