lgreiv's comments

Slightly different approach, but appears to have the same overarching goals: https://github.com/bullet-train-co/magic_test

„Magic Test allows you to write Rails system tests interactively through a combination of trial-and-error in a debugger session and also just simple clicking around in the application being tested, all without the slowness of constantly restarting the testing environment.“

I will keep an eye on both now, probably they will compliment each other at some point in time.

Since trying it on a dev conference in Amsterdam, I am severely hooked on Tony‘s Chocolonely, which usually rates quite high in labor protection reviews [1] and has started to introduce traceability for the supply chains of its various ingredients. It also tastes unbelievably good.

[1] https://www.chocolatescorecard.com/

A relevant (WIP) standard in this context could become 802.11bf „WiFi Sensing“ [1]. If plenty of common consumer devices will support it (maybe even some with an on-board camera), it may become hard to avoid.

[1] https://standards.ieee.org/beyond-standards/ieee-802-11bf-ai...

You should be able to organize accounts hierarchically using AWS Organizations, which allows to have cost centers and centralized billing (and some imposed policies over all accounts).

Very handy tool for sure. I really appreciate the efforts you made on in-line, repo and website documentation.

It’s a bit of legwork, but it’s there.

https://github.com/amberframework/docs/blob/master/examples/...

Nim really looks awesome too! If I came from a python background, I could see me reaching for Nim rather than Crystal.

While it may be possible to onboard Ruby developers fairly easy, it is still easier to find talent for an „established“ language. For my personal projects, I gladly use Crystal, but in my professional role as a technical decision maker I need to factor aspects like this in.

I wish Crystal would take off. It has so many things going for it (many of them mentioned in the article): performance, useful tooling such as an opinionated formatter, an integrated RSpec-like test framework, a powerful standard library, an awesome type system that gets out of the way most of the time, a familiar syntax.

So far I have been building some smaller personal CLI tools and a few web apps (with the Lucky framework). I’ve also tinkered with running it in AWS lambda functions in a custom (albeit unfinished) runtime.

Coming from a decade of Ruby, due to the similar syntax and mindset Crystal is my go to for cases where I need performance or runtime-less execution (e.g. in containers from scratch that contain only the binary and dependencies, if needed).

Crystal's standard library provided enough functionality for me in the past to get away with only few dependencies per project, which is great for supply chain security and complexity. Some of it's highlights are:

  - an ergonomic HTTP::Server and client
  - OAuth / OAuth2 clients with token refresh
  - JSON/YAML/XML parsing/generation/mapping
  - JSON/YAML mapping to classes
  - native templating similar to ERB

I have some bad news for you. They are not updating their browser integrations for <= v7 and the newer ones will not work with local vaults. De facto, they are already deprecating standalone licenses/local vaults.

Thank you for the suggestion, I’ll check it out.

This is my stance as well. I have not chosen a successor yet, but I’ll have a look at Bitwarden, Keepass and the recently released Proton Pass.

Trusting Dropbox for sync (which I did) meant trusting a cloud service, too, but IMO it is a less lucrative target for hacks than a server that stores _nothing but_ credentials. Also, using DB made me less dependent on connectivity (LAN sync) and would let me switch providers quite easily.

I was just listing the goals I gave it in temporal order, but I’ll include a weak task for the giggles in the future when talking about the POC. Good suggestion!

I've built a proof of concept myself in Ruby, an agent that extends itself with new abilities at runtime based on code suggestions from ChatGPT until it deems itself capable of fulfilling an arbitrary task given in natural language. It then persists that „specialized“ version of the task was completed successfully.

So far it was able to add an API to fetch me the local weather, return the capital of Venezuela, control brightness and volume of my MacBook and replicate itself at random locations (but tell me where, after).

That being said, I added multiple human-in-the-loop points in the assess/suggest/patch/execute cycle and (given the nature of LLMs) would never use it outside of a sandbox without these safety rails.

History really rhymes. This is another step in Replit reproducing the path of Heroku (which is a good thing to say IMO).

A next generation of IaaS with great DevX would be a relief to everyone burnt by AWS‘s complexity overhead (for a great bunch of customer’s needs).

I have seen several variations that I found consistent with the metaphor of a switch.

Broadly, these could be divided in implementations that offered a loading state (switch goes transparent until persisted, overlaid spinner etc.) and implementations that flicked the switch back when the request failed and provided a very noticeable status update (hint, animation, growl).

My preference for systems that work with unreliable persistence is the former, albeit that is purely personal and not founded in a deeper rationale.

Exactly this is it.

It is the metaphors that they apply, a toggle mimics a switch (e.g. a light switch) while a checkbox mimics it’s own paper counterpart.

To me, the semantic difference between the two is that I expect a toggle to cause an immediate effect whereas a checkbox merely holds the value to be applied later.

Applied to a client/server web application, I would expect a toggle to immediately cause a request to the backend. I’d expect a checkbox to be used in a form which is sent as a whole on submit.

It should be consistent in its use of idioms in order to reduce the number of lookups required. Still, it should be documented extraordinarily well, because it then can serve as an on-ramp to best practices for novices. Further, it should be tailored to the intended use case of the language to stay lean but usable to carry an application as far as possible without needing a heap of dependencies.

I appreciate these qualities in the standard library of Crystal [1], to name an example.

[1] https://crystal-lang.org/api/1.7.0/