At the company I work for, we recently launched a pixel-y status board called "Display" that immediately caught my eye:

It runs a custom app on the Tidbyt platform and was a successful Kickstarter in 2021. While it has a lot going for it (dimmable display, mobile app configuration, SDK and 3rd party apps, beautiful wood case), at $180 USD, it's still more than I want to spend.

A tweet I saw about it featured an animated character on the display which got me interested immediately. I dove right into a spritesheet animation tutorial on Adafruit. The basic idea is to use a single bitmap image that has all the frames on it, then use the displayio.TileGrid class to conveniently cycle through the frames. The finished demo:

Here's some notes on how I did it:

• A TileGrid represents a grid of images taken from a source bitmap. The bitmap is partitioned into equally sized "tiles", and any of these sub-regions can be shown as an image in the TileGrid.
• To choose a tile from the bitmap to be shown on a TileGrid, and to reference the bitmap's tiles are indexed in row-major order. For example, suppose we have a bitmap that is 256 x 256 pixels, and we define the tile size to be 64 x 64 pixels. Each of the bitmap tile regions would be numbered from 0 to 15.
• The tutorial encourages you to use a vertical spritesheet, because it's easy to create and simplifies indexing. But a horizontal one works just as well. For example, my spritesheet lives in a bitmap of 160 x 32 pixels, so each one of the five tiles is 32 x 32 pixels. Since we only need to display one frame at a time, we make the TileGrid have a width and height of 1:

bitmap = displayio.OnDiskBitmap(filename)
sprite = displayio.TileGrid(
    bitmap,
    pixel_shader=bitmap.pixel_shader,
    width=1,
    height=1,
    tile_width=32,
    tile_height=32
)
frame_count = int(bitmap.width / 32)

• To make the sprite move back and forth across the screen, I update the sprite's x member, keeping track of the current direction and when it's moved off-screen. In addition, I mirror the character when it is walking in the opposite direction by toggling the sprite's flip_x attribute: this eliminates the need to have a second, flipped version of the spritesheet.

def advance_frame():
    global current_frame
    current_frame = current_frame + 1
    if current_frame >= frame_count:
	    current_frame = 0
    sprite_group[1][0] = current_frame

    if sprite_group[1].x < -32 or sprite_group[1].x > 64:
    	sprite_group[1].flip_x = not sprite_group[1].flip_x
    direction = -1 if not sprite_group[1].flip_x else 1

    sprite_group[1].x += direction

One of my pandemic projects has been to decorate my office with a pixel theme (see this Twitter thread for photos). In the evenings, I like to browse artist portfolios, hunting for just the right pieces to hang on the wall.

Stephen Osborne made a series of illustrations a few years ago imagining the "cyberpunk Toronto of the future" called Neodot City, which is also his handle on Instagram. I was delighted by the local angle and aesthetic, and bought two of them on his RedBubble shop. Here's what one of the 8" by 12" metallic photographic prints looks like:

Looking for an interesting way to display this print, I came across a video by Adam Bowie describing How To Hack a Lightbox From an IKEA Ribba Frame. The basic idea was to take apart a shadow box, tape LED light strips to the sides of the frame, then illuminate the artwork by diffusing the light from the interior.

Here's a sneak peek of the final result:

The first step was a trip to Michaels, a massive arts-and-crafts chain store to get the 11" by 14" shadow boxes ($25 CAD for two) and mattes with 8" by 10" openings ($7 CAD each):

Michaels actually sells 11" by 14" mattes with 8" by 12" openings, but they were out of stock everywhere. Without an angled matte cutter, I used an Olfa snap-blade knife to (poorly) enlarge the 10" opening to a 12" long one.

I didn't need the shadow box spacer insert so I took that out and also bent the flexible points out of the way:

Then, I mounted the print to the matte using masking tape. This was a mistake. It isn't meant to hold any weight and doesn't even stick that well. It might be okay to just check alignment, but peeling it off started to remove bits of the matteboard material.

