Programming on CyberSpy

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.

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.

Julia Intro

Wed, 07 Nov 2018 15:11:45 -0500

Juliaet, Wherefore art thou?

As Yoda once said…

> YAPL - yet another programming language. Learn something new, you must.

Why Learn Julia?

Julia was designed from the beginning for high performance. Julia programs compile to efficient native code for multiple platforms via LLVM. As such, it’s an interesting programming language to take a look at as it’s a serious contender for certain classes of programming problems; most notibly, scientific and data-centric analysis.

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.

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.

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).

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$.

Brew up some Elixir recursion

Fri, 17 Nov 2017 22:03:09 -0500

Recursion is recursion is recursion is recursion….

So how hard is it to go back to a programming language that you haven’t used for months that you only used for less than a year? Well, it took me a few more minutes than I anticipated, but in the end, I was succesful!

Tonight, I thought I’d take the simple idea of creating Pascal’s Triangle. A simple construction that creates a table of binomial coefficients for the binomial $(x+y)^n = x^4+4x^3y+6x^2y^2+4xy^3+y^4$. Notice the coefficients in our expanded binomial:

Visualizing the News: Grab your PILlow

Sun, 12 Nov 2017 21:32:23 -0500

A Picture’s Worth a Gazillion Bits

newsapi

This weekend, I tripped over a neat news REST-ful api called newsapi. Grab an API key and you’re off to the races.

There are tons of live headlines - News API can provide headlines from 70 worldwide sources.

There are basically two api endpoints:

Accessing the API with Python

newsapi can easily be accessed using a browser since the REST-ful method used is a GET method. But, accessing the api from the browser is limiting.

Making Heads or Tails out of Recursion and Combinatorial Math

Thu, 09 Nov 2017 21:27:05 -0500

GNU — GNU’s Not Unix

I thought I’d take a look at two topics at once and make some fun by mashing them together. Today’s topic is recursion. In computer science (and in math, although we call the equation a recurrence relation) recursion is an often misunderstood concept causing lots of panic and anxiety. In reality - it’s pretty easy once you wrap you head around the idiom.

What is recursion?

When we define a function in such a way that it calls itself, we’ve defined a recusive function. The most basic example is the Factorial function, $f(n)=n!$. We define the function recursively by defining it in reference to itself. So, recursively, we define $f(n)$ as:

Getting Visual With It

Wed, 08 Nov 2017 10:26:20 -0500

Time to Get Vizzy With It!

Like Will says:

Gettin vizzy wit it Na na na na na na na nana Na na na na nana Gettin vizzy wit it…

Plot thickens

Time to turn on the lights and see what our data objects look like when we turn them into visualized plots. Sure, we can use the print function to see the numbers within our numpy objects. Better yet, let’s turn our objects into pretty graphical images. To do so, we turn to the matplotlib library. An extensive library of plotting routines that easily allows us to render image plots into many different formats (png, jpg, pdf, etc…) - both onto the screen for quick visual inspection, or written to a file for general use.

Do the Numpy

Tue, 07 Nov 2017 15:36:43 -0500

Do the Numpy Dance, Is your Chance to do the Nump!

Sir Numpy says:

The Numpy Dance is your chance to do the nump Do the Numpy Nump, come on and do the Numpty Nump Do the Numpy Nump, just watch me do the Numpty Nump Do ya know what I’m doin’, doin’ the Numpty Nump Do the Numpy Nump, do the Numpty Nump

Start at the beginning: `NumPy`

The first library that we will investigate is numpy. Simply put, numpy allows us to represent mathematical objects like arrays and matricies of different datatypes and performs operations on those objects thereby easing the burden of writing the tedious code within your applications to do the mundane representations and operations.

Data Science with Python: Let there be Light

Sun, 05 Nov 2017 17:48:04 -0500

Data-Science - Clueless? No prob. We got you dude.

So you’ve likely heard all the hype about “data-science” - and if you’re not among the cool kids, it might be a wee-bit overwhelming to you. Where to even start? What does it all mean? How do you even begin to understand what you need to know to begin learning more and making progress in the field.

Let’s start off with a few definitions:

Conway's Game of Life

Fri, 03 Nov 2017 22:05:38 -0400

Conway’s Game of Life

In 1970, British mathematician John Horton Conway invented a cellular automaton called The Game of Life. This simple game is governed by its initial cellular state and four simple rules:

Any live cell with fewer than two live neighbors dies, as if caused by underpopulation.
Any live cell with two or three live neighbors lives on to the next generation.
Any live cell with more than three live neighbors dies, as if by overpopulation.
Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.

The rules are applied to all the cells in the grid, starting with the initial grid populated with the starting live cells. After many iterations, the grid comes to an end-state which can be unexpected given the initial seed state.

Teaching Python to Beginners.

Sun, 15 Oct 2017 15:51:42 -0400

Teaching Python to a total noob

How hard can it be!

Recently, I had the pleasure of becoming a tutor for someone needing to learn how to program for the very first time. Having been a programmer for over four decades (OAF), I was quickly reminded of how much accumulated knowledge we who are in the know take for granted. Although my knowledge of computer science, and programming languages in general is extensive, I used the occasion to revisit aspects of the python language that are less obvious to a novice.