unCNCNTRTD | Brett Beekley

Programming Science (GScholar) Homebrew Games Projects: Losing Tic Tac Toe (github) Traffic Heatmap (github) Dynamic Resume (github) (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o), m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) })(window,document,'script','https://www.google-analytics.com/analytics.js','ga'); ga('create', 'UA-80723810-1', 'auto'); ga('send', 'pageview');

[uncncntrtd-blog]

Traffic Map Update

It might be time to find our own place after 5 wonderful years in Sawtelle. Emma is about to start a new job in Alhambra and we’re looking for somewhere that is good for both of our commutes.

I've been (very casually) working on a script to gather traffic data to help us determine where would be a good place to live. It’s now in a v1 state and ready to be used by any and all! Check it out on GitHub-- the readme should describe how to use it.

Now for some pretty pictures! The following is a contour map of estimated travel time to Emma’s new job at 7:00 am on a Wednesday aggregated with time coming back at 5:30 pm.

Next is the bike time to/from my job.

And finally the two combined!

Some commentary:

* There are some artifacts where the data point landed on a freeway. Driving duration is disproportionately low at these points and biking duration doesn’t exist (which I set to -1).

* The minima are pretty close to my job. My theory is that, since biking is slower than driving, the biking data curves down out the driving data.

* East Culver City is the equi-temporal area for our two commutes (but pretty far from a minimum)

* We’ll probably live in the Palms or Ocean Park areas since that would save us ~30-40 mins per day from our current location. Also we really like the locations (commute time isn’t everything!). 

[uncncntrtd-blog]

Traffic Map Mk 2

Updated to use contour lines and just generally be better. WIP here: https://github.com/beekley/TrafficMap/tree/refactor

Image above is Google Maps’ best guess for drive time to Alhambra at 8 am Wednesday morning.

[uncncntrtd-blog]

Raspberry Pi Balcony Lights

This has been a project in the making for months (years?) and it’s finally in a state I can call “done”. I now have a string of LED lights hanging above my balcony that can be controlled from a phone.

There’s still work to be done, including adding patterns that aren’t just sweeps through the rainbow. Now that this is something that can actually be used, I hope to keep up the work and continue contributing to it.

Also, I really liked the way they made our fig look:

Github project: https://github.com/beekley/PiLights

Video and screenshots: https://imgur.com/a/A3Z7iDl

[uncncntrtd-blog]

Dungeons & Dragons & Diners & Drive-ins & Dives

I started a new job a little over four months ago and, entirely coincidentally of course, I haven’t posted or worked on anything on github in over four months. Last summer and last year in general was a big sprint for personal projects and hobbies. I got a lot done but also got a little burned out.

But it’s (February) 2018 and time to get back on the horse! I have the first homebrew of the year ready for bottling tomorrow and it’s the first candidate for a batch we’re brewing for a friends’ wedding. Recipe here!

