If we asked you to think of a device that converts a chemical reaction into electricity, you’d probably say we were thinking of a battery. That’s true, but there is another device that does this that is both very similar and very different from a battery: the fuel cell.

In a very simple way, you can think of a fuel cell as a battery that consumes the chemicals it uses and allows you to replace those chemicals so that, as long as you have fuel, you can have electricity. However, the truth is a little more complicated than that. Batteries are energy storage devices. They run out when the energy stored in the chemicals runs out. In fact, many batteries can take electricity and reverse the chemical reaction, in effect recharging them. Fuel cells react chemicals to produce electricity. No fuel, no electricity.

Superficially, the two devices seem very similar. Like batteries, fuel cells have an anode and a cathode. They also have an electrolyte, but its purpose isn’t the same as in a conventional battery. Typically, a catalyst causes fuel to oxidize, creating positively charged ions and electrons. These ions move from the anode to the cathode, and the electrons move from the anode, through an external circuit, and then to the cathode, so electric current occurs. As a byproduct, many fuel cells produce potentially useful byproducts like water. NASA has the animation below that shows how one type of cell works.

History

Sir William Grove seems to have made the first fuel cell in 1838, publishing in The London and Edinburgh Philosophical Magazine and Journal of Science. His fuel cell used dilute acid, copper sulphate, along with sheet metal and porcelain. Today, the phosphoric acid fuel cell is similar to Grove’s design.

The Bacon fuel cell is due to Francis Thomas Bacon and uses alkaline fuel. Modern versions of this are in use today by NASA and others. Although Bacon’s fuel cell could produce 5 kW, it was General Electric in 1955 that started creating larger units. GE chemists developed an ion exchange membrane that included a platinum catalyst. Named after the developers, the “Grubb-Niedrach” fuel cell flew in Gemini space capsules. By 1959, a fuel cell tractor prototype was running, as well as a welding machine powered by a Bacon cell.

One of the reasons spacecraft often use fuel cells is that many cells take hydrogen and oxygen as fuel and put out electricity and water. There are already gas tanks available, and you can always use water.

Types of Fuel Cells

Not all fuel cells use the same fuel or produce the same byproducts. At the anode, a catalyst ionizes the fuel, which produces a positive ion and a free electron. The electrolyte, often a membrane, can pass ions, but not the electrons. That way, the ions move towards the cathode, but the electrons have to find another way — through the load — to get to the cathode. When they meet again, a reaction with more fuel and a catalyst produces the byproduct: hydrogen and oxygen form water.

Most common cells use hydrogen and oxygen with an anode catalyst of platinum and a cathode catalyst of nickel. The voltage output per cell is often less than a volt. However, some fuel cells use hydrocarbons. Diesel, methanol, and other hydrocarbons can produce electricity and carbon dioxide as a byproduct, along with water. You can even use some unusual organic inputs, although to be fair, those are microbial fuel cells.

Common types include:

• Alkaline – The Bacon cell was a fixture in space capsules, using carbon electrodes, a catalyst, and a hydroxide electrolyte.
• Solid acid – These use a solid acid material as electrolyte. The material is heated to increase conductivity.
• Phosphoric acid – Another acid-based technology that operates at hotter temperatures.
• Molten carbonate – These work at high temperatures using lithium potassium carbonate as an electrolyte.
• Solid oxide – Another high temperature that uses zirconia ceramic as the electrolyte.

In addition to technology, you can consider some fuel cells as stationary — typically producing a lot of power for consumption by some power grid — or mobile.

Using fuel cells in stationary applications is attractive partly because they have no moving parts. However, you need a way to fuel it and — if you want efficiency — you need a way to harness the waste heat produced. It is possible, for example, to use solar power to turn water into gas and then use that gas to feed a fuel cell. It is possible to use the heat directly or to convert it to electricity in a more conventional way.

Space

Fuel cells have a long history in space. You can see how alkaline Bacon cells were used in early fuel cells in the video below.

Very early fuel cells — starting with Gemini in 1962 — used a proton exchange membrane. However, in 1967, NASA started using Nafion from DuPont, which was improved over the old membranes.

However, alkaline cells had vastly improved power density, and from Apollo on, these cells, using a potassium hydroxide electrolyte, were standard issue.

Even the Shuttle had fuel cells. Russian spacecraft also had fuel cells, starting with a liquid oxygen-hydrogen cell used on the Soviet Lunar Orbital Spacecraft (LOK).

