Today, Carlton Gibson posted a wonderful short programming question:
I love little questions like this, and instantly came up with a solution. However, before I shared what I came up with, I took a quick look at the answers, and saw a bevy of very creative solutions.
None of these felt like an awesome solution for me. I’ve had some similar thoughts on some related matters, and it felt like time for a blog post.
Continue readingI’ve always been fascinated with distributed systems. It’s awesome that although we haven’t seen much in terms of increase of processing power, but instead we are moving to multi-core commodity hardware and scaling horizontally across it. When I just started professionally programming, distributed systems just meant you had a handful of programs keeping in concert with each other of sockets, each doing different pieces of the solution. It was a simpler time.
Now, you’re talking about a much more massive scale. I contribute IoT and cloud services like AWS or GCP with the rise of accessibility for making distributed programs easy. There’s also a slew of tools that are awesome and specifically designed for managing distributed systems. Kafka for your messaging, Zookeeper for service management, Spark for Data Science, the list goes on. Even my favorite language, Elixir, is built with distributed systems in mind. But there’s a catch
Advent of Code 2016 Day 14 (Go)
Advent of Code 2016 Day 13 (Lua)
Advent of Code 2016 Day 12 (C#)
Advent of Code 2016 Day 11 (Groovy)
Advent of Code 2016 Day 10 (OcaML)
Advent of Code 2016 Day 9 (Factor)
Advent of Code 2016 Day 8 (c++)
Advent of Code 2016 Day 7 (Javascript)
Advent of Code 2016 – Day 6 (Julia)
Advent of Code 2016 – Day 5( Java 8)
Advent of Code 2016 – Day 4 (Perl 6)
Advent of Code 2016 – Day 3 (Clojure)
Advent of Code – Day 2 (Python 3)
Advent Of Code 2016 – Day 1(Haskell)
Start: 12/20/2016
Finish 12/20/2016
Language: Typescript
SPOILER ALERT: If you have any inkling, any whatsoever, to work on the Advent of Code…. DO NOT READ THIS BLOG POST. DO NOT LOOK AT MY GITHUB PROJECT. It is no fun if you’re not solving it yourself, and you’ll feel so much better about yourself if you can figure it out without looking up an answer. This blog post is not to give away the answer, but instead, is there for people to learn from.
As always, the following code is in my GitHub: https://github.com/pviafore/AdventOfCode2016
I’m not sure how to describe this challenge, as it was a bunch of math calculations to see when a bunch of interacting circles were in a specific position. It’s probably best if you go check out the problem yourself, as I really can’t describe it well.
interface Disc {
totalPositions: number,
initialPosition: number,
}
function* infiniteSequence(){
var index = 0;
while(true)
yield index++;
}
function* filter(iterable:IterableIterator, f:(number)=>boolean){
for(let item of iterable){
if(f(item)){
yield item
}
}
}
function toDisc(str:string): Disc {
const regex:RegExp = /Disc #\d has (\d+) positions; at time=0, it is at position (\d+)./
const matches = str.match(regex);
return {totalPositions: parseInt(matches[1], 10), initialPosition: parseInt(matches[2], 10)}
}
function isTimeAllowed(num: number, disc:Disc)
{
return ((num + disc.initialPosition) % disc.totalPositions) == 0;
}
function getAllowedPositions(iterable:IterableIterator, disc:Disc, discNumber:number ){
return filter(iterable, num => isTimeAllowed(num + discNumber + 1, disc));
}
declare function require(name:string);
const fs = require("fs");
const lines = fs.readFileSync("day15.txt", "utf8").split("\n");
const discs = lines.filter(s => s !== "").map(toDisc);
const allowedNumbers = discs.reduce(getAllowedPositions, infiniteSequence());
console.log(allowedNumbers.next().value);
function* infiniteSequence(){
var index = 0;
while(true)
yield index++;
}
function* filter(iterable:IterableIterator, f:(number)=>boolean){
for(let item of iterable){
if(f(item)){
yield item
}
}
}
const allowedNumbers = discs.reduce(getAllowedPositions, infiniteSequence());
console.log(allowedNumbers.next().value);
function isTimeAllowed(num: number, disc:Disc)
{
return ((num + disc.initialPosition) % disc.totalPositions) == 0;
}
function getAllowedPositions(iterable:IterableIterator, disc:Disc, discNumber:number ){
return filter(iterable, num => isTimeAllowed(num + discNumber + 1, disc));
}
Another real easy one, as I just had to enter in another line of input to my text file and my code still worked.
I give myself an A- for this one. Typescript was fun; I prefer static typing and it was still Javascript that I was familiar with. I didn’t dive deep enough to really understand what else Typescript can buy me, so that’s why its not a straight up A. I really liked my solution too, as I got to deal with infinite sequences and reducing filter functions over them.
Next up is Scala for Day 16. Back to the JVM for that one. See you then.
Advent of Code 2016 – Day 5( Java 8)
Advent of Code 2016 – Day 4 (Perl 6)
Advent of Code 2016 – Day 3 (Clojure)
Advent of Code – Day 2 (Python 3)
Advent Of Code 2016 – Day 1(Haskell)
Start: 12/7/2016
Finish 12/7/2016
Language: Julia
SPOILER ALERT: If you have any inkling, any whatsoever, to work on the Advent of Code…. DO NOT READ THIS BLOG POST. DO NOT LOOK AT MY GITHUB PROJECT. It is no fun if you’re not solving it yourself, and you’ll feel so much better about yourself if you can figure it out without looking up an answer. This blog post is not to give away the answer, but instead, is there for people to learn from.
As always, the following code is in my GitHub: https://github.com/pviafore/AdventOfCode2016
So I decided to take a stab at Julia this time around. I was doing some column based reading of text, and I thought Julia’s arrays on steroids might give me something.
I was happy with how nicely this fit together, let’s take a look:
function getHighestCount(chars)
dict = Dict()
for char in chars
dict[char] = get(dict, char, 0) + 1
end
return sort(collect(dict), by= tuple -> last(tuple), rev=true)[1]
end
f = open("../day6.txt")
lines = readlines(f)
chars = map(s -> split(strip(s), ""), lines)
reshaped = hcat(chars...)
columns = map(x -> getHighestCount(reshaped[x,:]), 1:length(reshaped[:,1]))
answer = *(map(c -> c[1], columns)...)
println(answer)
close(f)
That’s it, 16 lines of code.
Main processing part is straight-forward again (once you know Julia syntax).
f = open("../day6.txt")
lines = readlines(f)
chars = map(s -> split(strip(s), ""), lines)
reshaped = hcat(chars...)
columns = map(x -> getHighestCount(reshaped[x,:]), 1:length(reshaped[:,1]))
answer = *(map(c -> c[1], columns)...)
println(answer)
close(f)
First we read the lines in, then map a split over them so we get a whole bunch of char arrays. With 624, 8 byte arrays, I decided to hcat the values, so that I ended up with a 624×8 array of characters. Then, using Julia’s n-dimensional array slicing, I did this
columns = map(x -> getHighestCount(reshaped[x,:]), 1:length(reshaped[:,1]))
We’ll take a look at getHighestCount in a bit, but for now, just know that it retrieves the letter of the most frequency. So in essence, we are getting the highest frequency of a column of the original text.
Then we map over the returned tuples and use the * to concatenate all of them together
*(map(c -> c[1], columns)...)
Looking at getHighestCount, it was simply a dictionary that tracked frequency, and then sorted by the values in reverse order.
function getHighestCount(chars)
dict = Dict()
for char in chars
dict[char] = get(dict, char, 0) + 1
end
return sort(collect(dict), by= tuple -> last(tuple), rev=true)[1]
end
And that was it.
This part was almost laughably easy. I turned getHighestCount into a getLowestCount, and removed the rev=true argument in the sort. That’s it. All there was. It is great when all you have to do to gain functionality is delete code.
function getLowestCount(chars)
dict = Dict()
for char in chars
dict[char] = get(dict, char, 0) + 1
end
return sort(collect(dict), by= tuple -> last(tuple))[1]
end
I’m not going to pretend I understand a lot of Julia’s n-dimensional mathematics, but I can definitely recognize how it would be a boon in numerical computing. At first, I wished there was a few more things in the standard library (I spent a lot of time looking for group_by, chunk_by, frequency counts, and so on) but in the end, I couldn’t find them (they may have very well been there), and it led me to what I think was a very Julian solution.
I grade myself as an A on this one. I solved this in about an hour and a half, and that included skimming back through 7 more languages in 7 weeks to refresh myself on Julia.
Next up, it looks like Regex will help me out again, so I’m going to take a stab in ECMAScript 2016+/Javascript.
Start: 12/5/2016
Finish 12/6/2016
Language: Perl
SPOILER ALERT: If you have any inkling, any whatsoever, to work on the Advent of Code…. DO NOT READ THIS BLOG POST. DO NOT LOOK AT MY GITHUB PROJECT. It is no fun if you’re not solving it yourself, and you’ll feel so much better about yourself if you can figure it out without looking up an answer. This blog post is not to give away the answer, but instead, is there for people to learn from.
As always, the following code is in my GitHub: https://github.com/pviafore/AdventOfCode2016
This day, the goal was to try and figure out which rooms out of a list were valid by matching up a checksum with their most frequent characters. I really liked this idea. What I didn’t like was the fact that I chose Perl for this. I had never written Perl before in my life. And I never want to ever again either.
Continue reading
We’ve all heard the term “Wolf in Sheep’s Clothing” before. It represents some malicious entity masquerading as something benign, hoping to gain some advantage. The other day, I came across something quite the opposite when working on HAPP. I was stuck on a problem for a long time, but I ended up with a solution born out of that dilemma. I found a “Sheep in Wolf’s Clothing”.
A lesson I learned a long time ago in software architecture is the idea that sometimes a deferred architecture is the best. Whenever you are faced with indecision in an architecture, it typically is a place where you should encode a customization point, because if you aren’t sure of it now, you can bet you will want to change it later.
The same thing comes up with roadblocks and problems. It takes some mindset shifting, but you have to treat these as opportunities in disguise. I was working on HAPP, trying to get voice commands to work on my new Linux Laptop. However, for those of you who have debugged audio on linux, it requires years of arcane black magic to make heads or tails of what you need. I spent a few days trying to get things to work, using pulseaudio, midi controllers, jack, and so on and so forth to no avail. I want to be able to run HAPP on my linux computer, but now I was finding I couldn’t.
The opportunity here is that maybe my input was too constrained. Yes, the whole point of HAPP is to voice-automate my house, but maybe I needed to expand. I allowed input to be handled in a separate thread from the console. I now had a way to inject commands, test them out, and see the results all though my console.
This opens up a whole new world of ideas. Rather than just making voice commands, I abstracted out the code to allow multiple input methods. Now, I could consider unit testing commands, without needing voice. I could distribute the voice recognition to other processing devices in my house ( like a phone, or what a great idea to start learning about something like a Raspberry Pi). Eventually I would like to have a distributed voice recognition network, so this was a great first step. This also provided a catalyst for me to create a config file to indicate which input methods are valid, which I will need for other things.
So next time you come across a problem, think about what opportunities it presents. Find a way to be creative and let that evolve your program. Don’t skimp requirements (I still have my main voice server working on Windows), but let the pain points guide you in what could be flexible. You may just find your own “”Sheep in Wolf’s Clothing”
Pat Viafore 