In the YouTube video, Bowie used LED strips powered by a wall plug, but I wanted the freedom to be able to place the frame anywhere, without a cord hanging out of it. There are plenty of LED light strips out there, but the ones I ended up getting were from lightinthebox.com ($10 CAD each). I got the ones powered by three AA batteries, with warm white LEDs, in a 2m length (since the shadow box perimeter was 2 x (11" + 14") = 50" = 127cm). The strips have adhesive on the back, and I also folded the framing points back to keep them out of the way.

One thing to consider is where you want the battery pack to end up (more on this below). I definitely wanted it at the bottom, so I started by taping the LEDs closest to the battery pack, beginning at the bottom of the frame (relative to how the artwork is being displayed). Here's the finished lights:

I also replaced the masking tape with paper tape (Duck Brand EZ Tear Paper Tape, $10 CAD) cut into narrow widths:

This is also a good time to check the illumination of your artwork, to see if photograph or artwork is too thick, or if LED lights are bright enough to shine through.

To allow the light to illuminate the interior, I needed to ensure the backing board was positioned higher than the light strips. I initially tried stacking flat, self-stick rubber bumpers (that you stick to a cabinet door so it doesn't slam onto the frame), but I needed four or five, and the adhesive wasn't very strong.

Instead, I ended up trimming pieces of styrofoam, and gluing them to the backing:

Shaving styrofoam pieces is messy, and I had a hard time making each one the same height. But it was close enough to get the backing board flush with the edge (close enough anyway!):

For aesthetic reasons, I didn't want to be able to see the individual LEDs, so it was important to diffuse the light inside the shadow box. I used foil tape ($5 CAD for 30 ft) on the inside of the backing board. You could also add an opaque vellum or acrylic sheet, but I wanted to avoid anything thick, as I didn't have a lot of depth to work with.

The last thing to figure out was where to put the battery pack. There is an on/off switch on the opposite side of where the battery door is. If I put the battery pack on the outside of the frame, the battery door needs to face outwards, and the whole thing offset to access the switch.

I tried this idea using a Command Strip to tape the pack to the back of the frame, threading the wire through a small notch:

However, when putting the frame on the wall, it tilted backwards too much:

I decided to try storing the battery pack inside the frame. I cut out three sides from the backing board to make a door, then used paper tape to reinforce the hinge. The width was enough to slip in the battery pack, and the height was just slightly less so the pack wouldn't fall out.

If you're wondering why there's a little tape flag attached to the battery pack, it's to make it easier to remove it to change the batteries:

I was initially worried that you would be able to see the shadow of the pack inside the frame, or that it would block too much light, but it wasn't a problem.

Once I was happy with the positioning, I taped the backing board to the frame using more paper tape. This would block any light leakage, and more importantly, held the frame and its contents together, so it could be hung.

That's pretty much it! I was quite pleased with the result. The neon signage in the composition looks really good when it's illuminated.

A neat thing about the MatrixPortal after you install CircuitPython on it, is that it's super easy to start writing projects. Plugging in the board mounts a USB mass storage device called CIRCUITPY:

Whatever functionality you need, you just copy from the Library Bundle on your host computer into the lib folder on the board. Your project code lives in the root folder; here, it's just called code.py. Any changes to the filesystem cause the MatrixPortal to restart and execute the new code.

This may seem a bit weird if you've never done embedded programming before, but it's because you don't have a shell (or even a traditional operating system!) running on the board. So no access to handy tools like pip or Homebrew to fetch dependencies. It also means that you'll have to pay more attention to inter-library dependencies.

Anyway, I tried out one of the simple projects, Network Connected RGB Matrix Clock. Here are some of the things I tweaked:

• I customized the clock with a BDF font downloaded from https://github.com/Tecate/bitmap-fonts
• To make the clock display 24-hour time, I commented out the lines that subtracted 12 from the hours. I also adjusted the label text to always format the hours with 2 digits.
• I used the adafruit_fancyled library with a custom palette to slowly change the colours of the display.
• Don't forget to get a free Adafruit IO account, and include your username and key in secrets.py. matrixportal.network.get_local_time() makes a network call to the Adafruit IO time server to get the time.

One thing I couldn't figure out is where the output of debug print() calls go. What is stdout on the board hooked up to!?

I found the answer in the Welcome to CircuitPython guide: the board exposes a serial console over the USB interface. The docs suggest using Mu, a simple Python editor that auto-detects the MatrixPortal and has built-in support for the serial console.

But since I'm a die-hard vim user, I wanted to connect to the serial console using screen.

I recently decided that my home office should be "pixel" themed (think low-resolution, 256-colour graphics from the 1990s). I got inspired after buying and framing this "pixorama" poster. I even ostentatiously re-arranged my office furniture, so meeting participants would see something more interesting than closet doors.

To include some actual pixels into my office, I researched displays that could show a clock or the weather or animated GIFs. The leader in this space seems to be Divoom: their Pixoo-Max display is a slick 32x32 LED matrix controlled by a mobile app. However, there's no public API, so you're limited to what the app can do.

Another option was the LaMetric Time, a beautiful, minimal clock with big chunky LEDs designed for displaying a little text. It's got a documented API, an app market, and lots of contributed IFTTT integrations. But $200 USD is pretty steep for something like this.

There were a couple of dead ends: the PIXEL LED Art Frame started out on Kickstarter but no longer appears to be sold. The Glance Clock is mostly a clock, with a Bluetooth-enabled display that syncs with your watch; it's a bit pricey and not very customizable. The Pixel It is a rough clone of the LaMetric Time, put together from parts you buy yourself, and seemed too complicated for me.

I browsed Adafruit but a lot of the projects using LED matrices seemed daunting, especially since I know virtually nothing about hardware, don't know how to solder, etc. Finally, I discovered the Matrix Portal M4:

This excerpt from the website was what sold me on this board:

Folks love Adafruit's wide selection of RGB matrices and accessories for making custom colorful LED displays... and Adafruit RGB Matrix Shields and FeatherWings can be quickly soldered together to make the wiring much easier.

But what if we made it even easier than that? Like, no solder, no wiring, just instant plug-and-play? Dream no more - with the Adafruit Matrix Portal add-on for RGB Matrices, there has never been an easier way to create powerful internet-connected LED displays.

Sign me up! Err, I mean, place an order from Elmwood Electronics, a Canadian source for Maker electronics, including Adafruit products. This is what I bought:

• 64x32 RGB LED Matrix - 3mm pitch ($59 CAD)
  The pitch is the distance between the LEDs, so it dictates the overall dimensions of the matrix. I wanted mine to live on a bookshelf, not in the windshield of a truck.
• Adafruit MatrixPortal M4 ($35)
  This is the board that drives the LED matrix. It has a CPU, flash, SRAM, WiFi coprocessor, accelerometer, and a bunch of other hardware goodies that are, uh, good to have.
• Raspberry Pi 4 Power Supply in White ($13)
  The power supply makes the LEDs light up. It has a USB-C connector, and I chose white to match my bookshelf!

Tonight, I followed the Adafruit setup guide, and got the MatrixPortal connected to the LED matrix, and installed CircuitPython 6.3.0 on it.

Whee, what fun! Next, I'll try to get a demo app running to ensure the panel is working, and to familiarize myself with the development environment.

I was recently asked to lead a live baking class online. My mind immediately went to a setup that went way beyond a phone on a tripod. I wanted:

• A camera feed of me presenting
• An overhead camera feed showing the countertop and my hands
• An external microphone to capture me talking
• A Bluetooth headset for me, so I can hear participants as I'm moving around
• High quality background music
• On screen indicator of the current track

Solution

I knew the basics of Zoom, FaceTime and Google Meet, but the above configuration went beyond what I've done in the past.

Happily, I was able to get it all working. I'll share my journey with you below, in three sections:

1. Video: Use OBS software to composite multiple camera feeds and other on-screen elements, publishing it as a virtual camera for Meet
2. Audio: Use Soundflower and Ladiocast to combine and route multiple audio sources to the livestream and to headphones
3. Overlays: Use a browser extension to scrobble from YouTube Music to Last.fm, then have OBS show a hosted website that fetches the current track

I'm using a Mac, so these directions won't be directly applicable if you're using Windows or Linux, but will hopefully point you towards your own solution.

Video

Open Broadcaster Software (OBS)

I first heard about OBS from our CEO last year:

That sounded like what I was looking for, so my first step was to download OBS Studio (Version 26.1.2, 64-bit) onto my MacBook Pro (macOS 11.2.3).

Running OBS for the first time should trigger the Auto-Configuration Wizard. If not, find it in the Tools menu.

OBS can work directly with many streaming services, but Google Meet isn't one of them. Select I will only be using the virtual camera (more on what that means in a moment). Click Next to continue, then click on Apply Settings to complete the wizard.

Now, you should see the main OBS screen. Yours might not have anything under Scenes, Sources, or Audio Mixer.

If you've read ahead the OBS Quickstart guide, it recommends downloading an extra app to capture system audio. Ignore that advice for now.

Scenes

In OBS, a scene is a surface on which you arrange the sources you want to display: camera feeds, web pages, images, text, etc.

Create your initial scene by clicking on the + button under the Scenes section at the bottom of the window, giving it a descriptive name.

Cameras

MacBooks have a built-in front-facing camera, so I'm going to use that as the one filming me. Let's add it as a video source in OBS, by clicking on the + button under Sources again, choosing Video Capture Device:

Make sure Create new is selected, and name it Built-in Camera. On the next screen, you'll actually select the physical camera to associate with this device. On the Device dropdown, click on FaceTime HD Camera (Built-in) (yours might have a slightly different name). You should see a live preview of the feed immediately:

After clicking OK, you'll see your new source in the Sources list, and your camera feed surrounded by a red box on the scene canvas. Feel free to play around with resizing and repositioning it:

For the overhead camera, I'm going to use a Logitech C930e webcam, mounted on an adjustable desktop suspension boom. In OBS, add another video capture source, naming it something like Overhead Camera. Select the webcam in the Device dropdown, then click OK. On the main screen, you'll see your second camera feed in a red box. Play around with resizing and repositioning it.

To change which feed is on top, drag the order of the sources or click the up and down buttons.

Virtual Camera for Google Meet

So far so good. Let's try it out in a Google Meet call. While you could share your OBS window or entire screen, the quality wouldn't be great. The better way to do this is to take advantage of the "virtual camera" in OBS. That broadcasts whatever is currently being shown in the current scene as if it were a camera connected to your laptop!

To see what I mean, in OBS, under the Controls section at the bottom, click Start Virtual Camera.

Next, from a browser logged into your Google account, visit the URL g.co/meet, and click New Meeting | Start an Instant Meeting. At the bottom of the screen, click the ⠇(three dots) button to open More Options. Click on Settings, then Video. In the Camera dropdown, select OBS Virtual Camera:

Close the settings window, and voilà!

Look at that! Your Google Meet camera is now a live composite of two video feeds. Back in OBS, play around with the sources in the scene, and watch it reflect immediately in your Meet call. Invite a friend (or use another device) to join the call, so you can see what it looks like as a participant.

From here, you can experiment with adding more sources to your scene. For example, a Text source could display your ingredient list.

For more help, browse through the OBS Wiki especially the Sources Guide.

Audio

Turing our attention to the audio now, we'll be speaking into a microphone, and also playing music on the computer. That's two input sources. We want our participants on the livestream to hear both, and maybe listen in on just the music through our headphones: two output sinks.

Most software can only pay attention to audio from one input at a time, and apps usually can select one output at a time.

See (hear?) the challenge we need to resolve?

After much searching, I stumbled upon Megan Lavengood's blog post. She describes a detailed solution for teaching music classes online. The directions below are adapted from her article.

Capturing Mac Sounds as Input

First, we're going to route audio output from the computer back to the computer so it can be used as an audio input. You might see this referred to as "desktop audio capture". It seems straightforward, to allow people on a call to hear what your computer is playing, but this ability isn't built-in to Macs.

Install Soundflower (2.0b2) by carefully following these directions from the developer.

Afterwards, you'll have two new Soundflower devices. Click on the volume icon in the menu bar:

To check that things are working, set your Sound Output to be Soundflower (64ch), as shown above. Then, play some music on your computer (from the Apple Music app, Spotify, it doesn't matter). Naturally, you won't hear anything. Open System Preferences | Sound | Input, select Soundflower (64ch), and verify that the Input level is showing activity:

What Soundflower is doing, is capturing any music being sent to its output device, and making it available as an input device.

Directing the Audio Output

Next, we're going to install a utility that will let us choose any of our audio inputs, and assign them to any of our outputs. We'll have a nice interface to select which outputs go to the livestream, and which ones we'll monitor.

Ladiocast is available, free, from the Mac App Store. Go and install v0.13.0 then launch it.

This is Ladiocast's mixer interface. The left side is where we'll configure all of our inputs.

For Input 1, we're going to select Soundflower (64ch), the device our Mac is outputting sound to. Underneath the volume slider for this input, you'll see buttons representing which outputs this input should be mapped to. Select Main.

For Input 2, select the microphone you'll be using (external or built-in), then click on Main underneath.

Turning to the right side, let's configure our outputs. Under Main Output, select Soundflower (2ch). This will be the device that the livestream will use as its "microphone".  It will contain the combined audio from whatever is playing on the computer (Input 1) and the microphone (Input 2).

For Aux Output 1, select your wired or Bluetooth headphones. You'll note that we didn't assign any inputs to this output. If we want to monitor the music, we could click on Aux 1 underneath Input 1. Unlike teaching a music class, I don't want to hear the background music for my baking tutorial, but this allows you to toggle it.

Your mixer should look something like this now:

Go ahead and play some music on your computer, making sure your Sound Output is still set to Soundflower (64ch). Talk into your microphone too! Verify that the Main Output monitor bars are moving in accordance with the inputs. If you've selected Aux 1 to monitor the music in your headphones (as I've done in the animation above), you should see the monitor bars of Aux Output 1 move in time to the music.

But Doesn't OBS Do Audio Mixing?

OBS does support sound mixing. However, configuring your sound independently via Soundflower and Ladiocast gives you more flexibility, so you don't have to use OBS when you just care about the sound. For example, if you want to use a single camera in Meet (the normal setup), but have background music playing, you don't need to involve OBS.

Testing Audio in Google Meet

We're ready to test the audio component of our setup. Keep the music playing, and start another Google Meet instant meeting. In Settings | Audio, select Soundflower (2ch) as the Microphone, and your headphones as the Speakers. If it's available in your organization, make sure to turn off noise cancellation, as that will interfere with the clarity of the music.

Have someone else join your meeting. Start talking in your microphone, and ensure the participants can hear both the music and your voice clearly. Make sure you can hear what they are saying as well.

Experiment with adjusting your computer's output volume, and Ladiocast's volume sliders and buttons, to get the right levels for the inputs and outputs.

We're almost done!

At this point, if you combine this audio setup with the virtual camera from the previous section, you have a pretty fancy Google Meet livestream setup: multiple camera feeds and background music, with great quality audio for both you and your viewers!

But let's not forget the icing on the cake, a little chyron showing the track that's currently playing!

Overlays

OBS supports other kinds of visual sources like text, the contents of a file, an image, a video, or even a web page. We want to show something like this at the bottom of our scene:

Now Playing on Last.fm

After a fruitless search, I quickly discovered that YouTube Music doesn't provide a way for apps to query what is currently playing.

However, xaymar's Now Playing Overlay using Last.FM looked promising. It makes use of Last.fm, a social music site, where users share what they are listening to, affectionately known as "scrobbling".

The overlay reads the current artist and song from Last.fm, and displays it with album art and animations. Then, using an OBS Browser source, we can display the web page in our scene.

Scraping for Scrobbling

How do we get the current track from YouTube Music though? Last.fm has an entire support page about this. I downloaded Web Scrobbler for Chrome, a browser extension that will scrape what's playing from dozens of music services and publish it to Last.fm.

After installing the extension, I signed up for a free Last.fm account, then authorized the extension to talk to Last.fm. Web Scrobbler's options should look similar to this afterwards:

Now, open up a browser tab, go to music.youtube.com, and start playing some music. Open up another tab, log in to last.fm and scroll down to your Recent Tracks. The currently playing track should be reflected:

Displaying a Site as an OBS Browser Source

Back to the now playing page by xaymar. His blog post has customization details, but the most basic setup is to create a browser instance in your streaming software pointing to his web page, with your Last.fm username.

Here's the step-by-step. From the main OBS screen, add a Browser source:

Give it a name like "Now Playing Overlay".

In the Properties dialog, set the following values:

• URL: https://stream.xaymar.com/nowplaying.html?user={your_last_fm_username}
• Width: 1024
• Height: 128
• Leave everything else unchecked
• Leave the default Custom CSS

If you still have music playing, and scrobbling to Last.fm, you should see something like this in the scene:

That little rectangle is actually a live web page that will keep displaying whatever track you've scrobbled to Last.fm! Try moving it around, resizing it, etc. and watch what happens a few seconds after the song changes.

Awe-some!

Conclusion

So, in the end, I achieved what I set out to do: broadcast a Google Meet livestream that could show me and my countertop, let viewers listen to music and my directions, and even see what song was playing.

What Does the Physical Setup Look Like?

I have an old Thunderbolt display connected to my MacBook via a Thunderbolt 3 (USB-C) to Thunderbolt 2 Adapter. It's sitting on a table behind the island.

The display serves as a USB hub, into which my Logitech webcam and Blue Yeti mic (both using USB-A connectors) are plugged in.

The webcam is mounted on an adjustable stand with extra height provided by some matzoh boxes.

On the day of the event, I put YouTube Music, Ladiocast and OBS on the laptop's display, and the Google Meet browser tab on the external display. This let me see everyone else on the big screen, and let me manage anything that might need adjusting on the MacBook's display.

Wow, Is It Really This Complicated?

Yes? I don't know. But this is what I came up with.

Obviously, if you don't need a second camera or an overlay, you wouldn't even need OBS. You might want decent background music for your meditation class or whatever, and the Soundflower/Ladiocast combo is enough.

I was surprised with the complexity of displaying a "Now Playing" overlay in a livestream. If you know of an easier, less roundabout way, I'd love to hear it.

Tips and Troubleshooting

• YouTube Music will not play in the background unless you have a Premium subscription, for example, a family plan. If your music keeps cutting out, this might be why. You can use a different service that is supported by the scrobbling extension.
• If the music is intermittent or poor quality, check to see if Google Meet's Noise Cancellation is enabled. Turn it off. Leaving it on will significantly degrade anything that isn't speech.
• If your voice sounds like a robot to listeners, try switching the microphone you're using. This happened to me with a Bluetooth headset mic, and went away when I used the Blue Yeti. Just remember to adjust which microphone is being used for Input 2 in Ladiocast.
• Keep your MacBook plugged in. Streaming, compositing, etc. is CPU intensive, and will drain battery very quickly.
• If space permits, connect an external monitor so that you can have OBS running on your laptop, and your Meet call on the other display. That will let you see more of the apps, and reduce switching apps while you're busy presenting.
• Test, test, test! I spent a couple of days setting up the software and hardware, and roped my wife and kids into helping me check the setup. You want to figure out the glitches well in advance of your event.

by Kai-Fu Lee
Houghton Mifflin Harcourt, 2018

Lee, a seasoned researcher and executive, promotes a pro-China, pro-tech view of the world, and how artificial intelligence will change it in a pervasive way. He describes the gladiatorial startup world of China, and how its companies have leapt ahead of Silicon Valley in many aspects of digital life, from government services to ecommerce to social interaction. By the end of the book, a Stage 4 lymphoma diagnosis leads him to an epiphany, that his narrow, tech-focused world view alienated him from his family, and the importance of thinking about software's impact on society.

Chop Suey Nation: The Legion Cafe and Other Stories from Canada’s Chinese Restaurants

by Ann Hui
Douglas & McIntyre, 2019

On a road trip with her husband, Hui tries to figure out why chop suey exists in almost the same form across the vast expanse of Canada. She presents vignettes of restaurant owners and their journey to small towns, helping her to more deeply understand her own parents' struggles as immigrants. Although she spends too much time on the logistics of the journey itself, I, as a 1st-generation Chinese-Canadian, found this to be a thought-provoking read, providing a voice to people whose stories aren't usually told.

Deep Work: Rules for Focused Success in a Distracted World

by Cal Newport
Grand Central Publishing, 2016

I didn't need the first part to convince me that being able to focus and concentrate on creative work was necessary in our modern economy. But the core teachings of part two of the book really resonated with me, on eliminating distractions and practising to work on difficult tasks, and I liked how Newport provides multiple strategies. Many of the anecdotes are about the habits of successful, well-resourced CEOs and philanthropists, but he doesn't provide any specific guidance for those of us who have to raise young children.

Thinking Inside the Box: Adventures with Crosswords and the Puzzling People Who Can't Live Without Them

Adrienne Raphel
Penguin Press, 2020

This enjoyable book zigs and zags from the origins of the crossword, to attending a national tournament, to the challenge of constructing a puzzle, and even a day-by-day chronicle of a crossword-themed cruise. You get a good insider's look at the people and process of producing the print and online New York Times crossword. Raphel lost me a bit when she strayed into describing some of the literary and cinematic depictions of cruciverbalists.

The Language of Food: A Linguist Reads the Menu

Dan Jurafsky
W.W. Norton, 2014

This delightful journey into how our English words for food came about is filled with fact after interesting fact, written in a very personal and engaging way. One of the themes that Jurafsky touches on, is that the world is more connected culturally than we may think, as many of the foods or customs we've adopted in North America, had their ancient origins in the Middle East. Some highlights for me, were his Yiddish and Cantonese examples, as well as the regression analyses he applies on menu writing.

All the Birds In The Sky

Charlie Jane Anders
Tor Books, 2016

As a tech person, I was delighted by the extremely accurate descriptions of technology in this book, without any "techno-babble" or simplifications. Anders weaves an intricate tale set in San Francisco that incorporates witchcraft, young love, hubris, and humanity's relationship with technology and Mother Nature. Her attention to detail, turns of phrase, poignant observations, and wry dialogue all contributed to this being a superb and unique addition to the science fiction corpus.

I re-discovered a love for long-form written works this year, but did not achieve my ambitious goal of reading one book per month this year.

Paper vs E-reader

Because I am trying to reduce the distraction that a phone causes, I bought a Kobo Clara HD e-reader in April.

I chose this model because:

1. It's not an Amazon product
2. The Wirecutter recommended it
3. Library books can be borrowed on it
4. It lets you sync your Pocket articles.

Now, on to the books:

The Attention Merchants

by Tim Wu
Knopf Doubleday Publishing Group, 2016

A chronicle of 150 years of advertisers systematically grabbing our attention, and selling it for profit. From Parisian theatre posters, to radio and TV dramas, to e-mail, video games, and smartphones, I was rapt with how advertising and entertainment have blended together so seamlessly. With ever more time willingly spent in front of screens, and more surfaces being infiltrated by ads, we need to keep our guard up, and ensure that our valuable attention remains our own.

The Martian

by Andy Weir
Crown/Archetype, 2014

A brilliant, funny, and imaginative story about a man who has to figure out how to keep himself alive when he is stranded on Mars. If you have an interest in space exploration, and chemistry or math, you might enjoy the verbose calculations and descriptions of how much oxygen or water is required to go from point A to point B. My 8-year old son and I enjoyed this book together, but we found it tedious at times, especially since I've seen the movie adaptation.

River Town: Two Years on the Yangtze

by Peter Hessler
HarperCollins, 2010

Hessler, a wonderful travel writer, spent two years in the early 2000s living and teaching in a small town in China while serving with the Peace Corps. He is a keen observer, and uses his struggle to learn how to read Chinese as a metaphor for understanding the rhythms of daily life in a rural village, his status as an outsider, and interactions with students. This book was on a list for anyone wanting to understand modern China, and I look forward to reading the two subsequent books he penned on living in the country.

Bad Blood: Secrets and Lies in a Silicon Valley Startup

by John Carreyrou
Knopf Doubleday Publishing Group, 2018

This book was a real page turner, and I told anyone within earshot about the story of Theranos, the now-defunct corporation that claimed to have invented a rapid blood test using a pinprick of blood. CEO Elizabeth Holmes was able to con so many prominent and successful people, who really wanted to believe in her charisma and vision. The anecdotes about the way she ran the company, how Theranos installed barely functional equipment in drug stores, and their pathetic attempts at cover-up, were a sickening reminder that snake-oil salesmen come in many different guises.

Room

by Emma Donoghue
Back Bay Books, 2013

This was an impulse read, a book that was lying on a shelf at a house we rented this summer. I had watched the movie a few years ago, but did not realize the printed narrative was told from the perspective of the 5-year old captive. Donoghue gives really distinct voices to the boy and his mother, and there is lots to read between the lines, in this absorbing and heart-wrenching tale.

Small, Sharp, Software Tools

by Brian Hogan
Pragmatic Bookshelf, 2019

Pragmatic Bookshelf often releases beta versions with a site to report errata, so I gave the manuscript a pretty thorough read as it was being edited. I'm extremely comfortable using CLIs, and parts of the book were very basic, but this book still had new tricks to teach me. My main takeaway is that many UNIX tools have decades of history and still endure, so it definitely pays to spend time to learn (and learn more!) about how to use them.

Three Squares: The Invention of the American Meal

by Abigail Carroll
Basic Books, 2013

One of my favourite genres is food history, so this book's stories of what and how colonists in America ate, was fascinating. It walks through how mealtimes changed as workers shifted from an agrarian to a faster-paced, sedentary office life, and how industrial food production and advertising started exerting a stronger influence on families. I wish Carroll would write an afterword, as I would love to hear her commentary on the rise of "cloud kitchens" and food delivery in the 21st century.

I continued looking into data science and machine learning this year. In March, I completed all five courses of the Deep Learning Specialization from deeplearning.ai, and also spent time playing around with ML Kit for Firebase:

At the beginning of the year, I also started planning a career shift, from Android mobile development to something within the broad discipline of data science. I collected advice from attendees at the Toronto Machine Learning 'Micro-Summit', pored over countless blogs and forums, had discussions with many colleagues, and did some serious thinking about whether I would have the time and energy to pursue a part-time graduate degree.

To find the right fit, I spent time messaging and chatting with various department heads, having lunch with various leads, spending several Hack Days with people from data teams, and even shadowing a colleague for a few hours. In the end, I was fortunate enough to be able to make a transition into a Data Scientist role within Shopify's Data Science & Engineering organization. One of the benefits of working in an organization that is supportive of your personal growth, is the possibility of such "internal movement".

I look forward to a year filled with learning, and being able to start making contributions.

Speaking

I spoke at a number of Android conferences in 2018:

• Android Summit (Washington, DC): How the Command-Line Can Give You Superpowers (video) (slides)
• Ohio DevFest (Cincinnati, OH): Not Har Gow: Using Custom Models with ML Kit (video) (slides)
• AndroidTO (Toronto, CA): How the Command-Line Can Give You Superpowers (video) (slides)

I got a lot of mileage out of the command-line talk as I had opportunities to incorporate feedback from our meetup and from work. Each time I presented for an outside audience, I continued to refine and polish it. I even gave it as a webinar!

Speaking of the meetup, we grew our membership to over 900 people, and hosted 8 events this past year. The most exciting news was our inclusion into Google's GDG Platform, so we are now known as GDG Toronto Android.

I'd like to continue giving talks in 2019, and will be looking at more non-Android focused conferences.

Writing

Sadly, I don't have much to show in this area. Despite indicating an interest in previous years to practise writing more, I suffer from such severe writer's block, that it takes me weeks to write a few hundred words. Even submitting something for CfPs and then editing my talk drafts takes me weeks.

Perhaps I should try to write a short blog post every month, to practise the craft of writing and figure out how I can get words down faster.

Reading

Another area where I expressed a desire to devote more time to, but did not succeed at. Discounting some fiction I read while I was on vacation, I spent my reading time on The New Yorker, and the weekend New York Times and Globe and Mail.

Projects

Running my own websites allows me to keep a toe dipped in the worlds of web development and system administration. In particular:

• This blog lets me play around with managing DNS records with Hover, running a droplet on DigitalOcean, administering an Ubuntu Linux virtual machine, configuring nginx, securing connections with Let's Encrypt, checking uptime with Uptime Robot, and publishing with the wonderful Ghost blog platform.
• My baking blog is a static site hosted on GitHub Pages, built with Jekyll. This means tinkering with Ruby, HTML and Sass to make the site look the way I want.

Resolutions

I don't usually make them, but this year, I want to. I will try to:

• Read one book per month
• Write one technical blog post per month

This year marked the 9th anniversary of AndroidTO, the largest Android developer conference in Canada. The organizers of GDG Toronto and Symbility Intersect put on a full-day lineup of fifteen 30-minute talks in the MaRS Discovery District.

There weren't a lot of sponsors at the tables outside the auditorium, but two community groups, GDG Toronto Android, and Android Pub Night, gave away stickers. Lunchtime was handled via Ritual, with attendees receiving a credit to go purchase a meal from a local restaurant. As in previous years, there was a live DJ helping with speaker intro/outro!

I was honoured to be accepted as a speaker during the morning half. Here's a summary of the talks I attended:

Accessibility @ Scale

(Slides)

Mallika Potter (@mallikaandroid) discussed how making apps accessible is a largely untapped area, despite its very large market. She emphasized that accessibility is not just beneficial for people with chronic conditions, or who are born with disabilities, because anyone can sustain a temporary impairment that requires accommodation.

One of the key points she made was that notifications and cues should have more than one sensory component. For example, a visual status bar notification should be accompanied by an auditory signal (and vice versa: avoid sound-only notifications, and provide a visual cue also). Another example is ensuring that videos contain captions.

Making changes incrementally and focusing on low-hanging fruit is important, because even small improvements can make your app usable for those that were previously unable to. Some quick fixes include using TalkBack to check for navigation issues, changing text size and density to look for clipping and crowding problems, and adding descriptions to UI controls.

Auditing Your APKs Like a Black Hat Hacker

(Slides)

Kristina Balaam (@chmodxx_) provided a whirlwind tour of how to think about security in Android apps, from the perspective of a malicious actor. She covered reverse engineering, attack surfaces, and best practices in app development.

Many of the tools of the app security trade are not used by everyday app developers. These include Apktool, a tool that can disassemble compiled APK resources (like string and image resources, manifest files, and more); dex2jar; smali (an assembler/disassembler for the Dalvik executable format); and JD (a Java bytecode decompiler and analyzer). In addition to these low-level tools, Kristina mentioned drozer, a security testing framework to identify vulnerabilities in apps and devices, and a playground app called Diva, to get practise in hacking.

In listening to her describe a lot of the security problems that befell major app developers over the years, I got the feeling that it's really hard to get security right. Operating systems like Android get a host of new features every year, and keeping up with best practices is never-ending. Do watch her presentation to learn more about how other companies got it wrong, and the things you should start doing to get it right.

How the Command-Line Can Give You Superpowers

(Slides)

Over the last few years, I have encountered a lot of developers who only know Android Studio, and rarely spend any time in the command-line. Having grown up with Commodore BASIC, DOS, and Linux, the command-line is second nature to me. This summer, I decided to put together a talk focusing on how CLI tools can be helpful to Android developers.

This talk is in its 3rd or 4th iteration, as I've given versions of it several times this year, refining and updating it each time.

Dynamic App Modules

(Slides)

Alex Saveau (@SUPERCILEX) gave us a deep dive into Google's new app serving model, Dynamic Delivery, and the associated App Bundle upload format. The subtitle of his presentation was "Building for Billions", and is apropos because the goal of dynamic delivery is to allow users to download optimized APKs containing only the code and resources they need. No more one-size-fits-all distribution!

We learned about how app bundles are an evolution of split APK support, but takes it further by allowing the Play Store to automatically extract configuration-specific resources (e.g. screen density, CPU architecture, etc.) and feature-specific components into individual APKs, then sign and build them for you. We also learned about how apps need to be organized into base and feature modules, and how to handle older devices that don't support dynamic delivery.

Applying Rx Best Practices To Your Architecture

(Slides)

Benoît Quenaudon (@oldergod) gave a talk describing how to implement a Model-View-Intent architecture using RxJava. He has written about managing state with Rx before, and has given a talk at Droidcon NYC on this subject as well.

This is a pretty advanced talk, adopting an architectural pattern that isn't easy to wrap your head around, implemented using a library that has an even steeper learning curve. His main points were to avoid side effects so that functions are pure and easy to test, and to maintain a single unidirectional stream of events.

If you are new to MVI and RxJava, there are many other resources out there to learn the basic concepts from (my favourites are this series on MVI by Hannes Dorfmann, and this free ebook on Rx by Matt Dupree). If you're looking for complete examples, you'll find Benoît's port of the Android Architecture TODO example in this repository very useful, as well as this one by my colleague Etienne.

Adventures of an Android Developer in iOS Land

(Slides)

Yun Cheng (@yuncheng13) does double-duty as an iOS and Android developer. In learning Android, she observed some differences in the tooling and language, and shared them with us in her talk.

Her first set of grievances were around Xcode, Apple's IDE. From its shortcomings with navigation and refactoring, to its poor autocomplete implementation, Yun could not think of any benefits of Xcode over Android Studio. Despite having alternative IDEs for writing Swift code (including JetBrains' AppCode), writing GUIs still requires Xcode to generate the machine-readable XML layouts. Speaking of Swift, she shared that it was nicer to use than Objective-C, especially with the latter's block syntax. (But perhaps closures are just as confusing?)

Testing is one area where Android developers take mocking for granted. However, Swift does not allow reflection. Despite having fewer hardware and OS versions to test on, iOS developers still struggle with code signing and TestFlight. Android developers have it much easier: build an APK, give it out.

Building Conversational Experiences with Actions on Google

Nick Felker (@HandNF) walked through how to develop Actions on Google, custom software to extend the functionality of Google's virtual Assistant.

There's a lot of "tech" that goes into the Assistant: NLP, AI, speech processing and synthesis. Being able to leverage all of that, and developing your own experience from a template in just a few hours is pretty magical. However, it's a pretty different mindset: you need to consider that people talking to the Assistant expect a real-time response, and may be having other chats at the same time. Conversation design involves thinking about all of these things so that interaction is natural and intuitive to users. And, since some connected devices have screens, existing visual UI/UX principles also need to be considered.

As Amazon did with Alexa, Google is encouraging developers to try writing Actions by offering incentives (Cloud credits and a T-shirt) if you publish before the end of July 2019.

Machine Learning: Life After the Tutorial

Kyri Paterson spoke about machine learning, data quality, and some of the mistakes companies have made when adding artificial intelligence to their products. She pointed out that ML algorithms are only as good as the data they are trained on, and that practitioners should be aware of pitfalls such as mislabelled data, feature scaling, correcting for bias in data sets using techniques like SMOTE, and data sanitization.

From the prejudice in Amazon's AI recruiting tool to the racist utterances of Microsoft's Tay chatbot to the implications of police wearing facial recognition glasses, there are many examples of imperfect technology powered by AI in our world today. Understanding what ML can and cannot do, and knowing that algorithms (and not just humans) can be biased, must be part of what data scientists consider nowadays.

Poor Programming Patterns and How to Avoid Them

(Slides)

Alice Yuan (@Names_Alice) gave several examples of code smells and poor programming in apps that she's worked on, and outlined solutions for them. A nice touch was her own hand-drawn illustrations on many of the slides.

The first issue she discussed was the classic inheritance vs composition design principle. A poor choice makes adding new features difficult, and leads to duplication of logic. Another poor choice was choosing an event bus over the observer pattern, as the former does not enforce that a listener is around when an event occurs. On Android, there are many choices available to implement observers and listeners (including LiveData and RxJava).

Alice also pointed out data consistency issues when attempting to cache values inside fragments, putting model-dependent logic in view layers. Her suggested solution was to use the repository pattern, a central source-of-truth for models. Note that the Jetpack guide to app architecture demonstrates a repository. Finally, she also chastised anyone not writing unit tests for their app. In her case, it was tightly coupled, poorly designed code that made it hard to test. By separating concerns, and using a good architecture pattern, she was able to improve understandability, promote code reusability, and ensure her code was testable.

Flutter: In Real Life, For Real People

Two of the organizers of AndroidTO, Mark Reale (@markreale) and Jeff Corcoran, closed the conference with an amusing talk about their journey of learning Flutter. Mark was convinced to starting learning Google's latest mobile SDK after listening to a podcast, but quickly learned that Google's own tutorials needed a lot of polishing.

Having two major mobile platforms to develop for means double the cost and effort for companies wanting apps on iOS and Android. Flutter is the latest attempt to solve the problem of building apps for two platforms from a single codebase. Mark and Jeff have hosted Flutter Study Jams in the past, relying on the educational resources that Google and Udacity provide. They quickly found that many of the materials were out-of-date and incomplete. It was not the case that you don't need any programming or development experience to get started with Dart and Flutter, despite the website's claims.

Mark put together a repository that outlined his journey, and Jeff ended up publishing an open-source conference app which was used for AndroidTO itself. (Watch the video to hear why there was no iOS version!)

Closing

Proceeds from this AndroidTO went to support the SickKids Tech&Innovation initiative. I also learned about a charitable organization in Canada called the Upside Foundation, aimed at early stage startups, for them to donate equity, which is then distributed to registered charities upon a liquidation event.

A few weekends ago, I attended a DevFest jointly organized by GDG Cincinnati and GDG Columbus. Ohio DevFest 2018 was held in the Tangeman University Center at the University of Cincinnati, and offered a full day of talks, organized into four tracks. Many local speakers and attendees from across the state showed up at 08:00 to get the day started.

I skipped the first time slot of the morning, to do some last minute tweaking on my slides!

Not Har Gow: Using Custom Models with ML Kit

(Slides)

I'm fortunate to be encouraged and financially supported by my employer to speak at conferences. Although Shopify does use machine learning in its core products, my interest recently has been at the intersection between ML and mobile.

For my talk, I wanted to walk through how to use a custom TensorFlow Lite model with ML Kit. One way to demonstrate this, is to take an existing image classification sample and retrain the underlying model. In my case, I used pictures of dumplings. For the live demo, I purchased dim sum from a local restaurant, brought some on-stage, and streamed the app's live camera view with the help of Vysor.

Getting feedback is usually a gift, so I was pleased when several people took the time to approach me to ask some questions, both after my talk and at the after-party as well.

Refactoring: Saving Your Code From Itself

(Slides)

The first presentation I attended was by Lorien Rensing (@MakerLorien). She spoke about concrete techniques to refactor code, as well as quantitative methods to measure code maintainability.

One of the oldest books on this subject is by Martin Fowler, who just completed the 2nd edition of Refactoring: Improving the Design of Existing Code. Lorien quoted a concise definition of refactoring given by Fowler:

a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior

We reviewed a number of code smells, things that are possibly indicative of a deeper problem: long methods (hard to understand), poorly named symbols (not meaningful), duplicated code (maintenance headaches), and poor organization.

Coming from a non-Microsoft world, the maintainability index was new to me, but it's a metric that's been in Visual Studio for over a decade. It complements other measurements like cyclomatic complexity and SLOC.

I also learned about the Gilded Rose Refactoring Kata, an exercise to give you deliberate practice in refactoring. Also, JetBrains offers a code-analysis and refactoring extension for .NET developers called ReSharper.

Slaying the Long-Lived Branch

(Slides)

As a fan of small, focused pull requests, I looked forward to hearing this talk by Kat Fairbanks (@DerKatzenbar) about dealing with branches that incorporate a significant amount of work. In her particular case, she was asked to review 3 weeks of work over 90 commits, which, when deployed, led to a production error requiring a rollback.

It's obvious that a massive set of changes is painful to review, and even the most experienced reviewer can miss something in the sea of code they are examining. Kat brought up the human element in code review. Feedback can be hard to give to someone, and a conscientious reviewer might be reluctant to point out a problem, because it would result in another QA pass.

Some sensible strategies Kat suggested were not adding small, unrelated changes to a pull request; keeping refactoring separate from feature work; and finding a balance between fewer, but larger PRs, and the cognitive overhead of many small, unrelated PRs.

On the topic of rolling out a huge set of changes into production, we learned about a few ways to reduce risk when doing so. One was the concept of feature toggles, deploying functionality that can be turned on and off. Of course, adding conditionals introduces its own complexity.

Another way to roll out large features is to do so incrementally, by breaking down large features into smaller chunks, and introducing them one at a time. Kat recommended reading GitHub's blog post about how they upgraded their 10-year old code base over 1.5 years to the most recent version of Rails. (Shopify's engineering blog also has an article about how we upgraded to Rails 5 last year.)

