I liked the way how you bootstrap the agent from a single markdown file.

I built so much muscle memory from the original system, so it made sense to apply it to other projects. This was the simplest way to achieve that

Why did you opt for "highly-abbreviated commit IDs"?

Instead of:

``` calendar/seasons.blog 196 40 d1

    196  196e749
     40  40c52f4
     d1  d142598

```

The tool should simply display:

``` calendar/seasons.blog 196e749 40c52f4 d142598 ```

That's it!

The second table only complicates the output.

PS:

`what-changed-twice` is a good name.

> While LLMs are capable of writing functional Verilog sometimes, their performance is still subhuman.

The key word here is "still".

We don't know what the limits of LLMs are.

It's possible that they will reach a dead end. But it is also possible that they will be able to do logic and math.

If (or when) they achieve that point, their performance will quickly become "superhuman" in these kinds of engineering tasks.

But the very next step will be the ability to do logic and math.

Reportedly, they've already hit the dead end: the newest Orion is marginally better than previous ChatGPT model (it's also marginally worse than it in some applications), and there is just no more fresh, non-AI generated data of somewhat good quality to train on.

> The surest sign of a market for lemons is when everything for sale is garbage, and nobody has an incentive to put something up for sale that's not garbage, because they have no way to credibly signal their offerings aren't garbage, too.

That's why I left twitter...

In fact, NAND gates are enough to build a Turing complete machine. ;-)

My favorite turning complete language is Fractran - https://en.wikipedia.org/wiki/FRACTRAN

    17 78 19 23 29 77 95 77  1 11 13 15  1 55
    -- -- -- -- -- -- -- -- -- -- -- -- -- --
    91 85 51 38 33 29 23 19 17 13 11  2  7  1

That computes prime numbers.

Iterate through the list (start with n = 2) and iterate through until the fraction is an integer. Repeat with the new number.

For this, after 2, the next value is 15 (when it gets to 15/2). Then it will be 825 (15 * 55/1). Then it will be 725 (825 * 29 / 33) and so on. At some point, n will be 2^x where the sequence of when the number is just a power of 2 will be: 2^2, 2^3, 2^5, 2^7, 2^11 and so on... the exponents of 2 are the prime sequence.

2, 15, 825, 725, 1925, 2275, 425, 390, 330, 290, 770, 910, 170, 156, 132, 116, 308, 364, 68, 4, 30 ...

https://oeis.org/A007542

https://news.ycombinator.com/item?id=35966537

https://softwareengineering.stackexchange.com/questions/2201...

https://web.archive.org/web/20150923211455/http://www.cs.vu....

How will you do unbound computation with only NAND gates? Either you need a clock (not a NAND gate) or you need to implement a clock using NAND gates, but that assumes physical aspects such as power propagation speed.

Typically you say that you can make arbitrary functions between any two closed domains using only NAND gates.

Turing completeness isn't about having everything you need to build the physical computer, just about expressing program logic that can perform a certain class of unbounded computations. Like, given any C program's logic that takes some input and gives an output, you could calculate the same thing (painfully) with NAND gates.

Anyway, bringing up Turing completeness is overly theoretical when talking about a programming language. It's pretty hard to make a language not Turing-complete, and it doesn't say much about what you can use it for IRL.

> you need to build the physical computer

Exactly.

Now tell me how you will do unbound computation (ie. write on the n+1 cell in the Turing machine) with a fixed number og NAND gates and without a clock.

Oh, I see what you mean. Yeah it seems like you need a clock.

NAND gates are enough to computer any boolean function. Being Turing complete requires some notion of state and state transition.

However, a RAM machine where the program counter is memory mapped, can be Turing complete with a [single machine instruction]( https://en.m.wikipedia.org/wiki/One-instruction_set_computer).

While true, to build a language using NAND gates, the language has to specify how to assemble those gates, which will still require conditionals and loops if you want it to build any machine.

It's a simple text adventure game engine. It looks like this:

---

The Lost Kingdom

You are a brave explorer on a quest to find the lost kingdom of an ancient civilization.

You are in a mysterious cave with passageways leading in different directions.

What do you want to do? look

You are in a mysterious cave with passageways leading in different directions.

I see here: a glowing gem

Exits: north

What do you want to do? take gem

Taken!

What do you want to do? look at gem

It's a glowing gem with an intricate pattern carved into its surface.

---

An interesting new feature is that you can ask the computer to do non-scripted things, like:

---

What do you want to do? eat gem

# Generating action...

You attempt to eat the gem, but it doesn't taste good. You spit it out and the gem is still in your possession.

---

The game, the scenario, the objects -- everything was created by GPT-3, and the script just have to keep track of the game state.

st - simple statistics from the command line

https://github.com/nferraz/st

Hey! This is great. Another thing that would be awesome would be to have a small histogram (could be oriented in rows rather than columns)!

Nice! They definitely overlap, although there are a few differences... I'm not sure if ministat accepts bignum, scientific notation, etc.

Yes, Sprint suggested this:

    octave -q --eval "mean = mean(load('$1'))"

But, again, octave requires more time to warm up...

That does not read the data from stdin. You could probably get it to work with some bash wizardry. But maybe not. I did spend some time on this a few years ago and it may have changed in the interim, but my memory is that I tried load("/dev/stdin") and using a fifo etc and it doesn't work (probably because load() uses some seeks to determine matrix data shape before reading data in i.e. data is read in as columns instead of reading in rows and transposing). At least that was my takeaway. At least if you want to use the load() builtin.

Basically you just need to write an octave function that reads values from the terminal.

There isn't a max rowcount for sum, mean, variance, etc, because it is not necessary to hold the data in memory.

The calculation of median and quartiles require that the whole set is stored and later sorted, so it is limited to the available memory.

Regarding your suggestion -- I'm considering the idea of dealing with multiple columns and even CSV and other types of tabulated data.