markisus

But we don’t usually count the decompression program size when evaluating compression ratio. Eg 7-Zip is about 1 MB, but you don’t think about that when evaluating particular 7z files.

In a way, although the double slit demonstrated self interference. In this experiment, I think the lattice is so sparsely populated that interference effects are negligible and particles move as free wave packets while the lattice is disabled.

For almost all n (size), the function runs for MAX_SIZE steps, since almost all numbers are greater than MAX_SIZE. And it never runs for more than MAX_SIZE steps.

The arxiv has more details. They sparsely populated a dense lattice with particles. Then they turned off the lattice, which allowed all the particles’ wave functions to evolve according to the Schrödinger equation. Then they turned the lattice back on, which constitutes a measurement and collapses the wave functions. Then they took statistics on how far and in which direction each particle traveled and compared those statistics to the ones implied by Schrödinger’s equation.

The article mentions at least a dozen defective parts.

> Swampy sent his own inspectors to the factory floor, and they discovered "dozens of red-painted defective parts installed on planes."

It also mentions that employees were regularly ordered to commit felonies by managers.

This points to something seriously wrong with the company culture.

However, this is public information likely already priced into the stock. So it wouldn’t surprise me either way which direction it goes from here.

The teams started working some time around September 2023, judging by timelines shown on the website https://a2rl.io/.

This is not a lot of time and explains why the performance was so underwhelming (eg spinning out, jerking for no reason). Either that or the compute platform may be under powered.

This is definitely not state of the art performance and if the league continues I would expect much more impressive results next time.

I’m not sure you can say that imitation learning has been under-researched in the past. Imitation learning has been tried before alongside RL. But it did not generalize well until the advent of generative diffusion models.

How does it work if there is more than one bend? Is it able to localize both bends? And what about the bend directionality? Anyway nice project. I could see it being used for a mesh to give robots a tactile skin covering.

For anyone else who is geographically challenged, the map apparently has 64 states instead of 50. Here is an article with the extra states highlighted.

https://www.explainxkcd.com/wiki/index.php/2868:_Label_the_S...

This may be the status quo because of the so called "hardware lottery" which has historically been optimized for floating point. I'm speculating, but if hardware designers were instead only concerned about raw xnor density and throughput, we might end up with chips powerful enough that giant 1-bit nets could be trained purely through evolution.

Your interests seem to lie closer to the systems and hardware side. Can you elaborate on why your career is in CRUD apps? What about working for SpaceX?

I’ve been using Pandas which exposes a python slicing syntax for manipulating relational data. It also has a builtin join() function.

“select id, date from orders” is orders[“id”, “date”].

It’s meant for in-memory datasets but the syntax could be extended to work for other backends. I’m not sure if anyone is working on that.

Except some firms have made extraordinary profits by statistical analysis of Mr Market, eg Renaissance

This quote hits close to home. “So I got the arm to match the conveyor speed by monitoring the position and pre-empting the motion command, alternating ‘slow’ and ‘fast’ at 10Hz with a duty cycle depending on how we are tracking our target. The motion is pretty jerky but it works.”

I’ve been through exactly this scenario in two very popular robotics frameworks.

Countless hours were spent by well intentioned framework developers to abstract away the underlying PID loop from the end users. Then countless more hours were spent by the end users to work around this by implementing a PID loop on top of the abstraction.

I think PCA plus nearest neighbor was one of the earliest effective face recognition algorithms aka the eigenfaces method.

It’s funny because you really have to have a lot of experience with the language to articulate these issues. C++ is the worst language, besides all the other ones, when it comes down to performance and third party library availability.

I’ll just throw in my own pet peeves here.

The existence of .h files is still a big problem. I’m not aware of another language (besides c of course) that basically forces you to type the same letters twice in slightly different ways in order to expose a public api.

I also don’t understand why there’s still no way to print an enum value.

However there is some progress. I think std::span fixes the issue with the vector of const vs const vector. The Eigen library gives a (not perfect, but very convenient) matrix type. And I think I heard something about modules?

The differential equations seem to show that this is a closed form implementation of a P (as in PID) controller. So the animation could be implemented without a call to exponential for small enough dt.

Pretty impressive. I wonder though why it was necessary to put the point map of the second image into the coordinate frame of the first. Isn’t it all the same from the point of the neural net?

From all his public talks, Carmack seems like a nice and smart guy. I’m curious why you have a negative impression.

I'm guessing this was downvoted for being rude, but I think there is a valid question here. It looks like Zed is putting a lot of work into minimizing the latency between a key being typed and feedback being displayed on a visual interface which is easily parsed by a sighted user.

If a programmer is using audio for feedback, then there is probably be some impedance mismatch by translating a visual interface into an audio description. Shouldn't there be much better audio encoding of the document? There would also be many more wasted cycles pushing around pixels, which the programmer will never see. An editor made specifically for visually impaired programmers, unencumbered by the constraints of a visual representation, would be able to explore the solution space much better than Zed.

Probabilistic Robotics covers Kalman Filter from a first principles probabilistic viewpoint, and its extension the EKF. It's quite readable for someone with basic understanding of linear algebra, probability, and calculus. I believe it also has a refresher on these basics in the introduction.

http://www.probabilistic-robotics.org/

Everything is a tradeoff. Even things like goto, and global variables will occasionally be the right choice.

Regarding the std::vector method, you may have a very loosely coupled system where a bunch of T1's enter into a pipeline and come out as T2's. For this use case, std::vector<T1> and std::vector<T2> are great. On the other hand, if you need to create an object and hand it off to someone else with no knowledge of how long they will need to hold onto it, then std::shared_ptr could be a good option.

In the in-between you have entity component systems that do the type of index tracking you mention so that identities are decoupled from memory location, allowing objects to move. I didn't understand your point about global variables and why they are necessary to implement this type of system. I also didn't understand how this gives up on all ownership. The owner would be the system that maintains the index to memory location mapping.

In my example, the T is one specific type. So you could have std::vector<Cat>. If you also have Dogs, you just make another vector std::vector<Dog>. It works fine with the standard allocator. You don't have to do anything special.

I usually like to place all dynamically heap objects of type T into an std::vector<T>, if possible. There is sometimes an obvious point where the entire batch should be discarded and a new batch should be built. At this point, you can call vector.clear() which avoids deallocation/allocation cost for the new batch, as long as it is not bigger than the old batch. This is a sort of quick and dirty arena allocation.

This style is also more cache friendly if you are going to be looping through the elements.

A very interesting cast of underdog characters appears in the article.

You’ve got one guy with a relentless spirit to continue with mathematics in is spare time after being blacklisted from mainstream academia because of antisemitism.

Another is a childhood prodigy, who set the record for the youngest American IMO team member, but got burned out as an adult and went into finance but found his way back through the mentorship of another mathematician.

And a third was a biology major. After graduating, he worked as a baker. But he wanted a career change so he entered a master’s program in math and proved an impressive result.

I also feel like the start menu now is totally busted. In older versions of Windows I could find applications I installed via the start menu. Now it’s seemingly random whether it wants to find my application or whether it shows me an internet article about the application.

For some reason the author thinks that skills you learn developing in PyTorch will go away if Facebook does. Wouldn’t the open source community just fork the source or develop a new framework? It’s not like backprop will stop working.

Minimizing Minkowski difference between convex bodies can also be formalized as a quadratic program. I wonder how the GJK performs against the QP formulation.

Nit: The most likely outcome is zero return, but expected return is positive (if the investor is rational) due to tail probability.

Do you think 1D could work? Maybe topic-space is some sort of tree-shaped structure where documents live in the thin strands.