Quantum computer

Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle

Quantum computers are really in their infancy. If you created a few logic gates with tubes back in the 1930s, it would be difficult to predict all the ways we would use computers today. However, you could probably guess where at least some of the problems would lie in the future. One of the things we are pretty sure will limit quantum computer development is error correction.

As far as we know, every quantum qubit we’ve come up with so far is very fragile and prone to random errors. That’s why every practical design today incorporates some sort of QEC — quantum error correction. Of course, error correction isn’t news. We use it all the time on unreliable storage media or communication channels and high-reliability memory. The problem is, you can’t directly clone a qubit (a quantum bit), so it is hard to use traditional error correction techniques with qubits.

After all, the whole point to a qubit is we don’t measure it until the end of the computation which, like Schrödinger’s cat, seals its fate. So if you were to “read” a bunch of qubits to form a checksum or a CRC, you’d destroy their quantum nature in the process making your computer not very useful. You can’t even copy a bit to use something like triple redundancy, either. There seems to be no way to practically duplicate a qubit.

Continue reading “Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle”

Trying And (Mostly) Failing To 3D Print A Hydrofoil

[Sam Barker] had a boring dingy that he wanted to spice up a bit, so he resolved to 3D print a hydrofoil wing for it so that it could fly across the water. (Video, embedded below.)

With a large wing designed and sliced into several pieces, and a total print time of 200 hours, [Sam] was ready to glue the foil wing together when he realized his scale was way off and the wings were far too large for his boat. With some hacking, [Sam] was able to use a single wing across the bottom of the ship. [Tom Stanton] came over to help with fiberglassing, and they were ready for a test.

As you might have guessed from the title, the test wasn’t particularly successful. Swapping the engine on the boat for a more potent motor gave the lift he needed in the front, but without a back foil, it was a wheelie rather than what [Sam] hoped for. Back at home, they printed a second wing and went back for a second test. The boat would start to lift out the water, but the shaft of the engine lifted out of the water, sending him back down. Unfortunately, a downpour cut the test short.

Not to be defeated entirely, [Sam] connected it to a much larger boat once the weather cleared and pulled his dingy along behind. To [Sam’s] credit, they did get some solid foiling, and the ship did lift out of the water until the wings sheared off from the stress. All in all, an entertaining story of engineering while racing against the weather.

We admire [Sam’s] ambition, and if you’re thinking about building a whole hydrofoil, we suggest starting with a smaller RC model and scaling up from there.

The Game Of Life Moves Pretty Fast, If You Don’t Use Stop Motion You Might Miss It

Munged Ferris Bueller quotes aside, Conway’s Game of Life is the classic cellular automata that we all reach for. The usual approach is to just iterate over every cell in the grid, computing the next state into a new grid buffer. [K155LA3] set out to turn that on its head by implementing Game Of Life in the hardware of an FPGA.

[K155LA3]’s version uses Chisel, a new HDL from the Berkley and RISCV communities. Under the hood, Chisel is Scala with some custom libraries that know how to map Scala concepts onto hardware. In broad strokes, Verilog and VHDL are focused on expressing hardware and then added abstraction on top of that over the year. Chisel and other newer HDL languages focus on expressing high-level general-purpose elements that get mapped onto hardware. FPGAs already map complex circuits and hardware onto LUTs and other slices, so what’s another layer of abstraction?

The FPGA chosen for this project is a Digilent Arty A7 with a VGA Pmod to turn the RGB444 into analog signals to actually display. What’s impressive about [K155LA3]’s implementation is just how fast it is. Even running at 60 frames per second it’s almost as fast as the monitor can handle. Of course, most computers lying around you could simulate a 60 x4 8 grid at 60 fps. Next, instead of connecting the grid logic to the 60 Hz VGA clock, he connects it to the 100 MHz board external oscillator. Now each pixel in each frame displayed contains over a million generations.

Unfortunately, even this small grid of 60×48 takes up 90% of the LUTs on the Artix-7. In the future, we’d love to see an even larger FPGA hardware implementation capable of handling grids that could hold whole computers in them. And naturally, this isn’t the first FPGA version of the Game Of Life here at Hackaday.