Large Scale Resource Planning and Management

I went to this session mostly out of curiosity, as I know nothing about how "the Cloud" is actually built. Arathi Mani spoke about how Google's datacenters are physically planned, built, and managed.

One of the first slides in her deck raised several dozen questions related to datacenters including: Where should you build it? Where do you get power from? Do you use existing hardware or design your own? Consider that every new feature in every web app (e.g. Gmail) needs its compute and storage needs to be forecast, in order to plan when to build another datacenter (each of which costs $200 million USD). Arathi mentioned an example of when a forecast is wrong, the launch of Pokémon Go.

There were so many eye-opening facts and figures in this talk:

• Google's 3-year trailing capital expenditure is a staggering $40 billion
• Physical pen tests are conducted annually
• Collectively, the world's datacenters use 2% of all electricity (3% according to this Forbes article)
• AI can be used to improve Power Usage Effectiveness, the ratio between energy used to run computers versus cooling and other overhead

This talk felt like a promotion for Google's datacenters, but I still enjoyed learning about what it takes to operate at Google's scale.

Panel: Non-Traditional Paths to Technology

The last session I attended featured a panel of women and men who didn't land in tech in the "traditional" way, i.e. study computer science or programming at school. Their previous careers included receptionist, audiologist, marketer, legal assistant, and sheet metal fabricator.

