Unfortunately, Apple doesn’t have a baby version of their Pro Display XDR, so I did the next best thing I could and picked up the LG UltraFine 24" 4K


The biggest drawback of the Apple Silicon M1-based MacBook Pro in day-to-day use at home is the screen. It will be perfect for café computing, when we can do that again and be lovely for airplanes when we can travel, too. However, it’s no match for the bigger 27" display on my almost six-year-old iMac 5K that‘s been the center of my desk.

Until now, I haven’t minded that because the iMac was the fastest machine in my current collection. That’s not the case anymore. Since I can’t use the 5K iMac’s display as an external screen, that left me wondering what to do.

One day, I might go nuts and get the Pro Display XDR, but it’s actually too big a display for my current work area. And let’s not mention the price tag. So, for now, I really just want a 24" display. If Apple had a baby 4K version of their Pro Display, I’d be all over it.

So, I did the next best thing. I picked up the [LG 24" UltraFine 4K display with macOS compatibilty][lg]. By Mac-compatible, they really mean that it has two Thunderbolt 3 and three USB-C ports and can charge up your Mac when you plug it in. And, it’s capable of P3 color.

In just a few minutes of use, I’m pretty satisfied with it. More than I expected, actually. The screen is big enough for serious multitasking, yet small enough that it lets my desk breathe a bit. The color is gorgeous for photo and video editing. And the simple one-plug display and charge capability is great to have a non-Apple device.

My one complaint might be the way it wiggles on its stand. There’s a little bit of rotational play there. However, the display comes with a VESA mount plate, so that’s pretty easy to fix later and put it on something more flexible to boot if I find the wiggle too annoying.

Verdict: A lovely display that pairs great with the Apple Silicon 13" MacBook Pro.

[lg]: https://www.lg.com/us/monitors/lg-24MD4KL-B-4k-uhd-led-monitor


Hello UltraFine 4K

I’d have a lot more sympathy for McConnell’s argument if he was backing up that speech by actually doing something to bring some other process to bear.


So, [Trump’s second impeachment ends with acquittal][nyt]. We knew that was going to happen, but I’m still sad that 43 US Senators were unwilling to hold Trump accountable in this way.

It pains me to say that I have a little bit of sympathy for Senator McConnell’s arguments for not voting for conviction. However, I can’t see that it would have been a dangerous precedent to vote for conviction even if the penalty of removal from office wasn’t applicable in this case. Further, I’d have a lot more sympathy for McConnell’s position if he was leading a charge for further action.

However, as it stands, it feels improbable that McConnel or anyone voting with him will pursue further action. Therefore, we’re left with 43 Senators putting fealty to Trump — not even their party, but Trump himself — above the country.

At least seven Republican Senators did vote to convict. As [David Frum writes in the Atlantic][a], this makes a significant point:

> But now see the world from the other side, through the eyes of those who defend Trump or even want him to run again. Their hope was to dismiss this impeachment as partisan, as founded on fake evidence, as hypocritical and anti-constitutional—to present this verdict as an act of oppression by one half the country against the other. That hope was banished today.

Let’s see if it plays out that way.

[nyt]: https://www.nytimes.com/live/2021/02/13/us/impeachment-trial
[a]: https://www.theatlantic.com/ideas/archive/2021/02/impeachment-did-not-prevail-trump-still-lost/618026/


Entirely predictable, yet sad

Implicit in a recent pointer to a code puzzle was the fact that a test-driven approach would be perfect.


[Allen Holub retweeted][aht] a [code puzzle that Alexey Grigorev posted][agt] which Alexey claimed that most candidates couldn’t solve the following within a 25-minute screening interview:

```js
Input: 'aaaabbbcca'
Output: [('a', 4), ('b', 3), ('c', 2), ('a', 1)]
```

My first thought was that this should be easy: a quick matter of counting up the number of times each letter occurred in the string. Then, I saw that final `a` character and realized that something a little more sophisticated was needed. It took me about 10 minutes (yes, I timed myself) to hack out the following solution in Ruby using IRB:

```ruby
'aaaabbbcca'.chars.reduce([]) do |a, c|
  if b = a.last and b[0] == c
    b[1] = b[1] + 1
  else
    a << [c, 1]
  end
  a
end
```

This produced the following output, which is close enough even though it’s in Ruby’s array of array output format:

```ruby
[['a', 4], ['b', 3], ['c', 2], ['a', 1]]
```

Of course, those one-letter variable names are only good for a few minutes. They really need to be cleaned up into something more readible. Here we go:

```ruby
'aaaabbbcca'.chars.reduce([]) do |accum, char|
  if last = accum.last and last[0] == char
    last[1] = last[1] + 1
  else
    accum << [char, 1]
  end
  accum
end
```

[Based on my recent interview experience][ego], I’m really not sure I could have been able to do it within Alexey’s 25 minute screening. Indeed, I’d have to be in a reasonable frame of mind to have a shot and not totally flub it up due to performance paralysis.

## Other solutions

A few other solutions stood out in the threads of these discussions. One I quite like is [Sam Ruby’s one liner][sr] using `scan` and a regexp:

```ruby
'aaaabbbcca'.scan(/((.)\2*)/).map(&:first)
```

which returns:

```json
["aaaa", "bbb", "cc", "a"]
```

To return the same format mine, you can use the following as the `map` function:

```ruby
.map { |item| [item[1], item[0].size] }
```

Vítězslav Ackermann Ferko [used the same approach in JavaScript][vat]:

```js
'aaaabbbcca'.match(/((.)\2*)/g).map((v) => [v[0], v.length])
```

I think my absolute favorite, however, is [this solution by Raymond Hettinger][rht]:

```sh
$ echo 'aaaabbbcca' | fold -w 1 | uniq -c
 4 a
 3 b
 2 c
 1 a
```

This one wins the prize! 💥

## Let’s be test-driven, ok?

Implicit (to me at least) in Allen’s pointer to the problem is that this is the kind of thing that would be great for a test-driven approach. So, instead of hacking it out in IRB, I could have written a test first:

```ruby
def test_simple
  expected = [['a', 4], ['b', 3], ['c', 2], ['a', 1]]
  assert_equal expected, solve('aaaabbbcca')
end
```

You might think that setting up a test-driven approach is overkill for a code puzzle like this. Certainly, it can be a pain in the arse to set up seperate files and a test driver. In Ruby, at least, you can do this in a single file:

```ruby
#!/usr/bin/env ruby

def solve(input)
  input.chars.reduce([]) do |accum, char|
    if last = accum.last and last[0] == char
      last[1] = last[1] + 1
    else
      accum << [char, 1]
    end
    accum
  end
end

require 'test/unit'

class Tests < Test::Unit::TestCase
  def test_simple
    expected = [['a', 4], ['b', 3], ['c', 2], ['a', 1]]
    assert_equal expected, solve('aaaabbbcca')
  end
end
```

I started using this all-in-one test-first approach in the last code interview I did recently, and it out really worked nicely. It certainly helped keep my thinking a little bit more structured during the process.

Of course, if we _really_ wanted to take the original instructions literally, we could have using a test-first approach and just returned the string asked for:

```ruby
#!/usr/bin/env ruby

def solve(input)
  "[('a', 4), ('b', 3), ('c', 2), ('a', 1)]"
end

require 'test/unit'

class Tests < Test::Unit::TestCase
  def test_simple
    expected = "[('a', 4), ('b', 3), ('c', 2), ('a', 1)]"
    assert_equal expected, solve('aaaabbbcca')
  end
end
```

You’d just need the right _je nai sais quo_ expression to go along with presenting this solution. Maybe one day, I’d be in a good frame of mind to do that. 🤣

[aht]: https://twitter.com/allenholub/status/1357115515672555520
[agt]: https://twitter.com/Al_Grigor/status/1357028887209902088
[ego]: /software/interviews/tripping-over-my-own-ego
[sr]: https://twitter.com/samruby/status/1358404706910011395
[rht]: https://twitter.com/raymondh/status/1358120906258673665
[vat]: https://twitter.com/vitezslavferko/status/1357506302725996546


The case of aaaabbbcca

After over five years at Microsoft, February 28th is my last day.


When Wunderlist was acquired by Microsoft, I don’t think I had any idea that I’d stay at the company for more than a couple of years. Indeed, I figured I’d serve out the holding period on my unvested shares and then move on. Mostly, I thought it was a fantastic irony that I was working for the company that was once the “Evil Empire.” A company that I helped battle when I was working at Sun Microsystems two decades ago.

Yet, here we are, over 5 and a half years later.

Three of those years were consumed by working in various ways on the integration of Wunderlist into Microsoft. Those weren’t easy years, by any stretch of the imagination. Our team came into Microsoft with a lot of churn at its top levels. That churn continued throughout my time there. Not much worked out the way any of us expected. I learned so much from those years, and I’m still processing the lessons.

For the last two and a half years, I worked as a CTO in Residence (it’s a position sort of like a CTO-as-a-Service) in Microsoft for Startups. That gave me the chance to connect with startups around Europe like [Userlane][ul], [Ultimate.ai][ui], [ProcessGold][pg] (now part of UIPath), [Uncrowd][uc] and [Be My Eyes][be] and help with both leadership and technical challenges. One of my proudest moments was helping to connect [Wayve.ai][w] with people inside Azure that could solve their massive data challenges.

I also coordinated the Microsoft for Startups presence at the [Slush conference][s] in 2018 and 2019. This included producing a set of talks for our booth each year. Two standout presentations from these events are [Recruiting a diverse team by Amali de Alwis][a] and [Selling with Microsoft by Sam Bowman][sb].

Leaving Microsoft now is bittersweet. The company is full of brilliant people, and I’m going to miss working with many of them. Azure has developed into a fantastic cloud for many uses. And, I love both the company’s [commitment to sustainablity][msc], and its focus on [helping developers][d].

My last day at Microsoft will be February 28th.

I’ll take a bit of time off and then will be starting on something new in mid-March. More on that later...

[w]: https://wayve.ai
[ul]: https://www.userlane.com
[ui]: https://www.ultimate.ai
[pg]: https://www.uipath.com/product/process-mining
[be]: https://www.bemyeyes.com
[uc]: https://uncrowd.uk/
[s]: https://www.slush.org
[a]: https://www.youtube.com/watch?v=ZuWPGmBZvkA&t=2s
[sb]: https://www.youtube.com/watch?v=ZXBceNIhIUo&t=0s
[msc]: https://news.microsoft.com/climate/
[d]: https://developer.microsoft.com/en-us/


Leaving Microsoft

I’ve rebuilt my website with Next.js and found it to be more interesting than I expected.


One of my New Year’s resolutions was to dig a bit deeper into [React][rjs]. It’s part of a personal project to rehabilitate my negative bias about the JavaScript ecosystem and to dig deeper into the details that I find really interesting. Also, I’ve been watching the [Next.js framework][nextjs] for a while. Now that it [supports static website generation][next-ssg], I decided it was time to dive in re-build my [duncan.dev][d] site using it, which you’re reading now.

About that bias of mine: I find most of the JavaScript ecosystem to be a layered hot mess. It has developed over time by a steadily accelerating accretion of ideas. Because of that, it can be tough to see the gems. Next.js looks to be one of the gems. Paired with [TypeScript][ts], I’m finding that I’m enjoying it.

[d]: https://duncan.dev
[rjs]: https://reactjs.org
[gjs]: https://www.gatsbyjs.com
[nextjs]: https://nextjs.org
[njs]: https://nodejs.org/en/
[next-ssg]: https://nextjs.org/docs/advanced-features/static-html-export
[ts]: https://www.typescriptlang.org


Now building with Next.js

You can have worked for decades in software development, and still be tripped up by a code interview.


I’ve had three code interviews in the last few months. In the first two, I did so badly that I lost any chance for the job, despite doing well on the other interviews. In other words, I bombed.

_“Seriously?”_ you might ask. _“You’ve been doing this how long, and you had a hard time with some code interviews?”_

Sadly, I’m embarrassed to admit; it seems yes.

In a bit of self-fulfilling prophecy, I think part of what tripped me up was my low opinion of code interviews. Like many others, I find the entire premise of a live coding interview to be suspect. There’s a dynamic to them that doesn’t exist in any reasonable situation unless maybe you’re hiring somebody to do live code demos on stage in front of a critical audience.

Some of the best software developers I know fear this dynamic so much that they avoid interviewing for any job that requires a coding interview.

I went into those first two interviews with a combination of that fear mixed in with a _“You’ve got to be seriously kidding me?”_ frame of mind. Not the right place to start. From there, it’s all too easy for the ego to slip into a thought loop along the lines of, _“You want me to prove to you that I can do a simple coding task? Don’t you know I was helping to ship industry-standard platforms when you were probably still in diapers!? I’ve written books and...”_

For me, this led to an obliteration of rational thought, and I froze. The interviews turned into a sad downward slide of compounding mistakes and ended in, dare I say it, shame.

The worst part? After each interview, I re-did the exercises and found that I could quickly solve them with ease. It only confirmed my worst fears of how useless the signal these interviews can give is.

How’d the third one go? Better.

I prepared by doing a bunch of exercises on [Exercism][exo] and [HackerRank][hr]. I found that I kind of like doing these kinds of problems. More importantly, I spent a bunch of time working on my attitude. I got myself to the point (for the most part, anyway) where I could go into it without focusing on the fact that I thought the entire exercise was pointless or useless. I still had a lot of performance anxiety and didn’t perform as well as I should have, but at least I didn’t bomb.

[exo]: https://exercism.io
[hr]: https://www.hackerrank.com
