$SCHOOL

• Actually getting to build a Lisp machine on an FPGA. My computer architecture professor has me tasked with implementing AIM-514 which shouldn’t be too hard but need to sit down and do it. There’ll be blog posts as I make headway and get something working to be sure.
• Pondering about a conj machine rather than a cons machine. The problem with LispMs from a modern standpoint is that the linked list representation of programs serializes fetching operations and imposes a single cycle order. The presence of a shared mutable environment also means that you can’t parallelize computing function arguments and soforth because they may have effects. I’m toying with some ideas derived from Clojure and my more static Clojure derivative Ox to try and envision an immutable environment machine where you could map evaluations out and fold them back in on multiple cores.
• Physics, Abstract algebra and other fun homework
• Developing a password reset unit for my fraternity’s homebrew website

Ox

• Toying with the idea of having lambda and proc. A proc is an imperative block which may mutate any argument. A lambda is lexically pure, that is it mutates none of its arguments and nothing it closes over and thus has no effects because our conception of effects is via one mechanism or another writing to “other” memory. As lambdas are pure, one can optimize or implement them however seems appropriate whereas the call stack and effect order below each proc must be guranteed.
• Still crunching through TaPL
• Dreaming off in my algebra class thinking about functions and types as sets and rings

I’m trying to build a good UI into version control software to answer the question, “what the hell happened here?”

The idea is that you’ll be able to open up a code file, mark some portion(s) of it as interesting to you, and step backwards and forwards through its revision history, seeing only those changes that affect the interesting portions of the file.

It’s been a long time coming because I’m stubbornly trying to write it in Haskell, but after a long, internet-free Labor Day weekend at my in-laws', I’m making good progress.

At work, doing another stub project, and probably picking a fight about equity and cap tables. Hopefully by October I’m either gone or compensated well for my burnout. The CEO is being pretty sheisty, whether by incompetence, cowardice, or malice. Surely, surely, it’s not too much to ask “Hey, who owns how much of us?”

Friends don’t let friends be early engineers. :(

Outside of work, I started a nice Elixir library for statistics with a friend. Got the CI and everything setup, and soon to publish roadmap and start development in earnest. There’re already a couple out there, but we don’t like their test suites or their ontology.

I’m trying to complete the Java API bindings for IPFS. We are hoping to use it for the storage backend in Peergos

1. Job hunting.
2. Trying to get back into learning Rust after a couple weeks of unrelated distractions.
3. Been thinking about trying to write a simple (read: brain dead) implementation of RIPv2 in Go on FreeBSD, just for funsies.
4. Maybe getting around to writing up a blog post about various “fine liner” pens and a few different journals I have tried, before settling on my current favorites: Staedtler pigment pens, and Leuchtturm1917 “dot” journals – Quo Vadis Habana is very nice too but no “dot” format (I liked the “blank” format here). Still looking for some nice tearaway paper pads – might try out a Clairefontaine pad since I like the Quo Vadis paper.

I’m clustering geospatial data using Scalding.

For work, I’m adding power consumption graphs to my video classifier app. Qt is impressive, but there’s a lot in there that’s servicing people with much different needs than mine, so wading through piles of cross-platform scaffolding to find a simple application development API is part of the fun. For certain values of the word “fun”.

For non-work, this is the week I switch to an org-mode workflow for everything; concomitant to that, I’ve been optimizing my keyboard and emacs layouts, and wishing for a USB HID that didn’t suck eggs. I’m also getting ready to fly to California for a week, which means leaving my wife with our three month old. I need to bring her a Mission burrito or something as a gesture of my undying appreciation.

Still trying to get MMIO changes merged into Rocket-Chip. Although all the assembly tests pass, Linux doesn’t boot anymore, and I can’t figure out why.

Got our next assignment for a class on virtual machines (the Java kind, not the VMware kind). We have to implement a bytecode interpreter.

decided to add a gui to pangrid to allow viewing, editing and interactive solving. experimented with various languages, currently settled in ocaml + labltk.

After failing miserably to implement anything practical with Elm, I’ve spent a bit of time researching PureScript. Unfortunately, while very tempting, it seems that all these projects (Elm, PureScript, GHCJS) are too new/rough/advanced for somebody without extensive FP experience. I don’t want to stick with CoffeeScript & Ramda but I might have to for the time being.

More or less done with client work for the foreseeable future (aside from maintenance/support) and working on yet another indie web run-your-own-server kind of thing.

Today I was tinkering with neo4j. It’s pretty slick, but my initial velocity has been lower than I’d like. The node adapters I’ve used so far have been painful, it seems in part due to neo4j 1.x->2.x. If anyone thinks I should spend the week diving into a different graph database, I’m open to suggestions!

This week I’m writing a generic wrapper for the IPFS client API in Scala / for the JVM here. The basic commands are complete and the remaining advanced commands should be plumbed in by the end of the week.

At work I’m continuing on drive management refactoring/rewrite.

Outside of work I started taking salsa dancing lessons and racing cyclocross. I had my first race last Wednesday and came in second out of ten. It was possibly the hardest 30 minutes I’ve ever spent on a bike, but a ton of fun. I’m racing again on Saturday, and possibly on Wednesday if I can arrange to leave work early.

Hopefully start on a responsive and interactive aircraft recognition guide in React.js, more as a way to learn React than because the project will be particularly useful.

For work, I volunteered to do a lunch and learn on Lambda Architectures, even though I know nothing about that. I’ve dug a few projects and articles, and I don’t know whether it’s already a thing of the past or not; if you guys have any pointers on the matter, please, I’m gonna need all the documentation that I need. :) The side-goal for this is to make me more comfortable in front of crowds. Part of me hopes that facing the fear I’ve been carrying since high school will eventually make me able to tame it.

