Rob Baruch on CyberSpy

The Sound of Silence

Mon, 29 Dec 2025 09:00:00 +0000

Happy New Year 2026! Almost Three Years of Silence

so, i’ve been tardy. What’s happenned over the last three years that seem to be remarkable? The most natural thing to do is ask an LLM. Let’s let it co-author (a markdown file no less) summarizing the most relevant events of the last three years. Here goes!

The Last Three Years in Review (2023–2025)

A Technical, Scientific, and Geopolitical Timeline

The past three years have been unusually dense with change. Advances in artificial intelligence, renewed great-power competition, supply-chain realignments, and breakthroughs in science have all reshaped how societies operate—and how technologists build systems.

Liquid Soap better than dirty Ice (DarkIce)

Fri, 10 Nov 2023 09:00:00 +0000

DarkIce bugs are Enough! Time to Soap Up

So, over the years, I’ve maintained a DarkIce stream for Icecast2 audio server. Mostly, I do this for DMR radio that I want to stream from my Anytone 878 handset. The challenge is the code is not maintained and is buggy. Configuration is less than desirable as well. So after finally deciding enough was enough (one can only restart a failed daemon so many times), I bit the bullet and went on the hunt for alternatives.

NFC Tagboard - Using NFC Tags, Grafana, and Docker

Sun, 05 Dec 2021 12:26:21 -0400

NFC Tags - Tracking tasks last completed

Trying to track when you last completed a long-dated task can be challenging. Writing them on a calendar makes for difficult searching. Heavy apps are overkill. So what’s a person to do? A simple soltution - use NFC tags which are pre-loaded with custom JSON, drop a little golang server, and Docker persistance with MySQL, along with a Grafana UI to easily manage tracking of tasks.

I'm Back!!! Diving into Rust!

Mon, 26 Apr 2021 12:26:21 -0400

Noobie to Rust? Let’s get started!!

So you want to get into rust? Sure, why not. Let’s do it.

The setup

Assuming you’re on a Mac, let’s get rust up and running so you’re ready to rip into learning the language. We’ll use rustup to install rust. This is the best way to manage your rust environment and toolchain. Not only can you manage toolchains using rustup, but also add-in components to make the experience a lot more enjoyable. More on that later. Not only will rustup install rust for you, but it will also be useful for maintaining the latest versions of rust. Rust has several toolchains, and using rustup will make maintaining them a whole lot easier.

Getting func(y) with Channels

Tue, 10 Dec 2019 09:55:44 -0500

Here’s a little golang puzzle

Take a look at the function below that computes a mystery value for the function $f(x)$. Any idea what the function is? Take a close look at the first line where we create a channel. Notice that the channel isn’t some boring int or string channel. No, this is a channel of type func(int, chan int, chan bool). Wait what??? That’s right, this channel takes a function that takes an integer and two channels as function parameters. We define such a function, x, right aftewards.

OS X VPN client pppd host route configuration on post-interface connection

Wed, 20 Nov 2019 11:42:17 -0500

VPN Client PPP daemon configuration

Recipe: Configure Default Host routes after a specific VPN connection has been established

Solution:

In order to configure the host (or network routes, although I’m solely interested in routing specific hosts between my two sites), we need to create a file with the following commands in /etc/ppp.

#!/bin/sh

# VPN_GATEWAY is the remote address of the vpn tunnel
# when ppp executes this script it will pass several values to it
# $5 will hold the remote gateway

VPN_GATEWAY=192.168.1.156
if [ "${5:-}" = "${VPN_GATEWAY}" ]
then
                /bin/echo "${5:-} routes added for interface ${5:-}" > "/tmp/pppd_ip_up_$$.log"
                /sbin/route add -host 192.168.1.92 -interface ppp0 || (/bin/echo "failed to add route 92" >> "/tmp/pppd_ip_up_$$.log")
                /sbin/route add -host 192.168.1.158 -interface ppp0|| (/bin/echo "failed to add route 158" >> "/tmp/pppd_ip_up_$$.log")
                /sbin/route add -host 192.168.1.56 -interface ppp0|| (/bin/echo "failed to add route 56" >> "/tmp/pppd_ip_up_$$.log")
                /sbin/route add -host 192.168.1.26 -interface ppp0|| (/bin/echo "failed to add route 26" >> "/tmp/pppd_ip_up_$$.log")
else
                /bin/echo "No routes added for interface ${5:-}" > "/tmp/pppd_ip_up_$$.log"
fi

This script must be owned by root and executable. We can create multiple else clauses to configure routes for our remote VPN connection based on the remote IP Address. I’ve added a log to /tmp to monitor the process.

