Linux Fu: Pimp Your Pipes

One of the best things about working at the Linux (or similar OS) command line is the use of pipes. In simple terms, a pipe takes the output of one command and sends it to the input of another command. You can do a lot with a pipe, but sometimes it is hard to work out the right order for a set of pipes. A common trick is to attack it incrementally. That is, do one command and get it working with the right options and inputs. Then add another command until that works. Keep adding commands and tweaking until you get the final results.

That’s fine, but [akavel] wanted better and used Go to create “up” — an interactive viewer for pipelines.

Pipe Philosophy

Pipes can do a lot. They match in with the original Unix philosophy of making each tool do one thing really well. Pipe is really good at allowing Linux commands to talk to each other. If you want to learn all about pipes, have a look at the Linux Info project’s guide. They even talk about why MSDOS pipes were not really pipes at all. (One thing that write up doesn’t touch on is the named pipe. Do a “man fifo” if you want to learn more for now and perhaps that will be the subject of a future Linux Fu.)

This program — called up — continuously runs and reruns your pipeline as you make changes to the pipe. This way, every change you make is instantly reflected in the output. Here’s the video, here’s a quick video which shows off the interactive nature of up.

Installing

The GitHub page assumes you know how to install a go program. I tried doing a build but I didn’t have a few dependencies. Turns out the easy way to do it was to run this line:

go get -u github.com/akavel/up

This put the executable in ~/go/bin — which isn’t on my path. You can, of course, copy or link it to some directory that’s on your path or add that directory to your path. You could also set an alias, for example. Or, like I did in the video, just specify it every time.

Perfect?

This seems like a neat simple tool. What could be better? Well, I was a little sad that you can’t use emacs or vi edit keys on the pipeline, at least not as far as I could tell. This is exactly the kind of thing where you want to back up into the middle and change something. You can use the arrow keys, though, so that’s something. I also wished the scrollable window had a search feature like less.

Otherwise, though, there’s not much to dislike about the little tool. If writing a pipeline is like using a C compiler, up makes it more like writing an interactive Basic program.

Raspberry Pi On The Go Powers Car System

Most new cars have GPS, rear cameras, and all the other wonders an on-board system can bring. But what if you have an old car? [Fabrice Aneche] has a 2011 vehicle, and wanted a rearview camera. He started with a touch screen, a Raspberry Pi 3, and a camera. But you know how these projects take on a life of their own. So far, the project has two entries in his blog.

It wasn’t long before he couldn’t resist the urge to add a GPS. But that’s no fun without maps. Plus you need turn-by-turn directions. [Fabrice] did a lot of the user interface using Qt5 and QML. He started out running it with X11 but that was slow. It turns out though that Qt5 can drive the Pi’s video directly without using X11, so that’s what he wound up doing. The code that isn’t in QML — mainly dealing with the GPS location — is written in Go, while the code for MOCS (My Own Car System) is on GitHub.

Continue reading “Raspberry Pi On The Go Powers Car System”

Unlocking Drones with Go

Looking for a first project in a relatively new language that’ll stretch your abilities? [Ron] was, so he hacked a commercially available drone and opened up a lot of its functionality, while writing the client software in Go.

The drone is a DJI Tello, which has some impressive hardware like a 14-core Intel processor and excellent video processing abilities. There’s also a vibrant community and a lot of support, making it the ideal platform for a project like this. It communicates to a base station via WiFi, and using some tools like the Wireshark [Rob] was able to decipher a lot of the communications and create a whole new driver for the drone. While the drone can be controlled in the traditional way, users can also write programs to control the drone as well.

The project is both an impressive feat in reverse engineering an inexpensive drone, and a fun example of programming in the Go language. Because of the fun and excitement of drones, they have become a popular platform on which to hack, from increasing their range to becoming a platform for developing AI.

Up AlphaGoer Five

AlphaGo is the deep learning program that can beat humans at the game Go. You can read Google’s highly technical paper on it, but you’ll have to wade through some very academic language. [Aman Agarwal] has done us a favor. He took the original paper and dissected the important parts of in in plain English. If the title doesn’t make sense to you, you need to read more XKCD.

[Aman] says his treatment will be useful for anyone who doesn’t want to become an expert on neural networks but still wants to understand this important breakthrough. He also thinks people who don’t have English as a first language may find his analysis useful. By the way, the actual Go matches where AlphaGo beat [Sedol] were streamed and you can watch all the replays on YouTube (the first match appears below).

Continue reading “Up AlphaGoer Five”

Hackaday Links: October 15, 2017

For the last few months we’ve been running The Hackaday Prize, a challenge for you to build the best bit of hardware. Right now — I mean right now — you should be finishing up your project, crossing your t’s and dotting your lowercase j’s. The last challenge in the Prize ends tomorrow. After that, we’re going to pick 20 finalists for the Anything Goes challenge, then send the finalists off to our fantastic team of judges. Time to get to work! Make sure your project meets all the requirements!

