Quantum computer

Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle

November 11, 2021 by 25 Comments

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

November 11, 2021 by 5 Comments

[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

November 11, 2021 by 12 Comments

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.

8″ Floppy On Your PC?

November 10, 2021 by 52 Comments

We should probably have a new metric for measuring mass storage performance: bytes per pound. An old IBM tape drive from the S/360 days, for example, could hold almost 6 megabytes of data. It also weighed more than a typical refrigerator. Today, a tiny postage-stamp-sized card can hold gigabytes of data and weighs — at most — a few ounces. Somewhere in the middle is the old 8 inch floppy drive. At its peak, you could cram about 1.2 megabytes on it, but even with the drive you could lift it all in one hand. These disks and their descendants ruled the computing world for a while. [Adrian asks the question: can you use an 8″ floppy drive on a PC? The answer is in the video below.

He didn’t do it on a lark. [Adrian] is getting ready to restore a TRS-80 Model II so he wanted to create some 8″test floppies. But how do you marry a 40-something-year-old drive to a modern computer? He had a few drives of unknown condition so there was nothing to do but try to get them working.

Continue reading “8″ Floppy On Your PC?” →

Linux On The Windows 11 Desktop

November 10, 2021 by 38 Comments

A month ago Microsoft officially released Windows 11. One of its features is the ability to run Linux GUI applications side by side as peers to normal Windows desktop apps. [Jim Salter] of Ars Technica took a closer look and declared it works as advertised.

This is an evolution of the Windows Subsystem for Linux (WSL), which has existed for a few years but only in command-line form. Linux being Linux, it was certainly possible to put visuals onscreen, but doing so required jumping through some hoops and dealing with limitations. Now “WSLg” gives a smoother and more accessible experience.

While tremendously valuable for those who need it, WSLg is admittedly a niche feature. The circumstances will be different for different needs. Around these parts, one example is letting us work with pieces of proprietary Windows software (such as low level hardware drivers or hardware-specific dev tools) while still retaining Linux tools for the rest of our workflow.

It’s also interesting to take a peek behind the scenes for an instructive look at bridging two operating systems. A Microsoft blog post describes the general architecture, where we were happy to see open-source work leveraged. And by basing this work on Wayland, it is more forward-looking than working with just X11.

The bad news is that WSLg is limited to Windows 11, at least for now. WSL users on Windows 10 will have to continue jumping through hoops (We described one method using X11.) And opening this door unfortunately also opened the door to security issues, so there’s still work ahead for WSL.

Arduino Piano Tuner Is Pitch Perfect

November 10, 2021 by 16 Comments

[JanHerman] knows that tuning musical instruments is all about precision and that precision is measured in a logarithmic unit called a cent. A cheap tuner unit might be accurate to 1.5 cents which sounds good until you look at one for ten times the price and find it is accurate to 0.1 cents. So you can spend $800 for precision or $60 for something less. [Jan] decided to build something better and cheaper using a 32-bit Arduino and a DDS frequency generator chip on a breakout board.

Oddly enough, the device doesn’t have a display. Instead, it generates a precise frequency and couples it to the piano using a transducer. You tune the string to the corresponding note. The post has a lot of detail about how piano tuning works.

Continue reading “Arduino Piano Tuner Is Pitch Perfect” →

Kinetic Log Splitter Gets The Job Done Kinetically

November 10, 2021 by 37 Comments

Swinging an axe to split firewood is great exercise and a wonderful way to blow off steam. However, if you’re not a muscled-up Hollywood character that needs to do some emotional processing, it can get pretty dull. Building a powered log splitter could make the work less strenuous, as [Made in Poland] demonstrates. (Video, embedded below.)

The build relies on a big electric motor, which is connected to a set of gears via a big belt drive. Those gears subsequently drive a rack forward when engaged via a lever, which pushes a log towards a splitter blade. The blade itself is a beautifully simple thing, being made out of a flat piece of steel bar carved up with a saw to form a pointy wedge.

The machine is remarkably effective, and greatly reduces the effort required to split even large 30 and 45 cm logs, as demonstrated in the video. We’ve featured a rundown on a few different designs before, too. Video after the break.

Continue reading “Kinetic Log Splitter Gets The Job Done Kinetically” →