I learned about some of the local programs to get you started on a tech career:

• Cincy Code IT Bootcamp
• i.c.stars, which offers a free bootcamp to qualified interns
• Operation Code, a non-profit that helps the military community

With so much instructional content available online, someone raised a question about whether a bootcamp or MOOC was better. Of course, the answer completely depends on the learner, but someone pointed out that in-person interaction, like learning with other students, and networking with people at meetups, can be important. While changing careers requires learning new skills, there are character traits such as grit, resilience, being curious, being confident, etc. that can help you succeed in whatever you do.

Fireside Chat

I wandered into the last event of the day, which turned out to be a casual Q&A with all of the speakers.

Some tidbits from our discussion:

• Don't stay at your first job too long (not for 9 years!)
• You have the ultimate responsibility for your own career
• Everyone thinks machine learning is the next big thing

After Party

The day ended with beer and pizza at the wonderful Rhinegeist Taproom. I didn't know that Cincinnati has an almost 200-year history of breweries, thanks to waves of German immigrants arriving in the mid-1800s.

Last week, I attended and spoke at Android Summit, in Tysons Corner, VA, just outside of Washington, DC. This was my first time at the annual event, which was celebrating its 4th anniversary.

The conference had two development tracks, a design track, and a testing track. During the introductory remarks, Michael Jones reiterated the message that apps are made collaboratively by people in different disciplines, and encouraged us to mingle and attend sessions from different tracks.