The shuttle’s power plant measured 14 x 15 x 45 inches and weighed 260 pounds. They were installed under the payload bay, just aft of the crew compartment. They drew cryogenic gases from nearby tanks and could provide 12 kW continuously, and up to 16 kW. However, they typically were taxed at about 50% capacity. Each orbiter’s power plant contained 96 individual cells connected to achieve a 28-volt output.

Going Mobile

There have been attempts to make fuel cell cars, but with the difficulty of delivering, storing, and transporting hydrogen, there has been resistance. The Toyota Mirai, for example, costs $57,000, yet owners sued because they couldn’t obtain hydrogen. Some buses use fuel cells, and a small number of trains (including the one mentioned in the video below).

Surprisingly, there is a market for forklifts using fuel cells. The clean output makes them ideal for indoor operation. Batteries? They take longer to charge and don’t work well in the cold. Fuel cells don’t mind the cold, and you can top them off in three minutes.

There have been attempts to put fuel cells into any vehicle you can imagine. Airplanes, motorcycles, and boats sporting fuel cells have all made the rounds.

Can You DIY?

We have seen a few fuel cell projects, but they all seem to vanish over time. In theory, it shouldn’t be that hard, unless you demand commercial efficiency. However, it can be done, as you can see in the video below. If you make a fuel cell, be sure to send us a tip so we can spread the word.

Featured image: “SEM micrograph of an MEA cross section” by [Xi Yin]

When you think of Singer, you usually think of sewing machines, although if you are a history buff, you might remember they diversified into calculators, flight simulation, and a few other odd businesses for a while. [Techmoan] has an unusual device from Singer that is decidedly not a sewing machine. It is a 1970s-era multimedia briefcase called the Audio Study Mate. This odd beast, as you can see in the video below, was a cassette player that also included a 35mm filmstrip viewer. Multimedia 1970s-style!

The film strip viewer is a bright light and a glass screen with some optics. You have to focus the image, and then a button moves the film one frame. However, that’s for manual mode. However, the tape could encode a signal to automatically advance the frame. That didn’t work right away.

Luckily, that required a teardown of the unit to investigate. Inside was a lot of vintage tech, and at some point, the auto advance started working somewhat. It never fully worked, but for a decades-old electromechanical device, it did pretty well.

We do, sometimes, miss what you could pull off with 35mm film.

You’d think a paper from a science team from Carnegie Mellon would be short on fun. But the team behind LegoGPT would prove you wrong. The system allows you to enter prompt text and produce physically stable LEGO models. They’ve done more than just a paper. You can find a GitHub repo and a running demo, too.

The authors note that the automated generation of 3D shapes has been done. However, incorporating real physics constraints and planning the resulting shape in LEGO-sized chunks is the real topic of interest. The actual project is a set of training data that can transform text to shapes. The real work is done using one of the LLaMA models. The training involved converting Lego designs into tokens, just like a chatbot converts words into tokens.

There are a lot of parts involved in the creation of the designs. They convert meshes to LEGO in one step using 1×1, 1×2, 1×4, 1×6, 1×8, 2×2, 2×4, and 2×6 bricks. Then they evaluate the stability of the design. Finally, they render an image and ask GPT-4o to produce captions to go with the image.

The most interesting example is when they feed robot arms the designs and let them make the resulting design. From text to LEGO with no human intervention! Sounds like something from a bad movie.

We wonder if they added the more advanced LEGO sets, if we could ask for our own Turing machine?

If you talk about Starlink, you are usually talking about the satellites that orbit the Earth carrying data to and from ground stations. Why not? Space is cool. But there’s another important part of the system: the terminals themselves. Thanks to [DarkNavy], you don’t have to tear one open yourself to see what’s inside.

The terminal consists of two parts: the router and the antenna. In this context, antenna is somewhat of a misnomer, since it is really the RF transceiver and antenna all together. The post looks only at the “antenna” part of the terminal.

The unit is 100% full of printed circuit board with many RF chips and a custom ST Microelectronics Cortex A-53 quad-core CPU. There was a hack to gain root shell on the device. This led to SpaceX disabling the UART via a firmware update. However, there is still a way to break in.

[DarkNavy] wanted to look at the code, too, but there was no easy way to dump the flash memory. Desoldering the eMMC chip and reading it was, however, productive. The next step was to create a virtual environment to run the software under Qemu.

