v9v

I believe it's even been ported to the M1 a few years ago: https://x.com/gmpalter/status/1361855786603929601

You mentioned UMI, which to my knowledge runs VSLAM on camera+IMU data to estimate the gripper pose and no exoskeletons are involved. See here: https://umi-gripper.github.io/

Pathsim is a block diagram-based simulator written in Python and seems to be getting very regular commits https://github.com/pathsim/pathsim

I use TRAMP to edit code loaded on robots occasionally. One advantage compared to VSCode is that it doesn't require the installation of anything onto the computer you're connecting to, since it uses the usual linux tools to work. But it can freeze up once in a while.

Not teleoperating can have certain disadvantages due to mismatches between how humans move vs. how robots move though. See here: https://evjang.com/2024/08/31/motors.html

At the very least it differs greatly from "world model" as understood in earlier robotics and AI research, wherein it referred to a model describing all the details of the world outside the system relevant to the problem at hand.

Relevant: A GPT-2 implementation in Fortran and an experience report: https://ondrejcertik.com/blog/2023/03/fastgpt-faster-than-py...

There were a few languages designed specifically for parallel computing spurred by DARPA's High Productivity Computing Systems project. While Fortress is dead, Chapel is still being developed.

There are recordings of other songs presented at the top of the article.

I like Webots because it's easier to get things up and running in it compared to other simulators.

> Lisp is also a huge train wreck that way. [...] There's like 20+ different lisp like languages.

Lisp is not a language, but a descriptor for a family of languages. Most Lisps are not functional in the modern sense either.

Similarly, there are functional C-like languages, but not all C-likes are functional, and "learn c-likes" is vague the same way "learn lisp" is.

The difference is time, effort and scalability. There are many things that humans can do that society doesn't strictly regulate, because as human activities they are done in limited volumes. When it becomes possible to automate some of these activities at scale, different sorts of risks and consequences may become a part of the activity.

Reminds me of particle filters.

Might be relevant: https://yosefk.com/blog/the-high-level-cpu-challenge.html

What motors do you use for the arm and what interfaces do you provide (position, velocity, effort)? How long does the battery last when idling?

Maybe you'll find this example to be a bit more useful: https://blog.adacore.com/i-cant-believe-that-i-can-prove-tha...

The idea is that you define a number of pre- and post- condition predicates for a function that you want proved (in what's effectively the header file of your Ada program). Like with tests, these checks that show that the output is correct are often shorter than the function body, as in this sorting example.

Then you implement your function body and the prover attempts to verify that your post-conditions hold given the pre-conditions. Along the way it tries to check other stuff like overflows, whether the pre- and post- conditions of the routines called inside are satisfied, etc. So you can use the prover to try to ensure in compile-time that any properties that you care about in your program are satisfied that you may otherwise catch in run-time via assertions.

Thought this post from the Ada vs. Rust thread was worthy of its own submission.

Fortran can do "in out" arguments to subroutines also.

Any USB-C ports on my laptops go unused, so I exclusively buy devices with min. 3 USB-A ports. All of my peripherals and cables are USB-A, and it's so much easier to tinker with USB-A ports due to the smaller amount of pins (easy to jam in multimeter probes etc)

It's a quote, so I can only speculate. Maybe he was referring to the effects caused by scratching or other damage on the disk?

I'm not the author of the post itself, but the 74181 chip seems to be defined in the simulator: https://github.com/hneemann/Digital/blob/master/src/main/dig...

It seems all this package does is install and configure ada-ts-mode and eglot (to use ada-language-server) with some custom commands (defined in config.lisp). Here's how I adapted it to my config: https://pastes.io/ada-config

Note that I added a format-on-save hook in my config, and since I do completions using corfu and not company, I didn't include that part of the package.

"Whatever you now find weird, ugly, uncomfortable and nasty about a new medium will surely become its signature. CD distortion, the jitteriness of digital video, the crap sound of 8-bit - all of these will be cherished and emulated as soon as they can be avoided. It’s the sound of failure: so much modern art is the sound of things going out of control, of a medium pushing to its limits and breaking apart. The distorted guitar sound is the sound of something too loud for the medium supposed to carry it. The blues singer with the cracked voice is the sound of an emotional cry too powerful for the throat that releases it. The excitement of grainy film, of bleached-out black and white, is the excitement of witnessing events too momentous for the medium assigned to record them." -Brian Eno

Fossil comes with a chatroom feature (https://fossil-scm.org/home/doc/trunk/www/chat.md). Could that be what they're referring to?

They have an emulator here: https://github.com/Datamuseum-DK/R1000.Emulator2

Notably it needs KiCad to run and takes ~140 hours to boot.

Seems like the reason for KiCad and the slow operation is that the emulation occurs at a really low level, and they've written a program to digitize all of the computer's schematics and convert them into netlists (which is then converted into systemC components for the emulator): https://github.com/Datamuseum-DK/R1000.HwDoc

a video explaining the process?: https://www.youtube.com/watch?v=oMRTr0bPuOA

This reminds me of the turnpike property in optimization: for some optimization problems, no matter what the initial and final conditions are, the optimal path passes through the same section. Then you can exploit this to simplify the problem as getting onto this highway and getting off at the right times.

Why use machine learning to solve a problem that you already know how to solve? The classical method is easier to derive, run and understand. Any failure cases can be easily reasoned about and can be clearly outlined and ameliorated if needed. Your proposed replacement needs lots of training data, a training cost that needs to be paid for any change in the data, a costlier runtime and unknown failure cases that we can't reason about at all. And if we hit any such failure cases the only thing we can do is change the data and cross our fingers. I don't see why learning-based methods would perform better here.

Maybe not applicable for the XR platform here, but you could add introspection capabilities not present in Linux, a la Genera letting the developer hotpatch driver-level code, or get all processes running on a shared address space which lets processes pass pointers around instead of the Unix model of serializing/deserializing data for communication (http://metamodular.com/Common-Lisp/lispos.html)

Please read the "Significance" section of the Wikipedia article you linked. It shows that your claim that this is a legal requirement isn't as clear-cut as you make it to be.

I normally dislike electron use for desktop applications but in this case it's a web browser so I don't see the problem. If you want an Emacslike text-based browser, maybe run emacs -nw and use eww?