This year, proceeds from the event went to Women Who Code, and, with an intentional reduction in swag, Android Summit was able to donate over $8000 to this not-for-profit.

I thought the conference was really well run, with lots of dedicated volunteers staffing the registration table, herding attendees between the two floors of the hotel, and ensuring the A/V was set up for the speakers. The venue is directly connected to a really large mall which had an enormous Italian restaurant where we had the speaker dinner. Nearby, I was within walking distance to a 24 hour grocery, several restaurants, and a Metrorail station.

Keynote

Claire Slattery opened the conference. She is the Director of Performance at Speechless, which performs shows to help people become better presenters. Her keynote was called, Creative Release: Why Improv Thinking Matters for Development. The title refers to applying techniques from improv theatre, such as listening with curiosity, making others look and feel good, and taking care of yourself, etc. to our work.

Speechless' scientist-in-residence is Charles Limb, who has studied what happens to our brains when musicians improvise (TEDx talk, PRI podcast). She encouraged us to work on changing the "volume" in our brains, by turning up our self-expression and creativity, and turning down the voice of our self-critic.

Claire led us through a number of small group, stand-up exercises, where we practised celebrating mistakes, listening actively, building presence, and creatively connecting our work and our interests.

Positive Sum — Developing Mobile Apps with Privacy as a Baseline Need