There were a few security questions raised. We wouldn’t call them red flags, per see, but maybe pink flags. For example, there are 41 trusted ssh keys placed in the device’s authorized_keys file. That seems like a lot for a production device on your network, but it isn’t any smoking gun.

We’ve watched the cat-and-mouse between Starlink and people hacking the receivers with interest.

If you want read-only memory today, you might be tempted to use flash memory or, if you want old-school, maybe an EPROM. But there was a time when that wasn’t feasible. [Igor Brichkov] shows us how to make a core rope memory using a set of ferrite cores and wire. This was famously used in early UNIVAC computers and the Apollo guidance computer. You can see how it works in the video below.

While rope memory superficially resembles core memory, the principle of operation is different. In core memory, the core’s magnetization is what determines any given bit. For rope memory, the cores are more like a sensing element. A set wire tries to flip the polarity of all cores. An inhibit signal stops that from happening except on the cores you want to read. Finally, a sense wire weaves through the cores and detects a blip when a core changes polarity. The second video, below, is an old MIT video that explains how it works (about 20 minutes in).

Why not just use core memory? Density. These memories could store much more data than a core memory system in the same volume. Of course, you could write to core memory, too, but that’s not always a requirement.

We’ve seen a resurgence of core rope projects lately. Regular old core is fun, too.

There was a time when version control was an exotic idea. Today, things like Git and a handful of other tools allow developers to easily rewind the clock or work on different versions of the same thing with very little effort. I’m here to encourage you not only to use version control but also to go even a step further, at least for important projects.

My First Job

I remember my first real job back in the early 1980s. We made a particular type of sensor that had a 6805 CPU onboard and, of course, had firmware. We did all the development on physically big CP/M machines with the improbable name of Quasar QDP-100s. No, not that Quasar. We’d generate a hex file, burn an EPROM, test, and eventually, the code would make it out in the field.

Of course, you always have to make changes. You might send a technician out with a tube full of EPROMs or, in an emergency, we’d buy the EPROMs space on a Greyhound bus. Nothing like today.

I was just getting started, and the guy who wrote the code for those sensors wasn’t much older than me. One day, we got a report that something was misbehaving out in the field. I asked him how we knew what version of the code was on the sensor. The blank look I got back worried me.

Seat of the Pants

Turns out, he’d burn however many EPROMs were required and then plow forward developing code. We had no idea what code was really running in the field. After we fixed the issue, I asked for and received a new rule. Every time we shipped an EEPROM, it got a version number sticker, and the entire development directory went on an 8″ floppy. The floppy got a write-protect tab and went up on the shelf.

I was young. I realize now that I needed to back those up, too, but it was still better than what we had been doing.

Enter Meta Version Control

Today, it would have been easy to label a commit and, later, check it back out. But there is still a latent problem. Your source code is only part of the equation when you are writing code. There’s also your development environment, including the libraries, the compiler, and anything else that can add to or modify your code. How do you version control that? Then there’s the operating system, which could interact with your code or development tools too.

Maybe it is a call back to my 8″ floppy days, but I have taken to doing serious development in a virtual machine. It doesn’t matter if you use QEMU or VirtualBox or VMWare. Just use it. The reason is simple. When you do a release, you can backup the entire development environment.

When you need to change something five years from now, you might find the debugger no longer runs on your version of the OS. The compiler fixed some bugs that you rely on or added some that you now trip over. But if you are in your comfy five-year-old virtual environment, you won’t care. I’ve had a number of cases where I wish I had done that because my old DOS software won’t run anymore. Switched to Linux? Or NewOS 2100^tm? No problem, as long as it can host a virtual machine.

Can’t decide on which one to use? [How to Simple] has some thoughts in the video below.

How About You?

How about it? Do you or will you virtualize and save? Do you use containers for this sort of thing? Or do you simply have faith that your version-controlled source code is sufficient? Let us know in the comments.

If you think Git is just for software, think again.

[Thomas Scherrer] has an odd piece of vintage test equipment in his most recent video. An AIM LCR Databridge 401. What’s a databridge? We assume it was a play on words of an LCR bridge with a digital output. Maybe. You can see a teardown in the video below.

Inside the box is a vintage 1983 Z80 CPU with all the extra pieces. The device autoranges, at least it seems as much. However, the unit locks up when you use the Bias button, but it isn’t clear if that’s a fault or if it is just waiting for something to happen.