Baby it's Cold Outside -- How Cold? Use an SHT31 and See!

Tue, 29 Jan 2019 11:42:17 -0500

ESP32 and SHT31 Temperature and Humidity Sensor Secure Web Server

In this blog post, I follow-up on the ESP32-IDF development and demonstrate how to incorporate an i2c device to measure the temperature and humidity. Specifically the SHT31. First, let’s do it plain-jane vanilla. We’ll incorporate the i2c device and simply display the measurements to the serial terminal through the uart. Next, we’ll make it more practical and send the data over the wifi network to a service that makes it convenient to visualize the time-series data.

Program the Esp32 with ESP-IDF on Mac OS X

Wed, 23 Jan 2019 22:11:25 -0500

Programming the ESP32 on your Mac!

Go out and buy yourself a cheap little ESP32 SoC and follow these basic instructions to setup your development environment on your Mac. If you want to do some advanced C-programming to control your ESP32, this is for you. If you’d rather use Arduino and play with simple sketches then this is not for you – google how to use Arduino and off you go!

What you will need

So, of course you’ll need an ESP32 SoC development board. I recommend the SparkFun Thing. Lots of other choices, but this blog post will address some of the specific configuration considerations that you’ll need to be aware of when you select this particular device.

Making some Noise - Teensy, TGA-Pro, and MIDI

Fri, 04 May 2018 10:34:07 -0400

Making Some Noise (and maybe even Music)!

In this blog post, I’ll share my experiences using the Teensy and TGA-Pro Guitar Audio Shield to process audio - both using an audio processing codec as well as MIDI. I’ve also included the Yamaha UX16 USB-to-MIDI controller to aid in patching my MIDI channels into the inputs of the Guitar Audio shield.

Teensy - Yet antother cheap USB uController board.

At the hear of this project is the Teensy 3.6 USB Microcontroller development board. This sub-$30 board is a feature-rich micro-controller using the Cortex M4, floating-point unit, digital and analog pins, and lots of communication protocols (USB, i2C, SPI, Serial, Ethernet). What makes this little USB-attached board so useful are the accompanying software elements:

Pathocaml - Getting Wacky with Functions And Polymorphism

Mon, 19 Mar 2018 20:21:13 -0400

OCaml on the Fringes - You can do that??

So, I got bored this afternoon and was contemplating why I was enjoying diving into OCaml more than say Elixir/Erlang for functional programming. The quality of the language that’s most captured my attention is the type system.

When you start playing around with the type system in OCaml you can go from some basic definitions of user-defined types to some pretty cool looking constructs. Let’s start of with something pretty transparent and move into something that might actually melt your brain.

OCaml OpenGL - Get into Gear!

Tue, 13 Mar 2018 14:41:15 -0400

OCaml and OpenGL - Getting our Functional Programming into Gear!

In my blog post for this day, I thought I’d take a look at the OCaml OpenGL library, lablgl. If you’re not already familair with openGL, I strongly suggest that you take a look at one of the tutorials available online. One that I found to be very informative; although written in c++, is opengl-tutorial. Nonetheless, in this post, we’ll look at some simple, and not so simple examples written in OCaml. But before we can do that, we need to install the requisite opam dependencies. To install lablgl, simply:

Exercism - Get your Code Deamons Out! Heal Your Body!

Wed, 28 Feb 2018 15:12:36 -0500

Exercis(m)

The best way to keep the mind, body, and soul sharp is to exercise! No better way to learn new programming paradigms than following this same precept when learning new concepts in an unfamiliar programming language. There are several sites online that afford noobs practice problems - Hackerrank, kaggle to name a few. But one that I recently came across, exercism.io, aims to provide not just programming exercises, but a community of folks committed to commenting and sharing both code and criticism on implementations to problem sets across many languages.

Riding the Camel Deeper into the Desert of Code: Records and Variants

Sun, 11 Feb 2018 12:41:10 -0500

Extending and Encapsulating Data - Records and Variants

Up next on our tour of OCaml are records and variants. If you are familiar with typedef, struct, and union in c/c++, you’ll quickly come to understand how to use records and variants in OCaml. We’ll start off looking at records, how to define them, use them in functions, and automatically generate common functions from our type definitions. There’s more to the eye than what you get in a language like c, so pay close attention as we move through the descriptions below. We’ll break it down one at a time so you’ll have no problems!

Let's Get Funky with the Camel

Fri, 09 Feb 2018 16:17:20 -0500

How many ways can we get Fun(ky)

In any programming paradigm, it’s critical to understand how we write functions - be they traditional imperative , anonymous , recursive, or functional. In this post, I will break down the different types of functions that you can write in OCaml.

