It's so lightweight!

One technique is, instead of trying to pick individual winners, look at the total addressable market. Then compare the market size with the capital being pumped in. If you look on this basis, Aswath concluded that collectively AI investment is likely to provide unsatisfactory returns.

Here's a recent headline: "Nvidia’s Jensen Huang thinks $1 trillion won’t be enough to meet AI demand—and he’s paying engineers in AI tokens worth half their salary to prove it"

There are two parts to this. 1. A staggering $1t is expected to be invested in AI. Someone worked out that this was more than the entire capital expenditure for companies like Apple. We're talking about its entire existence here. IOW, $1t is a lot of dough. A LOT.

Secondly, this whole notion that AI is such a sure thing that half the salary will be in tokens should ring alarm bells. '“I could totally imagine in the future every single engineer in our company will need an annual token budget,” he said. “They’re going to make a few 100,000 a year as their base pay. I’m going to give them probably half of that on top of it as tokens so that they could be amplified 10 times.”'

I recall from the dotcom fiasco that service companies like accountants and lawyers were providing services to the dotcom companies and being compensated in stock options rather than cold hard cash like you'd normally expect.

Very dangerous.

As another poster pointed out, this really boils down to FOMO by big tech. I'm expecting big trouble down the line. We await to see if I'm early or just plain wrong.

As the saying goes, once you've seen one Forth, then you've seen one Forth.

I've mucked around with my own Forths in the past, including one that recognises lexical type, so you could build something like a parser in Forth. I didn't take it that far. Forth is normally conceived as being built from the ground up, but if you're you're going to implement it in C or C++ then you can be more imaginative.

I played around with colorforth for 5 minutes on a couple of occasions, but I ran away screaming. What - just what - the hell is going on? I'm sure it all works for Charles Moore, but for mere mortals it might as well be a klingon control panel.

I think Moore effectively gave up on programming a couple of years ago? There was some strange modification in the guts of Windows and he couldn't get his environment to work any longer. He concluded that the game was not work the candle.

I'm also half-way to adding a little calendar extension, too.

And check this: version 1.2.2 is available on Aminet, for the Amiga. How's that for a blast from the past?

Oleo uses lex and yacc, whereas Neo has a hand-parser.

Oleo is in the style of emacs bindings, whereas Neo is more vim-like, but without the modality.

I think the Neo code is better-structured and more readable (but I would say that, wouldn't I? - although it is far from perfect). C++ generally makes code more readable and obvious, without all that pointer arithmetic.

The internals of Oleo are more complicated. It uses byte-code for cells, for example. Neo stores a parse tree for a cell. So you can see that a lot of programming effort is saved right there.

In terms of speed, I suspect that the original Oleo is faster, although it's difficult to benchmark.

Neo is also heading towards being a library that you can compile in with other C++ code. Plus there's an interface to Tcl, which Oleo never had. So you get a lot of extensibility there which Oleo doesn't have.

I also think Neo is more generally accessible. It's got something in the way of a menu (still early stages), which helps. Neo is just generally less fiddly with editing cells, IMO. The mouse works, too.

Oleo does have an interface using Motif. Very early-90s. There's even an interface to GTk, although I don't think that works properly. I decided to abandon all that and just stick to an ncurses interface. After all, if you want a fancy interface, there are proper options these days like LibreCalc, Caliigra and Gnumeric.

If I may be permitted a small plug ...

Oleo is a GNU spreadsheet going back absolutely donkey years. I cloned the repo here: https://github.com/blippy/oleo and made minimalist fixes to get the thing to compile.

I also based my own terminal-based spreadsheet based off of it call neoleo: https://github.com/blippy/neoleo

I wouldn't say that my project is particularly good, but it does have a number of features that I find useful. The next release will include Tcl bindings, so you can customise some of the workings of the app. There's also a module available where you can go to town programmatically.

It opens up a world of possibilities, including stuff like pivot tables.

  package require oleo
  load-oleo mysheet.oleo
  set ws [toMat]
  set subset [subRows $ws [mand [mstreq 2 foo] [mstreq 3 bar]]

I'm kinda dog-fooding it at the moment to put in place features that I need. It doesn't have the full equivalence of SQL-equivalent though.

However, saying you're committed is not the same as being committed.

Furrowing your brow and saying you'll try harder, even when you mean it, doesn't necessarily work, either.

It needs trade-offs, and a willingness for abandon certain things as trade-offs. It requires an honest assessment.

Stop updating the system every 5 minutes, stop with the advertising, stop with the user is the product mentality. Stop changing the interface. Stop with requiring a user account. Stop with the all your data are belong to us. Simplify.

None of this will happen, of course. Corporate imperatives militate against it.

Wanna improve Windows? How about having a two-year release cadence? Developers can get a technology preview, full of cavaet emptor achey breaky changes if they want. This allows them to develop for the next release.

Sync the development tools (more importantly the libraries) like C++ in with the release. Include those libraries. The pay-off is, as if by magic, if a user downloads a program for Windows N, it will work. No extra libraries will be required because they'll already be included in the OS.

I also heard about Matt Lucas, of Little Britain fame. He was slowly plugging away at it, and was about to give up. At around 30 years old, he teamed up with David Walliams, describing it as the last roll of the die. Their popularity exploded.

Morgan Freeman didn't become famous until he was in his 50's. Someone asked him if he was upset that it took so long. His response was: "No, because it didn't have to happen at all."

It's amazing that a platform that's been dead since the early 90's is still getting so much love.

Supports Arm M0 (Raspberry Pi Pico), ESP32 and a variety of others, including Z80.

https://github.com/slviajero/tinybasic

Amazingly, Aminet is still up-and-running with frequent uploads.

https://www.aminet.net/

I contributed a package to that once.

I also made an animation on the Amiga, "Sadistic Circus". A circus dog jumps through a hoop a few times, then gets set on fire. What a sick, sick little puppy I am. I submitted it to a PD disk collection one time.

The dog was an image I got off of a magazine disk, which I mucked around with to create my animation.

Pretty rubbish really, but whatever. Happy days.

Ah, nostalgia ain't what it used to be -- source contested

The fact that another breaking change has been introduced confirms my suspicion that Zig is not ready for primetime.

My conclusion is to just use C. For low-level programming it's very hard to improve on C. There is not likely to be any killer feature that some other contender will allow you to write the same code in a fifth of the lines nor make the code any more understandable.

Yes, C may have its quirky behaviour that people gnash their teeth over. But ultimately, it's not that bad.

If you want to use a better C, use C++. C++ is perfectly fine for using with microcontrollers, for example. Now get back to work!

I used words like IMMEDIATE and POSTPONE to create words that create words. I quickly get lost doing that, though.

Forth is very very cool to play with. Pragmatically, virtually any other language is better.

yes | pv > /dev/null

and was getting about 5.4GiB/s

On the fasm code, I was getting a meagre 7.3MiB/s. Ouch! The non-assembly version is considerably faster. I wonder if it is because I make a syscall for every write I want to perform, whereas C uses buffering, or something.

https://gitlab.com/mcturra2000/cerbo/-/blob/master/x64-asm/0...

Some people seem to revel in assembly, but I now know why C exists.