As I am transitioning to a new discipline soon, I decided to attend mostly non-development talks. This talk, on privacy and GDPR, was given by Noble Ackerson (@nobleackerson).

Noble went through a few "privacy by design" principles: consent (asking for permission to collect data), agency (allowing users to control their data), progressive disclosure (collect data as you need it, not all up front), governance (being able to monitor what's collected).

While it may be a burden to be careful with data, privacy principles align with good UX in most apps, so that we can gain trust from our users by being transparent with how their data is being used.

During the Q&A, I learned of several people to pay attention to who are very involved in privacy:

• Ann Cavoukian
• a conversation about privacy with Edward Snowdon, Noam Chomsky, and Glenn Greenwald

Excellence Principles that Produce Quality Mobile Solutions

I went from the design track over to the testing track for my 2nd talk of the day. This one was given by Elvin Rakhmankulov, Head of Mobile Competency at EPAM.

As a developer who has worked on teams practising varying levels of "process", it was interesting to hear from a seasoned veteran. Elvin breezed through a few list-heavy slides with best practises accumulated after working on dozens of client projects.

Some things I learned about were:

• the C4 Model for describing software architecture. I've struggled with trying to balance between high-level vs. detailed diagrams of how the pieces of an app fit together, so this framework looks helpful.
• architectural katas, practice exercises for software architects
• a "continuous inspection" dashboard for software quality called Sonarqube. It presents the results of a lot of static analysis tools on your code and revision control usage.
• a nicer way of describing using your own apps (which Wikipedia attributes to Jo Hoppe):

drinking your own champagne

Kotlin Multiplatform

This topic is a perennial favourite amongst mobile developers, as it deals with how to build apps for iOS and Android from one codebase. Kevin Galligan, from Touchlab (and organizer of droidconNYC) sped through the state of Kotlin Multiplatform. It was based roughly on this post.

Not only can iOS (native) and Android (JVM) be targeted, but Kotlin multiplatform can render to JavaScript as well. Kevin went on a bit of a rant about a lot of the unhelpful discussion around cross-platform development, that often compares apples to oranges, missing the more nuanced reality.

His own contribution to the field is knarch.db, an implementation of SQLite for iOS/macOS that is similar to the Android API, written in Kotlin/Native. In general, at this point in time, library support is what's missing, so this is a good area for open-source contributors to get involved in. Still, there's enough support available, that he built the Droidcon NYC app for Kotlin multiplatform.

Material Design Interactions

I went back to the design room to watch Amanda Legge, Principal Experience Designer at Capital One, do a live demo using Principle. In around a half an hour, she built three animated and interactive components that you would find in modern Android apps.

Her demos included making a circular progress spinner with in/out animations, replicating a parallax effect from Google Calendar, and a complicated drag interaction that modified text opacity and scaled another element.

One significant limitation of Principle is that it does not directly output files (e.g. XML layouts, drawables, animations) that can be imported into Android projects. By contrast, Zeplin can now generate resources and snippets for Android.

You can find more Principle tutorials on Amanda's YouTube channel.

How the Command-Line Can Give You Superpowers

I spent the next time slot polishing my slides, before giving my talk. I've uploaded the slides and the video recording will be available soon.

Ghost in the Machine

My colleague, Etienne Caron, discussed ARCore and his experiments with 3D printing and augmented reality.

Inspired by the android-robocar project, Etienne started with a Junior Runt Rover. He used Fusion 360 to design a frame, and a low-cost 3D printer to realize it. This allowed him to strap on a steroscopic camera and other components.

Then, he wrote an Android app to calibrate the vehicle's motion and track it via a marker. Then, he could tap at a point on the phone's viewfinder, to make the car roll to that spot!

The source code for this project and other VR and AR experiments can be found at https://github.com/kanawish/mixed-reality-toolbox

Closing Keynote

Nitya Narasimhan (@nitya) closed out the conference with Self Care for Developers: Defense Against The Dark Arts (slides), a serious topic presented with analogies from Harry Potter. Due to technical difficulties and delays, she had to accelerate her already-rapid speech and compress her talk into 20 minutes!

She shared a report from the APA titled Stress in America which highlights that uncertainty about the future, and work, are major sources of stress for Americans.

The connection to Harry Potter was interesting: J. K. Rowling was diagnosed with depression, and her illness inspired dementors. Nitya contrasted various evil powers in the books, with their defenses, and made analogies with how we can protect ourselves against sources of stress.

She outlined various strategies for combating stress. First, knowing the enemy is key: some acute stress makes you more resilient, but episodic or chronic stress wears you down, and the cumulative wear and tear on your brain reduces your ability to cope with future uncertainty.

Stress triggers come in many forms: environmental, physiological, physical, social. She suggested we remove time-based triggers by spending 30 days to set new habits, whether it be spending time to eat regularly, getting more sleep, or exercising more. For space-based triggers, declutter your environment (whether home, work, or online) by discarding, hiding, or blocking those sources.

By refocusing, we can cultivate habits to slow down. For Nitya, sketching and food preparation were tasks that helped her to calm down. Another good tip was to "ally-up": finding people who know you, who can cheer for you, or to run interference for you.

One practical tip to help build self-appreciation was to practice saying things to reinforce your sense of self-worth, e.g. when congratulated, just say "Thank you", without following up with any disclaimers or self-deprecating remarks.

Finally, she gave a constraints-based analogy to help us devise our own self-care strategy: think of a suitcase as holding all your mental baggage. If someone makes a stressful request of you, think about whether you have room to spare in your suitcase. If not, just say, "I don't have space for your request".

Software Development

New Skills

I'm pleased that I was able to expand my knowledge of the Android development ecosystem this year:

• Model-View-Presenter: the Logo Maker app gave me an opportunity to look into this architecture for the first time, and apply it to a real app.
• Custom Views: the logo is rendered with a composite view that uses dynamic resizing of multiple elements. I'll write a blog post about it sometime.
• RxJava: After many months of sitting on the sidelines, I finally got a chance to learn and apply reactive programming in an app.
• Kotlin: The timing of Google's announcement for Kotlin support was right around the time we started on Hatchful.
• Model-View-Intent: One of my colleagues was keen on exploring this architecture, which we used in Hatchful.
• More Firebase: There's over a dozen products in this platform, but this year, I was able to use the realtime database, cloud storage, cloud functions, and performance monitoring, in a production app.
• In-App Billing: This is the first time that I've had to deal with IAP, and managing SKUs in the Developer Console.

Apps

At work, I contributed to two new Android apps at Shopify:

Logo Maker

In April, we launched a basic logo maker, allowing you to customize text, icon, color, and basic placement.

Hatchful

In November, we launched a more polished brand asset app that launched simultaneously for iOS and Android.

Education

For the past year, I've been thinking about earning a master's degree. I like the idea of more formalized education, and the discipline of learning in a structured environment with a cohort of peers.

I looked into Georgia Tech's OMSCS (an online CS Master's), but wasn't sure whether I could sustain interest and apply myself in a completely online environment. I also looked into the University of Toronto's MScAC program. It combines study and work, and is suited for practising professionals, like me, but the program has very little coursework. With so many free, online resources available, I also found the idea of a self-directed, open-source masters interesting.