For not-work, I added one tiny piece of functionality to my Jira CLI, I’ll probably do a bit of cleanup in that shortly, it needs some love. And then, probably back onto autoapi, even though I’m now asking myself questions about scalability, CRDTs, stuff of the like, and how I could make autoapi help with consistency across distributed nodes. Any pointers on those things would also be much appreciated; I know that in this here place lurks brains much more powerful than mine. Help me levelup, inhabitants of the Internet!

Outside of work, this week I am answering as many questions as possible for the new Rust FAQ, I am barely starting a Rust-based implementation of R7RS (with the eventual goal of being an embedded language in Rust, similar to the way Lua works with C), and I am working through reading Aaron Turon’s thesis: “Understanding and Expressing Scalable Concurrency.”

Improving performance of the Prometheus JMX exporter by adding a mbean whitelist as it appears that RE2 for Java is less performant for our use case.

After that I’ll be looking into improving how custom collectors are done in the python client, and building on that to create a parser for the text format.

Project for my local makerspace; they want a web service that showcases the First Friday Hackathons they and others host. Building it in Rails using Neo4j. Coming together really nicely, though there are still a few ambiguous details and requirements from sponsors.

Connecting contestants/users’s GitHub profiles to the service and allowing them to select project repos and submit them for scoring/voting; creates a running report of who’s doing what and winning with what for sponsors to look at newhires.

I work there doing internal development stuff, so I don’t feel bad using “company time” to do exploratory stuff on this project.

I’m working on adding webrtc support to a kademlia implementation here.

Trying to figure out ways of proving (or disproving) that Jenkins or TeamCity will perform sufficiently well for our ginormous test suites (every commit causes 75-125 test suites – not tests, suites – to be executed), while waiting for the much delayed new datacenter hardware to come online (and no, we’re not allowed to use the public cloud in the meantime).

Appalled at the way the Jenkins open-source project is being “managed” (soooo many pull requests, including some solid ones from Google, that have just been languishing for months, if not years), yet continually surprised that it’s so popular (and I don’t think Google’s Bazel will actually make much of a dent here, though I can hope).

Otherwise, preparing some conference & code camp presentations on Docker and the container ecosystem.

Last week:

• Worked with Ops to set up an internal npm repository with Artifactory. Scoped packages was a little painful, but it’s all working now.
• Worked on this interesting CSS challenge from @Irene.
• More obsessing about lean, value stream mapping, and Kanban.
• Visiting family over the weekend.

This week:

• Back to the internal CSS framework. I get to start using flexbox for real now. :-)
• Diving back into our legacy PHP codebase for some bugfixing.
• Hopefully writing that blog post I’ve been promising for the engineering blog.
• Continue chapter 5 of my steampunk novel.

Building a streaming ESRI shapefile parser for geospatial data in elixir. The experience using geotools on the jvm for geospatial stuff was appalling, so I’m hoping to eventually replace a bunch of garbage at work with this.