How Does Starlink Work Anyway?

February 20, 2020 by Dan Maloney 128 Comments

No matter what you think of Elon Musk, it’s hard to deny that he takes the dictum “There’s no such thing as bad publicity” to heart. From hurling sports cars into orbit to solar-powered roof destroyers, there’s little that Mr. Musk can’t turn into a net positive for at least one of his many ventures, not to mention his image.

Elon may have gotten in over his head, though. His plan to use his SpaceX rockets to fill the sky with thousands of satellites dedicated to providing cheap Internet access ran afoul of the astronomy community, which has decried the impact of the Starlink satellites on observations, both in the optical wavelengths and further down the spectrum in the radio bands. And that’s with only a tiny fraction of the planned constellation deployed; once fully built-out, they fear Starlink will ruin Earth-based observation forever.

What exactly the final Starlink constellation will look like and what impact it would have on observations depend greatly on the degree to which it can withstand regulatory efforts and market forces. Assuming it does survive and gets built out into a system that more or less resembles the current plan, what exactly will Starlink do? And more importantly, how will it accomplish its stated goals?

Continue reading “How Does Starlink Work Anyway?” →

Faster Computers Lead To Slower Experiences?

March 22, 2019 by Kerry Scharfglass 110 Comments

Ever get that funny feeling that things aren’t quite what they used to be? Not in the way that a new washing machine has more plastic parts than one 40 years its senior. More like “my laptop can churn through hundreds of gigaflops, but when I scroll it doesn’t feel great.” That perception of smoothness might be based on a couple factors, including system latency. A couple years ago [danluu] had that feeling too and measured the latency of “devices I’ve run into in the past few months” (based on this list, he lives a more interesting life than we do). It turns out his hunch was objectively correct. What he wrote was a wonderful deep dive into how and why a wide variety of devices work and the hardware and software contributors to latency.

Let’s be clear about what “latency” means in this context. [danluu] was checking the time between a user input and some response on screen. For desktop systems he measured a keystroke, for mobile devices scrolling a browser. If you’re here on Hackaday (or maybe at a Vintage Computer Festival) the cause of the apparent contradiction at the top of the charts might be obvious.

Q: Why are some older systems faster than devices built decades later? A: The older systems just didn’t do much! Instead of complex multi-tasking operating systems doing hundreds of things at once, the CPU’s entire attention was bent on whatever user process was running. There are obvious practical drawbacks here but it certainly reduces context switching!

In some sense this complexity that [danluu] describes is at the core of how we solve problems with programming. Writing code is all about abstraction. While it’s true that any program could be written directly in machine code and customized to an individual machine’s hardware configuration, it would be pretty inconvenient for both developer and user. So over time layers of sugar have been added on top to hide raw hardware behind nicer interfaces written in higher-level programming languages.

And instead of writing every program to target exact hardware configurations there is a kernel to handle the lowest layers, then layers adding hotplug systems, power management, pluggable module and driver infrastructure, and more. When considering solutions to a programming problem the approach is always recursive: you can solve the problem, or add a layer of abstraction and reframe it. Enough layers of the latter makes the former trivial. But it’s abstractions all the way down.

[danluu]’s observation is that we’re just now starting to curve back around and hit low latency again, but this time by brute force! Modern solutions to latency largely look like increasingly exotic display technologies and complex optimizations which reach from UI draw functions all the way down to the silicon, not removing software and system infrastructure. It turns out the benefits of software complexity in terms of user experience and ease of development are worth it most of the time.

For a very tangible illustration of latency as applied to touchscreen devices, check out the Microsoft Research video after the break (linked to in [danluu]’s piece).

Continue reading “Faster Computers Lead To Slower Experiences?” →

HFT On HF, You Can’t Beat It For Latency

May 12, 2018 by Jenny List 14 Comments

If you are a radio enthusiast of A Certain Age, you may well go misty-eyed from time to time with memories of shortwave listening in decades past. Countries across the world operated their own propaganda radio stations, and you could hear Radio Moscow’s take on world events, the BBC World Service responding, and Radio Tirana proudly announcing that every Albanian village now had a telephone. Many of those shortwave broadcast stations are now long gone, but if you imagine the HF spectrum is dead, think again. An unexpected find in an industrial park near Chicago led to an interesting look at the world of high-frequency trading, or HFT, and how they have moved to using shortwave links when everyone else has abandoned them, because of the unparalleled low latency they offer when communicating across the world.

Our intrepid tower-hunter is [KE9YQ], who was out cycling and noticed a particularly unusual structure adorned with a set of HF beams. These are the large directional antennas of the type you might otherwise expect to see on the roof of an embassy or in the backyard of a well-heeled radio amateur, and were particularly unusual in this otherwise unexciting part of America. There followed an interesting process of tracking down the site’s owners via the FCC permits for its operation, leading to the deduction of its purpose. With other antenna-hunters on the lookout for corresponding sites elsewhere in the world, it seems that this unusual global network hiding in plain sight could soon be revealed.

Unsurprisingly we’ve not covered many shortwave HFT stories. There are however other higher-latency ways to cross the world on HF.

Via SWLing Post, and thanks [W6MOQ] for the tip.

Video Streaming Like Your Raspberry Pi Depended On It

September 12, 2017 by Lewin Day 23 Comments

The Raspberry Pi is an incredibly versatile computing platform, particularly when it comes to embedded applications. They’re used in all kinds of security and monitoring projects to take still shots over time, or record video footage for later review. It’s remarkably easy to do, and there’s a wide variety of tools available to get the job done.

However, if you need live video with as little latency as possible, things get more difficult. I was building a remotely controlled vehicle that uses the cellular data network for communication. Minimizing latency was key to making the vehicle easy to drive. Thus I set sail for the nearest search engine and begun researching my problem.

My first approach to the challenge was the venerable VLC Media Player. Initial experiments were sadly fraught with issues. Getting the software to recognize the webcam plugged into my Pi Zero took forever, and when I did get eventually get the stream up and running, it was far too laggy to be useful. Streaming over WiFi and waving my hands in front of the camera showed I had a delay of at least two or three seconds. While I could have possibly optimized it further, I decided to move on and try to find something a little more lightweight.

Continue reading “Video Streaming Like Your Raspberry Pi Depended On It” →

Fixing Arduino’s Serial Latency Issues

May 18, 2011 by Mike Nathan 42 Comments

arduino_latency

[Paul] wrote in to tell us about some interesting Arduino latency issues he helped nail down and fix on the Arduino.

It seems that [Michu] was having some problems with controlling his Rainbowduino project we featured earlier this year, and he couldn’t quite figure out why he was experiencing such huge delays when sending and receiving data.

Searching online for answers turned up very little, and since [Michu] was using Processing, the pair designed a set of tests to see what kind of latency was being introduced by Java. Pitting an Arduino Uno and an Arduino from 2009 against a Teensy 2.0, the tests gauged the latency of native data transfers versus transfers facilitated by Java via the rxtx library it uses for serial communications.

The results were pretty stunning. While both of the Arduinos lagged behind the Teensy by a long shot, their latency values under Java were always 20ms at a minimum – something didn’t add up. [Michu] poked around in the rxtx code and found a mystery 20ms delay programmed into the serial library. It made no sense to him, so he changed the delay to 2ms and saw a drastic increase in performance when transferring less than 128 bytes of data.

The pair’s fix doesn’t seem to affect latency when larger amounts of data (>1kB) are being transferred, but it makes a world of difference when manipulating smaller chunks of data.

For the sake of disclosure, it should be noted that [Paul’s] company produces the Teensy mcu.