It’s been a few weeks, so it’s time to start talking about Star Trek. I’m paying ten dollars a month to watch Star Trek: Discovery. I was going to pay that anyway, but I think this might actually be worth it. Highlights include Cardassian voles and Gorn skeletons. Also on the Star Trek front is The Orville, [Seth MacFarlane]’s TNG-inspired show. The Orville has far surpassed my expectations and is more Star Trek than Discovery. Leave your thoughts below.

It’s a new edition of Project Binky! Two blokes are spending years stuffing a 4WD Celica into a Mini. It’s the must-watch YouTube series of the decade.

AstroPrint now has an app. If you’re managing a 3D printer remotely and you’re not using Octoprint, you’re probably using AstroPrint. Now it’s in app format.

Have fifty bucks and want to blow it on something cool? A company is selling used LED display tiles on eBay. You get a case of ten for fifty bucks. Will you be able to drive them? Who knows and who cares? It’s fifty bucks for massive blinkies.

[Peter] is building an ultralight in his basement. For this YouTube update, he’s making the wings.

Oh it’s deer season, so here’s how you make deer jerky.

If you’re messing around with Z-Wave modules and Raspberry Pis, there’s a contest for you. The grand prize is an all-expense paid trip to CES2018 in Las Vegas. Why anyone would be enthusiastic about a trip to CES is beyond me, but the Excalibur arcade has Crazy Taxi, so that’s cool.

Go is the language all the cool kids are using. GoCV gives Go programmers access to OpenCV.

You are Go for FPGA!

Reconfigure.io is accepting beta applications for its environment to configure FPGAs using Go. Yes, Go is a programming language, but the software converts code into FPGA constructs, so you don’t need Verilog or VHDL. Since Go supports concurrent routines and channels for synchronization and communications, the parallel nature of the FPGA should fit well.

According to the project’s website, the tool also allows you to reconfigure the FPGA on the fly using a cloud-based build and deploy system. There isn’t much detail yet, unless you get accepted for the alpha. They claim they’ll give priority to the most interesting use cases, so pitching your blinking LED project probably isn’t going to cut it. There is a bit more detail, however, on their GitHub site.

Continue reading “You are Go for FPGA!”

Ask Hackaday: Google Beat Go; Bellwether or Hype?

We wake up this morning to the news that Google’s deep-search neural network project called AlphaGo has beaten the second ranked world Go master (who happens to be a human being). This is the first of five matches between the two adversaries that will play out this week.

On one hand, this is a sign of maturing technology. It has been almost twenty years since Deep Blue beat Gary Kasparov, the reigning chess world champion at the time. Although there are still four games to play against Lee Sedol, it was recently reported that AlphaGo beat European Go champion Fan Hui in five games straight. Go is generally considered a more difficult game for machine minds to play than chess. This is because Go has a much larger pool of possible moves at any given time.

Does This Matter?

Okay, the news part of this event has been covered: machine beats man. Does it matter? Will this affect your life and how? We want to hear what you think in the comments below. But I’m going to keep going with some of my thoughts on the topic.

You're still better at Ms. Pacman [Source: DeepMind paper in Nature]
You’re still better at Ms. Pacman [Source: DeepMind paper in Nature]
Let’s look first at what AlphaGo did to win. At its core, the game of Go is won by figuring out where your opponent will likely make a low-percentage move and then capitalizing on that choice. Know Your Enemy has been a tenet of strategy for a few millennia now and it holds true in the digital age. In addition to the rules of the game, AlphaGo was fed a healthy diet of 30 million positions from expert games. This builds behavior recognition into the system. Not just what moves can be made, but what moves are most likely to be made.

DeepMind, the company behind AlphaGo which was acquired by Google in 2014, has published a paper in Nature about their approach. They were even nice enough to let us read without dealing with a paywall. The secret sauce is the learning process which at its core tries to mimic how living entities learn: observe repetitively while assigning values to outcomes. This is key as it leads past “intellect”, to “intelligence” (the “I” in AI that everyone seems to be waiting for). But this is a bastardized version of “intelligence”. AlphaGo is able to recognize and predict behavior, then make choices that lead to a desired outcome. This is more than intellect as it does value the purpose of an opponent’s decisions. But it falls short of intelligence as AlphaGo doesn’t consciously understand the purpose it has detected. In my mind this is exactly what we need. Truly successful machine learning will be able to make sense out of sometimes irrational input.

The paper from Nature doesn’t go into details about Go, but it explains the approach of the learning system applied to Atari 2600. The algorithm was given 210×160 color video at 60Hz as an input and then told it could use a joystick with one button. From there it taught itself to play 49 games. It was not told the purpose or the rules of the games, but it was given examples of scores from human performance and rewarded for its own quality performances. The chart above shows that it learned to play 29 of them at or above human skill levels.

Continue reading “Ask Hackaday: Google Beat Go; Bellwether or Hype?”