v9v

In C with https://github.com/aartaka/pretty.c,

    foreach (i, int, 10, vector(10, int, 1, 2, 3, 3, 4, 5))
          println(*i);

Parts of this reminded me of the book "Sadly, Porn".

For Firefox I've switched to Glide (Firefox fork?) and configured it to implement Emacs keybindings. There is a config on the project's Github discussions page that I started off of.

I'll add another to the list of relevant links in the comments: https://spectrum.ieee.org/orbital-data-centers-heat

For those that don't know, this is a reference to a lovely story involving Charles Proteus Steinmetz https://www.smithsonianmag.com/history/charles-proteus-stein...

I guess you're writing it all out for educational purposes, but conventionally to describe the kinematics of a serial robot arm Denavit-Hartenberg parameters are used, which needs only 4 parameters per link.

It's hard to find it since it's a livestream. From the comments: https://www.youtube.com/watch?v=HG0twQJ7aG4&t=16047s

Somewhat relevant is a blog-post that likens attention to kernel smoothing: https://bactra.org/notebooks/nn-attention-and-transformers.h... (as discussed before in https://news.ycombinator.com/item?id=38756888)

Finally an auto-accompanist to rival Band-in-a-Box? https://www.bandinabox.com/

Recently a new VS Code extension was announced that you may want to check out: https://old.reddit.com/r/lisp/comments/1tn3zff/new_cl_vscode... It purports to be more stable.

I think Kevin Kelly has taken the opposing side before: https://colossus.com/article/flounder-mode/ (discussed https://news.ycombinator.com/item?id=44455933)

There are a few of these being sold as products: AGIBOT has some models like that (eg https://www.agibot.com/products/A2_W). One argument that could be made for legged robots is that these wheeled ones can only work in wheelchair-accessible spaces. Legged robots can also balance themselves dynamically: a wheeled robot may tip over if anything violates its static balance, eg. carrying a load high up and going through a steep incline, though I guess having the torso be tiltable as in https://www.agibot.com/products/G2 addresses that.

Legged robots overall have more implementation complexity, spend energy just to idle standing up, but can go over much more varied terrain provided the controller is good enough. There are ways to adapt wheeled bases to different terrains (eg. larger wheels, whegs, RHex, rocker-bogies) but we know how to use legs to locomote over many terrains from personal experience, while the perfect wheeled/non-legged locomotion system perhaps remains to be designed.

There's also the way robotics is going toward data-driven methods, which in some forms (ie. imitation learning) require human teleoperation data. Here having the robot mimic the human form makes the mapping from human joints to robot joints easier (compared to other morphologies where you'd need to figure out how to best approximate a human motion with the joints/joint limits your robot has, though this is not impossible).

There's also Bike for CL/.NET interop: https://github.com/Lovesan/bike

Put me down as interested!

Ada/SPARK may also be worth a look.

DREI = DREI Replaces EINE's Inheritor

https://mcclim.common-lisp.dev/static/documents/drei.pdf

I use https://github.com/TxGVNN/github-explorer for this and even though it doesn't have a C-x C-f nicety (you just m-x github-explorer then type in the repo name) it works via http (or at least I don't recall giving it any API key or anything).

One thing to be mindful of is that you can get a simulation to behave in (almost) any way you want if you set the parameters right, so you should take care to understand the assumptions that you're baking into your sim before taking its results as gospel.

For it to be an SI unit, shouldn't you be able to express it in terms of the 7 SI base units?

They could consider registering as a provider on something like OpenRouter if they aren't getting enough inference requests on their own site.

By gyro do you mean flywheel? Is there one in this robot?

Do they actually have ASICs or just FPGAs? The article seems a bit unclear.

The author claimed that the models he modified with this layer repetition method topped the huggingface open llm leaderboard in his first post: https://dnhkng.github.io/posts/rys/

Do you remember the names of the previous experiments done on this? Would love to take a look.

I think Godot is a possible contender as well. There are a few non-game applications made with it, and they've recently added a docs page tailored to non-game application development: https://docs.godotengine.org/en/stable/tutorials/ui/creating...

In one of the youtube comments the director says that they contacted the author and got permission.

Very interesting! I see that you've made a comment saying the other stuff you've tried is on the way as a second blog post, but what happens when you repeat these 7 layers once more? Does performance increase the more repetitions you do?

Thought this was about semiconductor cleanrooms at first. Any startups doing that?

Relevant: https://github.com/sipeed/picoclaw

I think the big differentiator for this one is the carrying capacity. They list 50kg instant/30kg sustained carrying capacity which is very impressive and I can't think of other humanoids with similar capability off the top of my head.

The connections are too easy to the point where the main challenge for me was to remember/locate where I had stored the nodes of that category. I think the fun in a connection puzzle comes from trying to figure out what the link is that connects different nodes, and resolving any red herrings by deduction (which is what makes OnlyConnect's connection wall great and NYT's knockoff mediocre). In this one I can spot the intended category for each node without even looking at the others.