Let’s start by examining the imperative function. Here’s a simple function that prints out the phrase Hello World! $n$ times, once on each line, and returns the value $n$ as its result.

OCaml Hello World and more

Tue, 06 Feb 2018 11:28:00 -0500

Well Hello There!

As tradition has it, every new programming language experience must begin with the basic Hello World. Let’s walk the the basics of how to set up our development environment specifically for OCaml and demonstrate how to compile our basic program.

Warming up our Environment

Of course we could just use our vanilla editor to enter our OCaml programs, but a more efficient work environment leverages an extensible editor that is aware of our programming language. Editors like sublime, Atom, and Visual Studio Code are some of the more popular selections. Vim and Emacs are also options, but the new tools tend to support vi/emacs style editing while offering more extensive and expansive features.

OCaml Intro: You can have it all: Object-Oriented, Imperative, and Functional

Thu, 01 Feb 2018 11:27:47 -0500

YAPL

So why take the time to delve into yet another programming language? I find at worst, one can expands one’s knowledge of existing programming paradigms by studying the language design choices of other languages not used on a daily-basis. Best case, one discovers a new language that is rich in expression and productivity; thereby refining the productivity of the user.

OCaml

So, I tripped over this programming language in a rather random and circuitous path. I was watching a super-cool video visualizing how the Fourier Transform integral is constructed (by 3Blue1Brown). At the end of the video, the sponsor was a well-known, prestigious wall-street boutique, Jane Street, famous for hiring the best of the best in mathematics and computer science. So, naturally, I thought I’d take a closer peek at their website and discovered that they were big sponsors in OCaml as it underlies their trading and production environments. And down the rabbit hole I went.

GPOTD - Furry Lewis

Thu, 25 Jan 2018 16:58:00 -0500

New Blog Series: GPOTD (Guitar Player of the Day):

Featured Artist: Furry Lewis.

Aside from writing about technical matters, I enjoy writing about music and musicians from time to time. To that end, I want to kick-off a new series GPOTD which features a guitar player that you likely aren’t familiar with. Today at the end of my acoustic guitar lesson, my teacher pulled up some music by this lesser-known player of the American Folk Music Revival. And it sounded amazing! So, I thought I’d take a closer look at the music and the man.

Pothos - A New Take on Data-Flow Frameworks

Wed, 17 Jan 2018 11:13:11 -0500

Data-Flows… like a river

In today’s post, I thought I’d take a look at and discuss the Pothos toolkit, a work-flow tool that improves upon the design principles of gnuradio and enables real-time data-flow processes for real-time applications.

Using a MacBook Pro, an ettus N210 SDR, and an FM-antenna, I’ll show how easy it is to build an FM Receiver to listen to your favorite radio stations on your laptop. While it’s an expensive way to tune in to your local DJ, it’s a great demonstration of how to use this great kit (written by Josh Blum).

Crypto 101: A Brief Tour of Practical Crypto in Golang

Thu, 14 Dec 2017 10:38:41 -0500

Crypto 101:

Golang offers a rich collection of packages supporting cryptographic operations. From a beginner’s perspective, maybe too many offerings! I offer up an overview of what’s available and an introduction to some practical uses of cryptography in Golang. Implementation details are always critical when discussing crypto. We’ll discuss some general implications of making poor choices and how such choices can completely undermine any uses of these tools.

What’ in the box?

The top-level crypto package is comprised of a little over a dozen sub-packages that offer:

Channel Your Inner Gopher

Wed, 13 Dec 2017 11:44:07 -0500

Channeling your Inner Gopher - (Literally) Reflecting upon Channels

Many gophers are likely familiar with the communication paradigm, channels. An elegant solution to communicate (uni or bidirectionally) typed information among go-routines. In it’s simplest form, we declare as type-valued channel variable, make it, and then send and receive data through it. Easy enough!

package main

import (
        "fmt"
)

func main() {
        var simpleChan chan int = make(chan int)

        go func(c chan int) {
                // send important data to the channel
                c <- 42
                close(c)
        }(simpleChan)

        // receive data
        num := <-simpleChan
        fmt.Printf("got %d\n", num)

}

In our trivial example above, we create an chan int typed-channel and initialize it using make.

Once Upon a Reflection: Looking Deeper into Golang reflection

Mon, 04 Dec 2017 17:36:31 -0500

I often reflect upon my code…

One of the coolest features of the Golang programming language is the reflect package. As the package documentation states at the onset of the package:

Package reflect implements run-time reflection, allowing a program to manipulate objects with arbitrary types. The typical use is to take a value with static type interface{} and extract its dynamic type information by calling TypeOf, which returns a Type.

