lknuth

Static analyzers like https://github.com/zizmorcore/zizmor can help find such misconfiguration. It is however unfortunate, that such footguns aren't harder to fire.

Making it solely about the extraction of dollars is a great recipe to make something mediocre. See Hollywood or Microslop.

Its like min-maxing a Diablo build where you want the quality of the product to be _just_ above the "acceptable" threshold but no higher because that's wasting money. Then, you're free to use all remaining points to spec into revenue.

It looks interesting but no source availability is a red flag for me.

Best performing by what metric? There aren't meaningful ways to measure engineer "performance" that makes them comparable as far as I know.

I think its cool that more people are building what I call "calm tech". More technology should try to serve a purpose quickly and then get out of the way instead of trying to artificially stay on your screen as long as possible.

Incidentally, I built my own calm RSS reader some time ago that has many similar ideas to yours: https://github.com/lukasknuth/briefly

I habe a "Pocketbook Verse Pro" that runs Linux. No need to root, you can copy ARM executables to the SD card and run them (that's how I use Syncthing on it). KOReader also works on it.

Speaking of passkeys, could they be used to authenticate to a local application - say for unlocking a password vault (perhaps through a Yubikey)?

I built my own reader because I didn't want unread items to accumulate. It just shows what was published the last X days.

The result is that there is no need for persistent storage, so its real easy to host. If you're interested, its here: https://github.com/lukasknuth/briefly

I appreciate that you document how the ranking works below the list. Thank you.

Elixir has OpenTelemetry bindings which integrate into most of these platforms. At work, we use DataDog.

True. There is inter-op with both Elixir and Erlang, but thsts like early TypeScript.

If you're at all interested, I'd suggest doing the basic and OTP tutorials on the Elixir Website. Takes about two hours. Seeing what's included and how it works is probably the strongest sails pitch.

I wonder why though. Aren't both of these things facts? I think you can justify using them anyways - which is what I'd be interested to talk about.

We look at K8s more like "the Cloud Operating System". Many of its capabilities are more valuable for other runtimes, but that doesn't mean that Elixir is a bad fit with it.

For example, the Erlang VM clustering can make use of K8s for Service Discovery. You can do ephemeral containers and use readiness probes to create a " hand over" period where new instances can sync their data from old, about-to-be-replaced instances.

It is alleviated quite a bit bz its pattern matching capabilities combined with the "let it crash" ethos.

They have a success typing system (which isn't very good) and are working on a fuller system (which isn't very mature).

If typing is the only thing keeping you out, have a look at Gleam.

Having worked with Elixir professionally for the last six years now, it is a very mature platform, very performant and offers many things that are hard in other languages right out of the box.

Do you disagree with the statement?

I found the config a lot nicer. It was very easy to custimze to my (very minimal) liking. The config is easily readable. And its portable to any supported shell.

Most shells can probably do everything this can as well and if you're already familiar with the archaic syntax there is probably limited use for you.

For an idea, here is my current config https://github.com/LukasKnuth/dotfiles/blob/main/zsh/.config...

Agreed, you can replace them easily: https://github.com/LukasKnuth/dotfiles/blob/main/zsh/.config...

I see where you're coming from with that take and I don't necessarily disagree - if these models where owned by "the people".

With the situation as it is right now, you're only contributing to some tech oligarchs ability to sell tokens to people.

I chose to put work into my writing and make it freely available on the internet. This isn't the same.

I habe a virtual layer on my keyboard that contains all symbols I need regularly. Holding down a specific key (that is simple to reach) toggles the layer - like the normal Shift key.

If you have or can make the time, some side projects can go a long way. Mainly to find out what you are actually interested in. I usually give myself some guard rails as to not spend too much time one one thing (perhaps say a month) and then see where that takes me.

Then, I write about the project for two reasons: I get an article out of it that I can share _and_ I get to digest the project as a whole.

Just pick anything that seems interesting and build something. Later, you can even build on top of earlier projects.

Aren't there more important issues than tossing more money into that particular furnace? Touch some grass man.

Helix if you like working in your terminal.

While I run and love litestream on my own system, I also like that they have a pretty comprehensive guide on how to do something like this manually, via built-in tools: https://litestream.io/alternatives/cron/

Thank you! Your work is keeping the web open.

How about a CSV import? My banks all have an option to export transactions to a CSV file. You would need an import tool to create the mapping though.

True, but your example is very targeted at a specific page. With local storage, you can have a simple short function that works everywhere and just sends everything back to your server. No need to specialize, works everywhere.

To expand on the "not as secure" comment: local storage is accessible to every JS that runs in the context of the page. This includes anything loaded into the page via <script src=""/> like tracking or cookie consent services.

Elixir and Phoenix/Ecto is much superior to Rails IMO.

My main gripe with Rails are conventions everywhere which aren't documented clearly. You just have to know them/learn them over time/from guides. It makes refactoring really hard, too.

Having your Framework generate the Docs is nice, but doesn't always fit.

At work, I build backends for mobile applications. When designing new APIs to be consumed by apps, we want input from the mobile developers. We facilitate this by having an api-specs repo with TSP and using Pull Requests to discuss, track and finally commit on new APIs.

It also allows mobile developers to open PRs with changes they want. The contracts are basically an interface that both sides can discuss and agree on.

Many. We used the NodeJS Version of it, which has pretty poor error handling. When it breaks, it breaks hard (runtime errors with no message or stack trace)

Security. You can not deactivate certain unsave mechanisms. For example, if you send it an ID token, it will not verify the aid claim, allowing Anny valid token from the same SSO provider.

API stability. We're consuming their API from a mobile app. But every major version (about five a year) changed the REST API without backward compatibility or versioning. Its fine if you use their lib and keep parity, but that's really only possible on the web.

All of this was with their self hosted offering, I haven't tried their hosted one.