The teardown starts at about six minutes in. Inside is a very large PCB. The board is soldermasked and looks good, but the traces are clearly set by a not-so-steady hand. In addition to AIM, Racal Dana sold this device as a model 9341. The service manual for that unit is floating around, although we weren’t able to download it due to a server issue. A search could probably turn up copies.

From the service manual, it looks like the CPU doesn’t do much of the actual measurement work. There are plenty of other chips and a fast crystal that work together and feed an analog-to-digital converter.

LCR meters used to be somewhat exotic, but are now fairly common. It used to be common to measure reactance using a grid dip meter.

[Project 326] is following up on his thermal microscope with a thermal telescope or, more precisely, a thermal monocular. In fact, many of the components and lenses in this project are the same as those in the microscope, so you could cannibalize that project for this one, if you wanted.

During the microscope project, [Project 326] noted that first-surface mirrors reflect IR as well as visible light. The plan was to make a Newtonian telescope for IR instead of light. While the resulting telescope worked with visible light, the diffraction limit prevented it from working for its intended purpose.

Shifting to a Keplerian telescope design was more productive. One of the microscope lenses got a new purpose, and he sourced new objective lenses that were relatively inexpensive.

The lens sets allow for 5X and 10X magnification. The lenses do reduce the sensitivity, but the telescope did work quite well. If you consider that the lenses are made to focus cutting lasers and not meant for use in imaging devices, it seems like an excellent result.

Missed the thermal microscope? Better catch up! Do you need a thermal camera? Ask a duck.

We know [Happy Little Diodes] frequently works with logic analyzer projects. His recent wireless logic analyzer for the ZX Spectrum is one of the oddest ones we’ve seen in a while. The heart of the system is an RP2040, and there are two boards. One board interfaces with the computer, and another hosts the controller.

The logic analyzer core is powered by a common open-source analyzer from [Eldrgusman]. This is one of the nice things about open source tools. Most people probably don’t need a logic analyzer that plugs directly into a ZX Spectrum. But if you do, it is fairly simple to repurpose a more generic piece of code and rework the hardware, if necessary.

You used to pay top dollar to get logic analyzers that “knew” about common CPUs and could capture their bus cycles, show execution, and disassemble the running code. But using a technique like this, you could easily decode any processor, even one you’ve designed yourself. All you need to do is invest the time to build it, if no one else has done it yet.

[Happy Little Diodes] is a big fan of the [Eldrgusman] design. What we would have given for a logic analyzer like this forty years ago.

If the Otis King slide rule in [Chris Staecker’s] latest video looks a bit familiar, you might be getting up there in age, or you might remember seeing us talk about one in our collection. Actually, we have two floating around one of the Hackaday bunkers, and they are quite the conversation piece. You can watch the video below.

The device is often mistaken for a spyglass, but it is really a huge slide rule with the scale wrapped around in a rod-shaped form factor. The video says the scale is the same as a 30-inch scale, but we think it is closer to 66 inches.

Slide rules work using the idea that adding up logarithms is the same as multiplying. For example, for a base 10 logarithm, log(10)=1, log(100)=2, and log(1000)=3. So you can see that 1+2=3. If the scales are printed so that you can easily add and then look up the antilog, you can easily figure out that 10×100=1000.

The black center part acts like a cursor on a conventional slide rule. How does it work? Watch [Chris’] video and you’ll see. We know from experience that one of these in good shape isn’t cheap. Lucky that [Chris] gives us a 3D printed version so you can make your own.

Another way to reduce the scale is to go circular, and you can make one of those, too.

Some things are so common you forget about them. How often do you think about an ordinary resistor, for example? Yet if you have a bad resistor, you’ll find it can be a big problem. Plus, how can you really understand electronics if you don’t know all the subtle details of a resistor? In the mechanical world, you could make the same arguments about the washer, and [New Mind] is ready to explain the history and the gory details of using washers in a recent video that you can see below.

The simple answer is that washers allow a bolt to fit in a hole otherwise too large, but that’s only a small part of the story. Technically, what you are really doing is distributing the load of a threaded fastener. However, washers can also act as spacers or springs. Some washers can lock, and some indicate various things like wear or preloading conditions.

Plain washers have a surprising number of secondary functions. Spring washers, including Belleville washers, help prevent fasteners from loosening over time. Wave washers look — well — wavy. They provide precise force against the bolt for preloading. Locking washers are also made to prevent fasteners from loosening, but use teeth or stops instead of springs.

There are plenty of standards, of course, that mostly match up. Mostly.

If you like knowing about odd washers, you might also want to know about the bolts that pass through them.