On the surface, that all sounds pretty straight-forward. But when you start to think about the types of objects (literally) that you might reflect upon, things can get interesting pretty quickly. It’s one thing to dynamically get the type of an object like an Int, and then extract it’s value. But what about dynamically getting access to Methods inside a struct and then calling it with values created dynamically from an a-priori signature, returning values and extracting those values programatically? Rather quickly, the power of reflection can become overwhelming and even confusion. Moreover, appropriate use-cases of reflection should be well thought out so that we aren’t simply getting too clever for our own good.

Brazilian

Sun, 03 Dec 2017 21:02:47 -0500

Brazilian Guitarists

Some of my favorite music on the guitar comes from talented Brazilian composers. Favoite among them is Heitor Villa-Lobos. Indiana University maintains a site dedicated to the man. For scholars interested in diving deeper, it’s a great source of information on the man and the music.

Go Get Interfaced: Enums in Golang

Sat, 02 Dec 2017 09:38:42 -0500

Golang, Interfaces, and Enums

So here’s a nice golang idiom that I ran across years ago that I found generally useful. Golang, unlike languages like c doesn’t natively support enumerations. Instead, constants typically are used when creating a list of enumerations. But, go is a strongly-typed language, so we can do better than simply using constants - we can type our enumeration with the use of a type declaration.

type DogState uint

By defining a type for our enumeration, we can consistently pass and return typed-values among our functions operating on our enumeration. Okay, that’s all well and good, but what happens when we want to go between uint values and string representations of those values; a commonly used paradigm when working with enumerations. One approach would have us write mapping functions that might switch among the values to return a string. Or, when going from a string name of an enumeration to the uint value, we might use a map[string]. That’s a doable implementation, but there’s an easier, and more idiomatic way.

Gogo

Wed, 29 Nov 2017 20:57:33 -0500

Here we gogo!

Years ago, I wrote an interesting article that I thought might be worth re-posting (and revising) here on my blog. For a while I got into programming in golang and in the early going (pun-alert!), there were a lot of idioms that were not well understood by a noob. One of those paradigms was channels, go-routines, and signals used simultaneously. Taken separately, they are more easily understood. But when taken together, there can be some confusion. In this article, I address how to properly establish a signal-handler and a channel to terminate go-routines when the user interrupts the program with a signal such as ctrl-c or kill(1).

Sagreras Book 2, Lesson 11

Tue, 28 Nov 2017 21:49:07 -0500

Etude Sagreras Lesson 11

Here’s my first cut at recording Sagreras Etude #11. Although the etude feels like it’s easy to play, recording it reveals an altogether unsatisfying experience when played back to the ear.

My goal is to show how the exercise evolves over time when practicing it with the intention of not just playing it as a site-reading piece, but rather practicing it with the intention of recording it with more attention beyond mere site-reading. Wish me luck!

Julio Salvador Sagreras

Tue, 28 Nov 2017 16:22:55 -0500

Études

Someone once asked…

How do you get to Carnegie Hall? Practice! Practice! Practice!

Well, I think the Amtrak is a better way for me to get there at this point in my life!

I’ve decided to spend time recording Sagreras etudes as I’m on a push to finish Book II and start Book III by March of 2018.

Stay tuned for

Recursion Revisited

Tue, 28 Nov 2017 15:23:02 -0500

Recursion, from more than one point-of-view.

A common programming idiom in computer science is solving a problem by self-reference, also known as recursion. In this post, we look at two different implementations of the same problem.

Solve a recursive problem in two different programming language paradigms

Let’s look at the solution to a simple problem, compute $f(x)=e^{x}$.

We will illustrate two separate solutions - one in a procedural language (python), and the other in a functional language (elixir).

Let’s start off with the functional language. Were does recursion come into play?

We define the function $f(x)=e^x$ as the infinite sum, $\text{ }f(x) = \sum_{n=0}^\infty{\frac{x^n}{n!}}$

In our solution below, we define two separate recursive functions, exp/2 and fac/1. What’s interesting to note here is how each of these functions has two separate definitions. This is an aspect of programming in elixir that elegantly uses pattern-matching to return different results depending upon the input. Our two functions nicely dovetail into the base-case and recursive case of a recursive algorithm.

For example, looking at exp/2, the first function definition returns 1 for any value of x (as indicated by the _ preceding the variable) and returns 1. This is the mathematical equivalent of $x^0=1\text{ for any }x$.

The second definition of exp/2 is the recursive case. for any value of $n\gt0$. Moreover, we define exp(x, n) as $\frac{e^x}{n!}$ + exp(x, n-1).

Similarly for the definition of fac/1 we see two definitions; one for $n=0$ and another for all values of $n\gt0$.