indiosmo

Concepts are great for overload sets where previously you needed enable_if gymnastics. Also useful for if constexpr.

If you do template metaprogramming it makes your life a lot easier.

There’s definitely interest in this in finance domains. I’ve done DATERANGE and GiST exclude constraints based solutions for a symbology database for example, where any given ticker might represent different securities at different times without overlap, and relying on functions to keep the dateranges in sync when updating a row.

So basically what WHITOUT OVERLAPS and FOR PORTION OF do.

The system time is also interesting in the context of financial data and backtesting, as companies might republish a statement with corrections, and it would help tracking why the system made a decision at a given time.

This bridges the gap to something like xtdb.

The way I frame this is that LLMs are not replacing the tools, whic are are deterministic. They are replacing the humans, which are themselves non-deterministic, as in your Zuckerberg example.

I usually instruct the agent to use the skills explicitly, e.g. "/writing-tests write the tests for @some-class.cpp"

So the skills are mostly a sort of on-demand AGENTS.md specific to the task.

Another example is I have a `plan-review` skill, so when planning something I add at the end of the prompt something like: "plan the task, .... then launch claude and codex /plan-review agents in parallel and take their findings into account before producing the final plan".

I use this library a lot for scope guards in C++ https://github.com/Neargye/scope_guard, especially for rolling back state on errors, e.g.

In a function that inserts into 4 separate maps, and might fail between each insert, I'll add a scope exit after each insert with the corresponding erase.

Before returning on success, I'll dismiss all the scopes.

I suppose the tradeoff vs RAII in the mutex example is that with the guard you still need to actually call it every time you lock a mutex, so you can still forget it and end up with the unreleased mutex, whereas with RAII that is not possible.

Andrei Alexandrescu comes to mind as someone who does this often. Plenty of talks on youtube.

One recent example of boilerplate for me is I’ve been writing dbt models and I get it to write the schema.yml file for me based on the sql.

It’s basically just a translation, but with dozens of tables, each with dozens of columns it gets tedious pretty fast.

If given other files from the project as context it’s also pretty good at generating the table and column descriptions for documentation, which I would probably just not write at all if doing it by hand.

This resonates with my experience of using LLMs to build tooling.

I have a repo with several libraries where i need error codes to be globally unique, as well as adhere to a set of prefixes attributed to each library. This was enforced by carefully reviewing any commits that touched the error code headers.

I’ve had a ticket open for years to write a tool to do this and the general idea of the tool’s architecture but never got around to implementing it.

I used the LLMs to research design alternatives (clang tools, tree sitter, etc) and eventually implement a tree sitter based python tool that: given a json config of the library prefixes, checks they all adhere and that there are no duplicate error codes within a library.

This would probably have taken me at least a few days to do on my own (or probably would just sit in the backlog forever), took about 3 hours.

bpftrace was instrumental in helping me diagnose a latency spike on a hot path.

I call into a vendor library that eventually calls into Solarflare's TCPDirect API to send packets to the network.

This call usually stays under 5us and has very little variance, but I was seeing the occasional 30ms or 60ms outlier.

I attached probes to track the latency of each call down the stack and it became quite easy to pin down the specific function.

Eventually tracking it down to a single assignment to a variable that was mmapped to a file, and getting spikes due to page cache writeback.

After figuring it out I found these two articles that go into more detail on the problem.

https://rigtorp.se/virtual-memory/

https://tungdam.medium.com/our-lessons-on-linux-writeback-do...

Here's one of the probes producing a histogram of the latency of the call to the TCPDirect function, which was surprising in how simple it was.

  sudo bpftrace -p "$PID" -e '
    // —— TCPDirect ——
    uprobe:/lib/x86_64-linux-gnu/libonload_zf.so.1:zft_send_single {
      @zf_start[tid] = nsecs;
    }
    uretprobe:/lib/x86_64-linux-gnu/libonload_zf.so.1:zft_send_single /@zf_start[tid]/ {
      $lat = nsecs - @zf_start[tid];
      @h_zft = hist($lat / 1000);
      delete(@zf_start[tid]);
    }
  '

Elixir has this.

https://hexdocs.pm/elixir/main/docs-tests-and-with.html

I suppose the argument is that while the robot itself might not have run over anyone, it might have caused someone else on the road to do it.

So if we're just measuring how many crashes the robot has been involved in, we can't account for how many crashes the robot indirectly caused.

In addition to the radio signal being faster as noted by the other commenters, for long distances the radiowave is actually the shorter route.

If you take one of the routes in the article, Chicago to Sao Paulo.

The distance is about 8,400km in a straight line.

According to https://en.wikipedia.org/wiki/Skywave a single shortwave hop can reach 3,500km, so 3 hops are required, or about 30ms.

The shortest commercially available submarine cable between the US and Sao Paulo alone is significantly higher than that (almost double), and it comes out of the east coast, so you'd still have to factor in the latency between Chicago and New York.

Even specialized low latency networks that mix wireless and fiber will still have much higher latency than the radio.

The tradeoff is that shortwave radio has very little bandwidth so you're restricted to simple signals.

I have been using SML in production for a little over a year now without issues, mostly for protocol machines.

I agree the documentation is not great though, you kind of have to go over the example code and try to figure things out on your own.

Using embedded data for keeping state (e.g. counters, etc; see https://boost-experimental.github.io/sml/examples/index.html...) along with injecting std::functions to use as actions is pretty powerful.

Here's a basic example I wrote some months ago showing a hierarchical machine (https://gist.github.com/indiosmo/08ab24181770125d5a2448d27f6...).

Also please note my usage is pretty basic as I usually have the same machine ported to C# and Python so I tend to use the smallest subset of functionality supported by all the libraries in each language.

In the context of hedge funds, I'm assuming compliance.