As to what area I'd like to concentrate in, hardly a day goes by without some mention of artificial intelligence or machine learning, even in non-technical news sources. I've been paying more attention to these fields to see if they're areas I'd like to someday pivot into. With the formation of the Vector Institute in Toronto, and the Ontario government's announcement of increased funding for applied master's students in AI, this is an exciting time to be involved.

Deep Learning

With these thoughts rattling around in my mind, after the announcement of deeplearning.ai in August, I decided to jump (back) into studying machine learning. (A few years ago, I started, but didn't complete, Andrew Ng's seminal ML course on Coursera.)

After enrolling in the Deep Learning Specialization, I'm pleased to have successfully completed the first four courses this year:

• Neural Networks and Deep Learning
• Improving Deep Neural Networks
• Structuring Machine Learning Projects
• Convolutional Neural Networks

Completed the fourth course (Convolutional Neural Networks) of the #deeplearningai specialization by @AndrewYNg on @Coursera. Here are some neural style transfer images I created as part of an assignment. pic.twitter.com/74uaTZWzK7

— Eric Fung (@gnufmuffin) January 8, 2018

The subjects have been really interesting, so I'll continue to take more online courses this year, after finishing the DL specialization.

Public Speaking and Writing

In contrast to last year, I wasn't accepted to speak at any conferences this year. I'm not sure how many CfPs I submitted, but it was less than five. My proposal ideas weren't that original, so I'm going to re-think my talk ideas some more, and try again this year.

The Toronto Android Meetup is still going strong. We ended the year with over 700 members, and 11 events (including two rounds of lightning talks). I gave one talk at our meetup this year:

As you can confirm, I didn't publish anything in 2017. I'd like to work on that more, perhaps using a productivity tool to encourage me to meet a goal for writing on a weekly basis.

Productivity

I've been running RescueTime on my work laptop for a long time. My year in review report is an interesting look back at how I spend my work time. Notably, I spend only half my day doing "software development". One-quarter of my day is on "communication and scheduling", that is, group chat using Slack.

Inspired by a post I read on Chiu-ki Chan's blog a while ago, here is a look back at what I accomplished during the year:

Started a Meetup

I was somewhat surprised to discover that an Android meetup for Toronto developers didn't exist at the beginning of the year (a previous group became inactive at the end of 2015). With the support of my employer, I decided to start one myself.

After getting in touch with the previous organizers, Toronto Android Developers Meetup was formed and began meeting in April. During the year, we held 8 meetups, grew our membership to over 400 people, and have received a lot of encouraging, positive feedback about the need for such a community.

Public Speaking

One of my professional goals for the year was to speak at external events. I was inspired by Donn Felker's The Single Best Thing You Can Do For Your Career, and the excellent book Present! A Techie's Guide to Public Speaking by Poornima Vijayashanker and Karen Catlin.

I ended the year submitting to five CfPs. (The deadlines for several other conferences I wanted to submit to were in my calendar, but I didn't follow through. Something to work on in 2017…)

I was accepted to two events and gave these talks:

• Set Course for Notifications… Engage! at DevFest DC
  • An introduction to Firebase Notifications, and how I used them in an Android app I developed for work
• Playing with Fire(base) at DevFest Florida
  • A survey of several Firebase technologies I used to re-engage users for an Android app I built

In addition, I gave numerous presentations at work and at the Meetup.

Launched a new app

As the sole mobile developer on a team I joined in the middle of the year, I built and launched Entrepreneur's Digest. The app gave me a chance to explore Firebase, and was fertile ground in finding material for talks.

Started this blog

I don't consider myself a good author (and struggle with writer's block a lot). But, I decided a good way to practise was to start writing technical articles.

This year

• Read more: Make time to read more books of all kinds: software development classics, fiction, etc.
• Watch more: I learn best from reading words, but I'm finding more and more useful content in the form of videos (conference talks) and screencasts (e.g. https://caster.io/ for Android developers)
• Increase productivity: As I get more experience, I shouldn't be making the same mistakes. I want to try and identify bad habits and find new efficiencies.
• Reduce distractions: I started using RescueTime to track where the time in my day goes.

Another conference I was accepted into this year, was DevFest Florida. This was my second speaking engagement for the year, after my debut at DevFest DC.

Although I was editing and rehearsing right until the last minute, I had the opportunity to attend several of the talks:

Innovating Is Not About Technology, But Psychology

Alyssa Nicoll (@alyssanicoll) gave the keynote on the topic of motivation for developers, and how to get into the mindset to achieve personal growth.

At #DevFestFL and @AlyssaNicoll is giving the keynote! pic.twitter.com/4SoB0xvvJ7

— Mike Traverso 🎄 (@traversoft) November 5, 2016

• Many developers strive to be well-read, perhaps as a goal in itself
• Why are we here? To be a life-long learner? To be around other developers?
• When asked "What do you struggle with?", responses typically included "fear of learning something new", "fear of getting stuck", "fear of looking dumb"
• It's OK to be afraid, but don't let that fear crush you. You can't do everything alone.
• Try to surround yourself with "winners": passionate, not complacent, people. Not people who sit around, wait around, wish for something to happen.

Alyssa gave three steps to help you get beyond sitting, waiting and wishing:

• Ask Why More: This is an important mindset for developers. It helps you learn new things, challenge yourself, and grow.
• Teach: Influential developers are innately sharing with others, but also learn to be self-taught.
• Want More: Are you growing and being challenged? Do you recognize what you are worth and what your potential is?

An essay that Alyssa shared was The Sad, Beautiful Fact That We're All Going To Miss Almost Everything by Linda Holmes. One memorable sentence from it is "You will die having missed almost everything." The key observation is that with the number of books, TV shows, social media, and other sources of information, you will never see the vast majority of them in your lifetime. Culling, or being more selective, is not enough. Learning to surrender to this "sad, beautiful fact" allows us to be well-read via "making a genuine effort to explore thoughtfully", rather than trying to keep up.

The keynote was quite short, maybe 20 minutes, but Alyssa engaged us in a group discussion for the remainder of the time. We talked about the imposter syndrome diagram and a few other things, and she took notes to use for future iterations of her talk.

Here's Alyssa giving an Ignite! version of this talk at another conference:

Staying Relevant for All Your Years

(Slides)

Christi Kapp (@artinmotionllc) spoke about her personal journey of innovation and entrepreneurship.

She spoke about the importance of staying relevant throughout your career, and to keep up with the changing winds of technology. Like with animal or plant species, technology also goes extinct. Careers also have phases. Using her own trajectory as an example, Christi graphed her career along a time vs. satisfaction axes. It was interesting to note her satisfaction fluctuating when changing jobs, the correlation (both positive and negative) between satisfaction and money, and how she found retiring and travelling boring.

Her keys to successfully thriving were to:

• Be open to non-tech related career directions
• Listen and pay attention to patterns in data (e.g. exponential curves signalling breakout technologies, money being invested in certain areas)
• Being friendly and collaborative, making positive and productive connections with people
• Surf the waves of technology and trends: be ready to jump to the next wave when the current one is about to crash

Multi-Window and Your App

(Slides)

Mark Murphy (@commonsguy) spoke about multi-window support in Android 7.0

This talk was right before mine, so I was feeling nervous and didn't take any notes at all.

Playing with Fire(base)

(Slides)

Because I enjoy creating extra work for myself, I didn't repeat my previous talk about Firebase Notifications, but created a new talk to cover a few more Firebase technologies:

Designing as a Developer

Justin Mitchell (@itsthisjustin) spoke about how developers can become better at design.

Right off the bat, Justin spoke about the products that developers create, whether they had a UI or not. He emphasized the importance of solving problems for users, not just fulfilling a set of requirements. Here are tools and ideas organized under four areas that Justin shared:

User Testing

• Don't overlook putting your app/product/website in front of people who haven't seen it before
• A service that provides audio/video feedback on your website or mobile app is https://usertesting.com. You select the target audience criteria, and they match you up from their panel of a million testers.
• The subreddit /r/beermoney can be used to solicit feedback on your upcoming product launch in exchange for a few bucks.
• https://lookback.io/ is a user research tool for Mac desktop, iOS and Android that records users playing with your app, and their feedback. Not only is their face and voice captured, but what they saw and where they touched.
• https://usabilityhub.com/ helps you run design tests in the form of quick surveys (e.g. what do you recall after 5 seconds, do you prefer A or B, where would you click to do this)

Prototyping

• Don't discount quick sketches on paper or napkins
• Two website and mobile app prototyping tools I hadn't heard of were Marvel and Proto.io
• A very powerful and sophisticated UX prototyping tool (with poor UX itself!) is Axure
• Someone in the audience mentioned his company's product, Briefs, which makes rich prototypes on Mac and iOS (unfortunately, not Android).

"Stealing"