[Wrongdog Recons] suffers from a severe case of nostalgia. His earlier project simulated broadcast TV, and he was a little surprised at how popular the project was on GitHub. As people requested features, he realized that he could create a simulated cable box and emulate a 1990s-era cable TV system. Of course, you also needed a physical box, which turned into another project. You can see more about the project in the video below.

Inside is, unsurprisingly, a Raspberry Pi. Then you have to pretend to be a cable TV scheduler and organize your different video files for channels. You can interleave commercials and station breaks.

One addition was a scheduler so you could set up things like football games only play during football season. You can also control timing so you don’t get beer commercials during Saturday morning cartoons.

We were especially impressed with the program guide channel that lets you see what’s playing, just like an old-style cable system. The simulation even plays trash TV in the morning and bizarre commercials post-midnight.

If you are tired of having to decide what to watch, this might be for you. If you want to simulate the earliest pay TV, you’ll need a coin slot. We wonder if the simulator could do a local origination weather channel.

You normally think of ELINT — Electronic Intelligence — as something done in secret by shadowy three-letter agencies or the military. The term usually means gathering intelligence from signals that don’t contain speech (since that’s COMINT). But [Nukes] was looking at public data from NASA’s SMAP satellite and made an interesting discovery. Despite the satellite’s mission to measure soil moisture, it also provided data on strange happenings in the radio spectrum.

While 1.4 GHz is technically in the L-band, it is reserved (from 1.400–1.427 GHz)  for specialized purposes. The frequency is critical for radio astronomy, so it is typically clear other than low-power safety critical data systems that benefit from the low potential for interference. SMAP, coincidentally, listens on 1.41 GHz and maps where there is interference.

Since there aren’t supposed to be any high-power transmitters at that frequency, you can imagine that anything showing up there is probably something unusual and interesting. In particular, it is often a signature for military jamming since nearby frequencies are often used for passive radar and to control drones. So looking at the data can give you a window on geopolitics at any given moment.

The data is out there, and a simple Python script can pull it. We imagine this is the kind of data that only a spook in a SCIF would have had just a decade or two ago.

Jamming tech is secretive but powerful. SMAP isn’t the only satellite to have its mission unexpectedly repurposed.

Remember Video Volley? No? We don’t either. It looks like it was a very early video game console that could play tennis, hockey, or handball. In this video, [James] tears one apart. If you are like us, we are guessing there will be little more than one of those General Instrument video game chips inside.

These don’t look like they were mass-produced. The case looks like something off the shelf from those days. The whole thing looks more like a nice homebrew project or a pretty good prototype. Not like something you’d buy in a store.

Even inside, the wiring looks decidedly hand-built. The cheap phenolic PCB contained a surprise. The box does have a dedicated “pong” chip. But it isn’t from General Instruments! It’s a National Semiconductor chip instead.

The controllers are little more than sliding potentiometers in a box with a switch. We wonder how many of these were made and what they sold for new. If you know anything, let us know in the comments.

We still see the occasional project around a General Instruments chip. If you really want a challenge for a homebrew pong, ditch the pong chip and all the other ICs, too. If you want to read more about the history of the pong chip, you’ll probably enjoy this blog post from [pong-story].

Microsoft’s latest Phi4 LLM has 14 billion parameters that require about 11 GB of storage. Can you run it on a Raspberry Pi? Get serious. However, the Phi4-mini-reasoning model is a cut-down version with “only” 3.8 billion parameters that requires 3.2 GB. That’s more realistic and, in a recent video, [Gary Explains] tells you how to add this LLM to your Raspberry Pi arsenal.

The version [Gary] uses has four-bit quantization and, as you might expect, the performance isn’t going to be stellar. If you are versed in all the LLM lingo, the quantization is the way weights are stored, and, in general, the more parameters a model uses, the more things it can figure out.

As a benchmark, [Gary] likes to use what he calls “the Alice question.” In other words, he asks for an answer to this question: “Alice has five brothers and she also has three sisters. How many sisters does Alice’s brother have?” While it probably took you a second to think about it, you almost certainly came up with the correct answer. With this model, a Raspberry Pi can answer it, too.

The first run seems fairly speedy, but it is running on a PC with a GPU. He notes that the same question takes about 10 minutes to pop up on a Raspberry Pi 5 with 4 cores and 8GB of RAM.

We aren’t sure what you’d do with a very slow LLM, but it does work. Let us know what you’d use it for, if anything, in the comments.

