Experiments in managing perfectionism

Design

This week involved interview prep, but I got to spend a bit of time thinking about design. My first day at Square involved presentations from various teams, but the message that continues to echo is the one from design director Ty Lettau.

Your job is to absorb as much complexity as you can, and pass the simplicity through.

This philosophy showed its physical manifestation when I had a tour of the hardware lab. The degree of care and attention to detail ranged from the choice of materials (aesthetically pleasing yet durable), to how the product feels in the hand, to the flow from the seller to the buyer and back, to even the embedded software. The devices run on a fork of Android, which amongst other things allowed EMV payments to be fast yet secure, helping to cut down lines at Blue Bottle.

I worked in the Risk team, covering fraud, disputes and recovery. The inner workings under the hood may be cutting-edge machine learning (with lots of arbitrary rules set by intermediaries), but all this was abstracted away from the end user. We continually looked for ways to make the process faster, cheaper, simpler.

Figma (discussed in a prior post) has a Learn Design pilot, which highlights this multi-faceted aspect of design. Naturally I had a soft spot for the section on simplicity, and in particular this excerpt.

Often, creating something simple is more difficult than creating something complex. However, simplicity in design is not necessarily the opposite of complexity, but the revealing of the complex information in a measured and easy to digest way.

Simplicity manifests itself in writing too. I love this quote by Stephen Toulmin.

The effort the writer does not put into writing, the reader has to put into reading.

Add perfectionism to the mix, and you'll end up with lots of drafts and redrafts. On the flip side, that feeling of pride in the end result... priceless.

Content: The Laws of Simplicity

Re: simplicity, there's The Laws of Simplicity by John Maeda (Github profile here). The excerpt is Law No 1.

http://lawsofsimplicity.com/los/law-1-reduce.html

The simplest way to achieve simplicity is through thoughtful reduction.

Content: The Gap

Re: iterations, there's The Gap by Ira Glass. If it's one thing I'd take away from this blog post, it's this one. The RC version of this is advice from Dave, "when in doubt, code".

Content: The Flower Duet

In being sophisticated, one may go through a phase of faux sophistication. Listening to Delibes on the way there... bliss.

Content: Do we need to have a passion?

FT Weekend used to have a section called The Sage and The Shrink. I've not read this post since the time it was published - writing a blog has truly been a journey of rediscovery.

https://www.ft.com/cms/s/2/0dc70fac-4c86-11e1-b1b5-00144feabdc0.html

The most constructive attitude is not “I must find my passion”. Instead pursue what passions you do have, big or small, and keep exploring the things that interest you with an open mind. There is plenty to love and appreciate, whether or not you find “the one”.

Content: High Rise

There are moments when I ask myself, is it too late to become an architect? The Square office was one. The Black Diamond in Copenhagen is another (when sharing the photo, the caption went "If I could marry a building, it would be this one").

The trip to Copenhagen also included a visit to the offices of the architectural firm Bjarke Ingels Group. My friend who worked there described how at that point in time they only participate in competitions. The office was filled with scale models, and it was a joy seeing how the initial concept evolved over time. The highly-interactive website (which used to run on Flash) has parts of this exposition in each project description.

I looked up this New Yorker profile of Bjarke Ingels for the purposes of this blog post (flows nicely from last week's post on Renzo Piano). This excerpt embodies The Sage's advice above perfectly.

https://www.newyorker.com/magazine/2012/09/10/high-rise

My thinking was, I’ll do architecture until I have a better idea. And I simply never got a better idea.

WebAssembly

Every Thursday there's a Front End Hack and Tell - we commit to working on something front end-related at the start of the session, and circle back at the end to share what we came up with. I've been learning Rust to get into WebAssembly, but so far still ramping up on the Rust part. I learned MIPS Assembly a while ago, and thought a refresher might help me approach WebAssembly from a different angle.

This didn't quite work out as planned. The notes I have from that time assumed I'd be revising the material, as opposed to picking it up practically from scratch. Plus WebAssembly is a stack machine, not a register-based one like MIPS.

C

I spent the rest of the hacking time on Rust, but my refresher reminded me of the story of how C came about. Assembly can be thought of a set of instructions that the processor understands. For example, `add $t1, $t2, $t3` means add the values in $t2 and $t3 then place it in $t1. The tricky bit is each processor has its own instruction set, so you'll need to compose one set of instructions for a MIPS processor and a different set for an Intel x86.

The idea behind C is a language that's one layer up from the processor (so it works across both), but also sufficiently low level so things run fast. What did the creators of C do once they're done? They created Unix.

Content: Design

Having featured data science and product management, let's talk about design. First, a preamble.

Square allowed every person who had a smartphone the ability to accept credit cards. The problem was, now every fraudster could use Square to cash out stolen credit cards. Square solved this problem with machine learning. By leveraging the improved ability of ML models to flag suspicious payments, ability to accept credit cards is made accessible.

If Square is an example of a business model that becomes viable (amongst other things) on the back of machine learning, can we think about the analogue for, say, WebAssembly? Here Figma comes to mind - WebAssembly allows the functionality of the Adobe design suite to be run in the browser, but with the performance of a native app.

https://kwokchain.com/2020/06/19/why-figma-wins

What I especially loved with the post is the framing of tighter iteration cycles. Before Figma, the design process involved back-and-forth between teams via e-mail. With Figma, all design and feedback are stored centrally in the cloud, allowing more context to be retained at handoffs (analogous to the same language across teams in a previous post). I must have overlooked the reference to other cool technologies deployed on the prior reading - WebGL and CRDTs.

In summary, I learned a lot working as a data scientist in a company where machine learning makes or breaks the business. I'm curious to see how new business models becomes viable with something like WebAssembly. Though first, one needs to understand WebAssembly...