• There are a lot of free or low-cost, high quality icons out there, so developers have no excuse
• The Noun Project is a paid service ($10/mo) with a desktop app that lets you drag-and-drop from 500,000 vector icons. They also offer a free tier, with attribution.
• Lingo is a visual asset library that helps ensure consistency among teams
• Over 9000 templates and assets are available from Envato Elements. A yearly subscription gives you unlimited downloads.

Utilities

• Yoink ($10) is a Mac drag-and-drop utility that acts like a virtual shelf to simplify moving things around. It provides a section of invisible screen that acts like a cut-and-paste buffer.
• If you've ever been annoyed by your menubar icons being hidden by your application menu, you need Bartender 2 ($20). It organizes your menu bar apps, and lets you navigate by keyboard and search them too.
• A free colour picker tool called Sip makes it dead easy to sample the colour of any on-screen pixel, and then output it in a variety of IDE-ready formats (e.g. if you specify Android ARGB it would copy Color.argb(255, 55, 111, 203) to the clipboard)
• For file sharing, particularly for visual assets like screenshots or screen recordings, Jumpshare offers commenting, file previews, and more.
• If you want to outsource user testing, feedback and research, Applause can handle everything from handling NDAs to signing apps, etc.

Writing Testable Apps

Matt Dupree (@philosohacker) gave an elegant talk about how to make Android code more testable.

He began with the obvious statement that "tested apps are better apps", and shared a few quotes from prominent developers like Dan North. I particularly enjoyed Matt's skewering of the Google I/O app for Android. But instead of just criticizing, he demonstrated how to refactor parts of the app to make it more testable.

Matt kept coming back to the concept of seams, which is from Michael Feathers' book,
Working Effectively with Legacy Code. A seam is a place to alter behaviour, without editing in that place. In the Android programming world, think of build variants (link seams), or dependency injection of mocks (object seams). Link seams can be used to swap out factory classes, so that you can use object seams. For example, for testing, you can swap in a factory class that returns a mocked version of a network service.

There were a lot of terms and concepts that I need to study more thoroughly, and patterns that I need to explore. Fortunately, Matt has been writing a lot about Android testing in his blog, Philosophical Hacker, which I've added to my reading list.

Now in its 7th year, the AndroidTO conference was held at the beginning of November. Despite being an Android-focused event, there were a few, general mobile talks that were nevertheless quite interesting. Here's my rundown of the sessions I attended:

3 Ways to Add Machine Learning to Your App

Yufeng Guo (@yufengg), a Google Developer Advocate for the Cloud Platform, spoke about Google's machine learning initiatives.

This DevFest season, Google has really been spreading the word about ML and TensorFlow. I heard two different talks at DevFestDC on the subjects already, so was curious to hear another Googler's perspectives.

First talk of the day at @androidTO by @yufengg on Google's machine learning APIs, both mobile and cloud. Awesome live demos! pic.twitter.com/9Q5DSvfXdT

— Eric Fung (@gnufmuffin) November 2, 2016

Yufeng spoke about the challenges of training and prediction in a mobile context: a lot more computational horsepower is required for the former, so even today's smartphone processors are no match for hundreds of networked CPUs. For each combination of dimension (pre-trained vs. custom, and, local vs. cloud prediction), Google offers a way to use ML in your apps:

• The Mobile Vision API gives you a pre-trained model with processing done on mobile. It offers fast, face detection (not recognition), returning image coordinates of facial features, and expression probabilities (e.g. smiling, joyfulness).
• The Cloud Vision API is another pre-trained model, but offers much more powerful image analysis. It can take arbitrary photos and label them with descriptions across a variety of domains, including logos and landmarks. In addition, In addition, there is a Speech API for converting audio to text, and a Natural Language API for analyzing the structure and meaning of text.
• For all other custom applications, there's TensorFlow, whether it's used on mobile or cloud.

Yufeng even did a few live demos involving the audience:

Thanks for giving me the thumbs up @androidTO pic.twitter.com/XYwBJ7k3Qq

— Yufeng G (@yufengg) November 2, 2016

Supercharging Your Android Release with Fastlane

Andrea Falcone (@asfalcone) gave the same talk I attended at Droidcon NYC.

Excited (again) about how @FastlaneTools can speedup app screenshots and publishing. Listening to @asfalcone this morning at @androidTO pic.twitter.com/O1THvDmmUB

— Eric Fung (@gnufmuffin) November 2, 2016

Animations to Guide Us All

(Slides)

Marcos Paulo Damasceno (@marcospaulosd) walked us through a series of progressively fancier activity transitions in a sample app he built.

Fancy Activity Transition implementation details being explained by @marcospaulosd at @androidTO pic.twitter.com/scNhzmnPXx

— Eric Fung (@gnufmuffin) November 2, 2016

Some things I learned about activity transitions:

• Get started by calling getWindow().setEnterTransition(), with one of the predefined transitions in the android.transition package
• After a shared element transition, to have other views in the target activity slide in, create a Slide transition, then add views to it that should be animated. Group these transitions into a TransitionSet and set them on the window.
• Call setTransitionGroup(false) to tell Android that a ViewGroup should not be treated as a unit, and that its children should be animated individually.
• After an INVISIBLE view moves to its final position, use a shared element callback to add a reveal effect, making the view VISIBLE and then starting the animation.

All of the above ideas are demonstrated in a slick demo app that Marcos wrote: https://github.com/marcospaulo/cinema_example

Machine Learning Tools

Vihan Jain (LinkedIn), a Google employee, gave (yet) another overview of the company's machine learning tools.

He described TensorFlow as a way to perform computations defined as a DAG to optimize an objective function. These computations are defined in a high-level language, compiled, and optimized in the cloud. A lower-level CPU, e.g. mobile or GPU, can execute part or all of the graph, and push data through it. He suggested we look at a code lab called TensorFlow for Poets which introduces you to the idea of transfer learning, where an existing trained model can be re-trained on a similar problem.

To build something from scratch, Google uses the phrase Wide and Deep Learning to describe their techniques for building recommender systems, search and ranking systems.

Give Your App a Boost in Quality with Firebase

Doug Stevenson (@codingdoug), a familiar face from all of his Firebase advocacy in videos and articles, gave a lightning talk about how to use Firebase to improve app quality.

Sharing about the powerful and feature rich @Firebase platform - lightning talk by @CodingDoug at @androidTO pic.twitter.com/85toDs7Exe

— Eric Fung (@gnufmuffin) November 2, 2016

I jotted down a few notes on my phone:

• Remote Config is like a fancy if-else
• Per-user authentication can be done for the real-time database, using Firebase Authentication
• Coming soon: mobile crash reporting view
• Use notifications to inform users of known crashes

Dealing with Legacy Code

Nathalie Simons (LinkedIn) from TribalScale spoke about how to deal with old, inherited codebases. This was a generally applicable talk, not dealing directly with Android.

Legacy code often comes with the baggage of bugs, unknown behaviour and/or unknown design decisions. People are forgetful and don't remember the what and why of code they wrote.

Nathalie Simons from @TribalScale giving tips on dealing with legacy code - lightning talk at @androidTO pic.twitter.com/hAUS9ksHDm

— Eric Fung (@gnufmuffin) November 2, 2016

Nathalie outlined three approaches if you find yourself working with another company's code:

• Work with what you have: study existing code to figure out how it is currently working, without trying to clean it up. Make use of logging and breakpoints with the goal of understanding.
• Start from scratch: in addition to studying the existing code, rewrite the code. Put yourself in the previous developers' shoes: they had reasons for what they did. Figure out why, before judging. This technique may be risky, because you don't know what the original business requirements were.
• Take what you need: after studying the legacy code, cherry-pick what you need onto a clean slate. Introduce portions of old code incrementally, so you know where to place blame when something breaks.

Building Integrated Medical Apps

(Slides)

James Agnew (@jamesagnew) from the Centre for eHealth Global Innovation spoke about his team's challenges in developing healthcare apps.

To start, James presented an example of rethinking healthcare from a 2010 article in WIRED about redesigning blood test results. The designs were turned into a proof-of-concept by the Boston Children's Hospital.

The Centre's mandate is to develop apps for patients to manage chronic conditions, so they can be active participants in their own health. Such apps help patients follow their care plan (measuring weight or blood sugar, reminders to follow a morning routine), help doctors manage patients' health (uploading data to a doctor), make sense of collected data, and accumulate data for research.

Learning about apps to manage chronic conditions, modern healthcare standards, and research at scale from @jamesagnew at @androidTO pic.twitter.com/UljKldtNFj

— Eric Fung (@gnufmuffin) November 2, 2016

As one can imagine, healthcare apps have to deal with a number of standards.

• Bluetooth often suffers from flaky connections, and the lack of standard profiles for medical applications (like a thermometer or blood pressure monitor).
• The underlying premise of most electronic health record systems is replicating data everywhere, which doesn't match the intermittent connectivity and limited storage of smartphones.
• FHIR is a modern initiative to develop a data format and API for exchanging health records. There is an open-source reference implementation in Java available at http://hapifhir.io/ including an Android library. And, at a higher level, the SMART Health IT platform defines standards for profile and authorization for healthcare apps, and an app gallery.

Looking to the future, James mentioned a number of ongoing initiatives:

• the idea of seeing your health records curated like a Facebook news feed
• using smartphones to perform research at scale (Ed.: I immediately thought of Apple's ResearchKit). Sync For Science is a US collaboration which allows patients to share their electronic health data with research apps
• an artificial pancreas that uses a smartphone as a controller, e.g. TypeZero