There are some other small models if you don’t like Phi4.

We always enjoy [The History Guy], and we wish he’d do more history of science and technology. But when he does, he always delivers! His latest video, which you can see below, focuses on the Cold War pursuit of creating transfermium elements. That is, the discovery of elements that appear above fermium using advanced techniques like cyclotrons.

There was a brief history of scientists producing unnatural elements. The two leaders in this work were a Soviet lab, the Joint Institute of Nuclear Research, and a US lab at Berkeley.

You’d think the discovery of new elements wouldn’t be very exciting. However, with the politics of the day, naming elements became a huge exercise in diplomacy.

Part of the problem was the difficulty in proving you created a huge atom for a few milliseconds. It was often the case that the initial inventor wasn’t entirely clear.

We were buoyed to learn that American scientists named an element(Mendelevium) after a Russian scientist as an act of friendship, although the good feelings didn’t last.

We wonder if a new element pops up, if we can get some votes for Hackadaium. Don’t laugh. You might not need a cyclotron anymore.

[Martin Lorton] has a vintage Harmon 4200B selective voltmeter that needed repair. He picked it up on eBay, and he knew it wasn’t working, but it was in good condition, especially for the price. He’s posted four videos about what’s inside and how he’s fixing it. You can see the first installment below.

The 4200B is an RMS voltmeter and is selective because it has a tuned circuit to adjust to a particular frequency. The unit uses discrete components and has an analog meter along with an LCD counter.

The initial tests didn’t work out well because the analog meter was stuck, so it wouldn’t go beyond about 33% of full scale.

Since there are four videos (so far), there is a good bit of information and detail about the meter. However, it is an interesting piece of gear and part 3 is interesting if you want to see inside an analog meter movement.

By the fourth video, things seem to be working well. You might want to browse the manual for the similar 4200A manual to get oriented.

Forgot why we measure RMS? You weren’t the only one. RMS conversion in meters is a big topic and there are many ways to do it.

We’ve certainly seen people take a photo of a part, bring it into CAD, and then scale it until some dimension on the screen is the same as a known dimension of the part. We like what [Scale Addition] shows in the video below. In addition to a picture of the part, he also takes a picture of a vernier caliper gripping the part. Now your scale is built into the picture, and you can edit out the caliper later.

He uses SketchUp, but this would work on any software that can import an image. Given the image with the correct scale, it is usually trivial to sketch over the image or even use an automatic tracing function. You still need some measurements, of course. The part in question has a vertical portion that doesn’t show up in a flat photograph. We’ve had good luck using a flatbed scanner before, and there’s no reason you couldn’t scan a part with a caliper for scale.

This is one case where a digital caliper probably isn’t as handy as an old-school one. But it would be possible to do the same trick with any measurement device. You could even take your picture on a grid of known dimensions. This would also allow you to check that the distances at the top and bottom are the same as the distances on the right and left.

Of course, you can get 3D scanners, but they have their own challenges.

Although [Vitor Fróis] is explaining linear regression because it relates to machine learning, the post and, indeed, the topic have wide applications in many things that we do with electronics and computers. It is one way to use independent variables to predict dependent variables, and, in its simplest form, it is based on nothing more than a straight line.

You might remember from school that a straight line can be described by: y=mx+b. Here, m is the slope of the line and b is the y-intercept. Another way to think about it is that m is how fast the line goes up (or down, if m is negative), and b is where the line “starts” at x=0.

[Vitor] starts out with a great example: home prices (the dependent variable) and area (the independent variable). As you would guess, bigger houses tend to sell for more than smaller houses. But it isn’t an exact formula, because there are a lot of reasons a house might sell for more or less. If you plot it, you don’t get a nice line; you get a cloud of points that sort of group around some imaginary line.

There are mathematical ways to figure out what line you should imagine, but you can often eyeball it, too. The real trick is evaluating the quality of that imaginary line.

To do that, you need an error measure. If you didn’t know better, you’d probably think expressing the error in terms of absolute value would be best. You know, “this is 10 off” or whatever. But, as [Vitor] explains, the standard way to do this is with a squared error term R². Why? Read the post and find out.

For electronics, linear regression has many applications, including interpreting sensor data. You might also use it to generalize a batch of unknown components, for example. Think of a batch of transistors with different Beta values at different frequencies. A linear regression will help you predict the Beta and the error term will tell you if it is worth using the prediction or not. Or, maybe you just want to make the perfect cup of coffee.