There’s a new project that has me really excited: I’m DMing a Dungeons and Dragons group at work. A couple coworkers and I were talking about podcasts and other nerdy media and naturally my favorite live D&D podcast (#TheZoneCast) came up. They said they’ve always wanted to play and I’ve always wanted to DM. We got it going and have a group of 9 who hop in and out of the party.

We’ve had three encounters and couple bookkeeping sessions to create characters and level up. I think it’s gone pretty well so far. Every session goes longer than I plan-- including one 5 hour marathon encounter one Wednesday evening. The players just keep getting more into it and that pumps me up.

There are a few logistical quirks with having a group of 9 characters. The party hasn’t and likely won’t ever be consistent, so we’ve been starting and ending each session at a home base-- an inn in Neverwinter called The Winter Rose. This is actually pretty nice since it bookends each adventure and gives the characters a familiar place to get to know. Another problem we’re still working on is how to share loot and info with characters who might not have been there for a previous session. We’ll figure it out.

And now, a little overview of the adventure so far.

Our story begins as many do in the Forgotten Realms, at an inn. Our heroes find themselves sharing a beer, perhaps their first together, when a half-orc approaches them and asks to join their party for the last day of travel to Neverwinter. They accept and head out the first thing the next day. Their new companion was not as friendly as (some of them) expected and led them into an ambush. Our heroes were victorious and made it to Neverwinter with a mysterious elven cloak and shiny black gemstone embedded in lockbox used as bait.

The gang then came across a looted merchant cart in the canals of Neverwinter. Follow a trail of goblins, they clear out a sewer lair led by a bugbear named Klarg and free a knight of the Protectorate named Sildar.

When the Protectorate tries to send a reward to the inn where the gang is staying, the knight is attacked by a mob of freedom-fighters. Our heroes (mostly) help the knight, Giles, and fend off the attackers. As a reward, they are given Sildar’s Protectorate-issued magical dagger.

More adventure (and possibly scheming by our heroes) awaits!

[uncncntrtd-blog]

How to use ES8’s Async (and Await) to write concise promise-returning functions

It’s no secret (nor surprise) that async/await is one of the most anticipated features of ES8/ES2017. While there are lot of great resources already about the magic of the await keyword, its unsung sidekick async hasn’t gotten the same attention.

If you’ve used async/await before, you know that async is what allows await to work and is required in the nearest-parent function declaration of any use of the await keyword. Without async, await would just block code execution. That would negate JS’s asynchronous nature, one of JS’s best features and the reason JS can be used server-side (e.g. in Node). In order to do this, async makes the function, well, asynchronous by making the function return a promise, allowing other code to continue running while it awaits.

The side-effect of this is that async makes writing promised-based asynchronous functions both simple and synchronous-like:

The promise returned by an async function resolves using .then() — just like any other promise — when the function returns, with the value that is returned — just like a synchronous function

The promise returned by an async function catches an error using .catch() when the function throws an error

Let’s say we have a function that returns a promise that resolves after it gets some data from an API. Using promises, this might look like the following:

const withPromise = () => {  return new Promise((resolve, reject) => {    request(‘https://google.com')    .then((data) => {      // Pass data to promise resolution      resolve(data);    })    .catch((err) => {      // Reject with error      reject(err);    });  }); }

Which requires instantiating a new Promise object, then calling .then, .catch, resolve and reject function. Promises require a lot of baggage to get them to work, not to mention a whole set of vocabulary unique to them.

Using async, we can achieve the same in a few lines

const withAsync = async () => {  try { return await request(‘https://google.com') }  catch (err) { throw err } }

Which not only is concise and reads just like synchronous code, but will return a promise just like the first snippet.

withPromise().then(data => console.log(data)); withAsync().then(data => console.log(data));

(The above snippets use request-promise, a module to make http requests that return promises. They’re also trivial functions that just wrap around the the request method. Also on Medium.)

[uncncntrtd-blog]

Combined Biking and Transit Directions

My Carless-in-LA Experiment has been underway for a little over two months now. And I feel great! I’m biking into work, walking to places more, ordering groceries from Amazon Fresh. It’s surprisingly easy. As long as I never leave the westside.

Despite popular perception, public transit in LA is fairly comprehensive, as long as you start and end your trip along a single line. It gets slow when you have to walk ~10 mins at each end, and wait for one or more transfers. I don’t live far from the Metro but it still takes me an hour to get to the Metro-adjacent Arts District.

But I have a bike! I can use that to shorten the walking durations, or even replace a multi-legged route with something sans-transfers that otherwise would have required too much walking.

So I put together a quick app that uses the Google Maps APIs to provide directions that combine both biking and public transit. It also compares how long Google says it would take to do the same route solely via cycling, driving or public transit. Biking+Transit is often within a few minutes of driving, or even faster at times with traffic.

You can play around with a demo here. Source is on Github.

[uncncntrtd-blog]

CICD Tech Talk

Continuous Integration Continuous Delivery and microservices by Brett Beekley Microservices, get it?

I talked about CI and CD at Codesmith last week. It’s super simplified -- only 10 mins -- but I hope it covered some of how and why it’s useful to build big things out of small things.

[uncncntrtd-blog]

I created a node app that takes in a Songkick event id and creates a playlist in spotify. And... it works! More to come.

Github: https://github.com/beekley/playlister

[uncncntrtd-blog]

Scrobbling through the years

Spotify lets your hook up your last.fm account to keep track of what music you listen to. I used a last.fm to csv service someone put together to grab my data, then sqlite DB browser to run queries on it. 

The first thing I did was get a list of the top played artist each week as long since July 2013, when I started keeping this data (summary/freqArtist.csv, on the github repo). Not a lot stands out just looking at that, but then I sorted the top artists by how many times they were the top artist of the week (summary/topArtists.csv). 

List of artists with >1 week on the top-artist-of-the-week list:

This is arguably a list of my “favorite” artists, since I both listened to them a lot-- enough to be top of the week-- and they stood the test of time-- being listened to over the span of several weeks. And I think the list is pretty accurate.

Next, I took a look at how much I listened to a few artists before/after seeing them live. 

I listened to some artists a lot leading up to the show, then much less immediately after (SOHN, Tame Impala), some that I didn’t listen to much before, then a ton after (Bonobo, Jon Hopkins), and some that I listened to for months before and months after (Eric Prydz, with some serious cramming right before the show).

The .db and ancillary files are on github if you want to see how I did this or judge my music tastes. I had to do a little manipulation of the raw last.fm data, since sqlite didn’t like the way last.fm formatted datetime (see queries/songs2.sql for how I created a view that solved this).

[uncncntrtd-blog]

I was talking with someone who couldn’t believe that I saw an engine-less Ferrari 308 GTB on craigslist for $5k. Hagerty’s historical prices show that, when I looked in mid-2013, that wouldn’t be unheard-of.

So Hagerty, what you’re saying is that I should invest my money in air cooled porsches? This site it too cool.

[uncncntrtd-blog]

Commuting Heatmap

I’ve made some more progress on my heatmap project using the Google Maps APIs and produced a couple cool maps of the sum of commute times for my girlfriend (to UCLA) and myself (to Long Beach) from locations across LA. 

Below are some of the maps. Scale is unfortunately not always consistent and I don’t have specific numbers (except where mentioned).

8 am Monday projected travel time. Travel to UCLA: Public Transit; Travel to Long Beach: Driving. When taking transit, it really pays to be close to your destination. The minimum is right around UCLA (and right around where we live!)

8 am Monday projected travel time. Travel to UCLA: Driving Travel to Long Beach: Driving. The scales on this and the above one are actually the same (the max deep-red is 5 hours of summed travel time). Minimum is pretty much in the same location as before, but the whole length of the 405 is pretty good. Below is the rescaled version to see detail a but better.

There are plenty more variations that would be cool to see, such as transit in both directions, or MIN(transit, driving), or MIN(transit, driving * some_pain_and_suffering_multiplier). But Google really doesn’t like this use of their API and I kept running into query limits. At >100 datapoints, I had to slow the process and add a 5 second delay between requests. This was very tedious and I ended up just letting some of these run while I went to the UCLA football game last night (Go Bruins!). I’m ready to call this project done-- at least for now.

This is available on Github, though I’ve killed my API key so you’ll have to BYOK. Note: Keep the dataset small and/or delay high.

[uncncntrtd-blog]

Asymmetry in Games

A few years ago, I had written an article called “Debunking Asymmetry”. I think that that piece makes some mistakes about how it framed some of the problems of asymmetric forces …

Speaking of asymmetry in games... 

I really liked this article, though I don’t agree with it in some places.

[uncncntrtd-blog]

Asymmetric Multiplayer

I dream about unmade games all time time-- on long runs, in the car, when playing other games-- and asymmetry is one of the things that pops up disproportionally often. 

I’ve always the social aspect of gaming (though not exclusively) and many of my most-played games are multiplayer in general and esports in specific. Looking at the multiplayers games I have loved and loved-less, I’ve noticed that the ones with staying power have at least some component of asymmetry.

To give a converse example, Rocket League is a very popular, highly competitive multiplayer game based on the simple goal of “get ball in opponent’s goal”. It’s a fantastic example of how a game with simple rules and few mechanics can be hugely difficult to master (irl Rocker League, soccer, is popular largely for this reason). It’s fast paced without feeling light and every goal is satisfying. 

But I just couldn’t get into it. Maybe I’m just bad at it and haven’t put in enough time to change that. Or maybe it’s just too symmetric.

Now looking at some of the esports I have known at love-- Counter-strike, Starcraft-- they have strong asymmetry, which I think gives them a level of depth, engagement, and replayability that symmetric games can’t match. Every round in CS:GO feels exciting and unique, since the terrorists (Ts) have to anticipate how the counter-terrorists (CTs) are going to approach to plant the bomb, while the CTs have to stay unpredictable in order to compensate for the Ts’ defender’s advantage. Even in a direct shootout, the weapons available to each side are different, meaning they have to employ different attack/defend strategies. Then at halftime, the teams switch and it basically becomes a new game with new rules, goals and strategies for each team.

Starcraft 2 is played entirely differently depending on which races are playing against each other. A high-level Protoss playing against Zerg looks little like the same player playing against Terran. As each player learns more about what the other is doing, they adapt their approach, keeping the game dynamic (to watch and play). Mirror matches (e.g. PvP) are pretty boring in comparison, since it either becomes a rock-paper-scissors of who chose which tech path best, or a race to do the same thing better/faster than the opponent.

Asymmetry can turn non-competetive games into something innovative and exciting. Keep Talking and Nobody Explodes is the first VR party game that I’ve played that’s actually designed to be a party game (tilt brush is actually really cool to play in big groups).

[uncncntrtd-blog]

Distribution of NYT Crossword Difficulty (according to Rex Parker)

We try to do every day’s NYT crossword at work (2+ month streak!) and we check to see what crossword enthusiast, Rex Parker, has to say about each. We often think they’re are harder than he rates them, so I wanted to see how even Rex’s “Relative Difficulty” was distributed.

Turns out it’s not bad. I scraped his blog for the past 1695 days and (brutishly) lumped each score into buckets. My methodology is below:

If the word “Easy” was in the difficulty, then add “1″ to the “Easy” column for that day; else blank

If the word “Medium” was in the difficulty, then add “2″ to the “Medium” column for that day; else blank

If the word “Challenging” was in the difficulty, then add “3″ to the “Challenging” column for that day; else blank

The average of non-blank columns is calculated in the “avg” column

This makes the assumption that Rex is regular in his descriptions of difficulty (he is most of the time, but not all), and that all posts are made by Rex (most are, but not all), and that something like “Easy-Challenging” means “Medium”.

Next, I want to see the distribution over time and the distribution per day of the week.

[uncncntrtd-blog]

Diplomacy: Because it’s not a real board game unless someone leaves in anger after 6 hours of “playing”.

People make fun of board-game-nerd board games (e.g. Agricola, Twilight Imperium, even some Catan expansions) because of the large amount of time spent learning the rules and setting the game up. I can confidently say that the ratio of setup:play time in Diplomacy is a very low 1:20! (30 mins setup/learning, 10 hours playing)

[uncncntrtd-blog]

First professional league match! NALCS Regional Qualifiers C9 vs NV

[uncncntrtd-blog]

Doing a little research on a new phone. Thanks, Google!