Shared posts

15 Feb 15:23

FeverBee Is Hiring A Web Designer / UI Designer ($500 referral fee)

by Richard Millington

A quick aside from our usual content…

As the title suggests, FeverBee is hiring a web/UI designer. Details below.

If this job isn’t for you but you know someone who would be a great fit, send this link to them and if we hire them for at least 3 months, you earn a $500 referral fee.

 

Mission

FeverBee’s mission is to help great companies build thriving online communities of members, customers, and employees.

Over the past decade, we’ve worked with the largest organizations in the world (including Microsoft, Apple, Facebook, SAP, Oracle, Google, etc..) to build communities where members share knowledge, solve problems, and feel a powerful sense of belonging.

Our success lies in our ability to understand what members truly desire in a community and develop community strategies which drastically increase engagement and participation. In the coming months, we’re expanding our services to offer both strategy and design support. And we’re looking for a designer to shape and deliver our strategies.

 

Objectives

  • Use our research to design exciting and engaging community experiences for the world’s largest organizations.
  • Take full responsibility for FeverBee’s website design.

 

Responsibilities

  • Redesign the FeverBee website to deliver a modern, engaging, and aesthetically exciting look and feel where audiences can easily find the information they need.
  • Use our deep audience research to design full community experiences for our clients (from a visitor’s first visit through to regular participation).
  • Help us build the right systems and processes for creating successful community experience (from initial consultation, through to prototypes, wireframes, artwork, and the full design for development).
  • Collaborate with multiple client stakeholders to present ideas, gather feedback, and ensure clients are kept fully informed and delighted with the outcome.
  • Develop visual assets to support FeverBee’s content (frameworks, graphics, icons etc…).
  • Proactively evaluate client communities and make data-driven recommendations for improvement.

 

Skills And Experience

  • English language proficiency.
  • At least 4 years of professional UI and front-end web design experience (reflected in a strong portfolio).
  • Understanding of browser compatibility across multiple platforms and devices.
  • Ability to design with accessibility in mind.
  • Proficiency in Figma, Adobe Creative Suite, Photoshop and/or similar tools.
  • Proficiency with HTML, CSS, and Javascript would be a bonus.
  • Experience working with communities would be a bonus.

 

Location

  • This is a remote position (open to applicants in Europe and North America ONLY).
  • Note: If you are outside the UK you will be responsible for satisfying local tax requirements).

 

How To Apply

  • Send an email to richard@feverbee.com. Including your resume/CV can help, but examples of your work would be even better.

Salary

  • £40 to £45k GB (approx $54k – $61k USD).

The post FeverBee Is Hiring A Web Designer / UI Designer ($500 referral fee) first appeared on FeverBee.

15 Feb 06:42

On Taking Notes and Choosing Tools

by Ton Zijlstra

In reply to On taking notes and syndicating them by zblesk

Thank you for writing that! I too find it highly interesting to see how other people arrange their workflows, choose their tools and what they do with them. Often there are things that spark an idea or suggest a useful tweak to my own workflows. So thank you for making a comparison between how you work and what I wrote about how I work.

A few reactions to some of the things you mention.

My perspective on (personal) knowledge management is centered around the notion that I should have everything under my fingertips, and should be able to fully determine my own choice of tools. Tools one can preferably tweak, reshape or replace easily. I started taking notes in the early 1990’s and local text files were the most basic choice I made (and one of the few I then could make). Later convenience lured me into other things like Evernote, and Things for tasks, but I’ve returned to that basic starting point of using text files more recently.

At the core are these notions I hold:

  • Local first. I’m from an era that connectivity can’t be taken for granted, and regularly work in settings where that is still true. It is also a dependency that even when it is usually reliable, probably carries a high cost if it does fail, as that most likely is in key moments (basically a version of the demo effect).
  • Agency over tools. Tools must provide actual agency. A key part of it is being able to fully control it’s deployment and use, being able to tweak it etc. Tools must be smaller than us in that sense (not in a literal sense). Convenience may make me ignore this factor up to a certain point, but in the end having control over my tools always comes back up as an issue. Not having such control ultimately always turns a tool into a single point of failure. (Gmail and Evernote are prime examples to me) That drives me to simpler tools within my own scope of control and power to manipulate, and only allowing more complexity if it increases my personal agency significantly. It also means to me that tools need to be useful on their own, and more useful when networked.
  • Personal tools. Tools need to be adaptable to the person using it. That makes it easier to make those tools smarter. As personal preferences can be assumed as the defaults, and personal routines are predictable to the person itself. Predictable routines plus preferences equal functions and parameters, i.e. code.
  • Personal agency is always in the context of networked agency. In most settings the unit of agency is not the individual but a small group of connected people trying to solve something that is important to the group itself. Whatever tools the group uses should be within the scope of control of that same group. As a group’s notion of local is usually a networked notion, my local stuff needs to be able to connect (yet not depend on it). Distribution is important here. Centralisation is mostly to be avoided as it carries a cost in overhead, control and resilience.

Put that all together, and indeed POSSE basically becomes the prime directive for everything.

On PHP: I’ve been using PHP for about 20 years. When I create something as a personal tool, it makes sense to just grab the building blocks I’m already familiar with. I’ve always run a local webserver on my pc/laptop, and writing up a few lines of PHP and dropping it in a folder my local webserver uses, makes it fast and easy. Easier at least than getting to know new frameworks, or whatnot. Javascript never appealed to me even if it is from the same 1990’s era, nor succeeded in making much sense to me. Apart from doing browser side things with it in an HTML page.

On WordPress: I used to handcode my sites, until I started using Movable Type shortly after I initiated my blog (hosted on a webserver at home). That was written in Perl which I was comfortable with having written my then employer’s first intranet in it. A decade later I switched to WordPress when my Movable Type install suddenly stopped working completely. I see you use Ghost, which ran a kickstarter I supported shortly after I switched to WordPress (self hosted on an external hosting package). By the time Ghost saw its first release I didn’t act on my earlier idea of running that on a home server. I’m not particularly attached to WP (also used Drupal heavily for other sites), and use it pretty bare bones, but it has served me well for the last 10 years. The switch to Gutenberg and blocks though has me thinking I might maybe go for something simpler.

On Obsidian / Joplin: I also use Joplin, but haven’t tweaked it like you have, I use it out of the box. It’s where my Evernote exports live, which from there I export to md files as needed. I treat Obsidian as a viewer, and Joplin too. Because of that I dislike that Joplin stores stuff locally in an sqlite database, obscuring the contents from my filesystem that way. From a viewer it then becomes an obscurer. Currently Obsidian has my sympathy, that may change, no tool is forever. So in my choices of e.g. plugins for Obsidian I avoid things that provide functionality that comes with a type of lock-in, where if you stop using a plugin part of your information disappears or is hard to get at because it was in a database not in the notes. I dislike YAML frontmatter too. For the Dataview plugin I use inline datafields (key:: value) which makes them a regular part of the note itself. Only when for some automation I need to know where to easily find a data field, I will put it at the top (but still not as YAML frontmatter).

On public RSS subscriptions: yes, I post a list of all the feeds I subscribe to. I treat them as individual’s voices (so no feeds from news outlets etc), and group them by my perceived social distance. I treat blogging and interacting with feeds as distributed conversations.

I always like reading about how other people process information and handle their notes/knowledge bases. It’s a topic I think about often.

Ton Zijlstra’s ideas are especially interesting to me because it seems we are trying to achieve similar goals, but go about it in opposite ways.

zblesk

(also posted to Indienews)

15 Feb 06:41

These Weeks in Firefox: Issue 109

by Mike Conley

Highlights

  • Since the compatibility panel is also riding the 98 train, we polished it a bit: we added support for Internet Explorer 11 data (bug), reworked the tooltip for compatibility issues (bug) and last but not least, updated Firefox icon  (bug)
    • The compatibility panel in the Firefox DevTools showing the -webkit-overflow-scrolling rule on the selected element. A number of icons are shown indicating which browsers have compatibility problems with that rule.

      Cool people make sure their sites work in as many browser engines as possible.

  • The new performance panel is riding the train and will be enabled in Firefox release 98 (bug). The new panel will make it easier for web developers to record and share profiles as it opens a new profiler.firefox.com tab when capturing the profile. Many thanks to jwajsberg who fixed the last issues that were blocking this.
    • The Performance panel in the Firefox DevTools UI shows a button to start recording a performance profile.

      A long overdue overhaul of the DevTools Performance Panel is riding out to users soon!

  • Claudia, our DevTools Outreachy intern, is about to enable the new “Edit and resend” panel of the Network Monitor on Nightly 🎉 (bug)
    • A more robust "Edit and Resend" UI is shown in the Firefox DevTools Network panel. The original network request is shown with editable fields.

      A new fancy Edit and Resend panel for the DevTools Network Monitor tool!

  • Support of WebVTT captions is coming for Picture-in-Picture! The patch is in Nightly but it’s off by default – there’s still quite a bit of work to do. If you’re curious, you can test our progress by setting media.videocontrols.picture-in-picture.display-text-tracks.enabled to true in about:config.
  • CTA for our Nightly testing community: help us test website compatibility for when Firefox reaches v100! In about:preferences#experimental, there is a toggle that lets you use the v100 UA string ahead of time. See issues with sites with the v100 on, but not when it’s off? File a webcompat.org bug and let us know!

Friends of the Firefox team

Resolved bugs (excluding employees)

Script to find new contributors from bug list

Volunteers that fixed more than one bug

  • Claudia Batista [:claubatista]
  • Jane Kotovich (:janey)
  • Jintao Hu
  • Masatoshi Kimura [:emk]
  • Shane Hughes [:aminomancer]

New contributors (🌟 = first patch)

Project Updates

Add-ons / Web Extensions

WebExtensions Framework
  • As part of the ongoing ManifestVersion 3 work (Proposal: Limited Event Pages for MV3 · Issue #134 · w3c/webextensions · GitHub), we have started to introduce support for the non-persistent background page (also known as EventPage):
    • Bug 1748524 (initial set of changes to support non-persistent background page, currently gated by the ‘extensions.eventPages.enabled’ about:config preference)
    • Bug 1748541 (WebExtensions API Events internal refactoring, used in follow up patches to extend “persisting and priming of the API event listeners” to more WebExtensions APIs on extensions using a non persistent background script, either an event page or a service worker)
    • Bug 1748547 (persist alarm listeners to allow them to respawn the background script if fired after it has been terminated)
  • Thanks to Barret, the ‘pkcs11’ WebExtensions API does not use osfile.jsm anymore – Bug 1745352

Developer Tools

  • Hikota fixed a contrast issue when using the debugger command palette in dark mode (bug)
  • Angelina made it possible to open links displayed in the headers panel of the network monitor (bug)
  • Long time contributor sebo started to work on Custom Formatters for DevTools (bug), with funding from the Clojurist Together Foundation. Custom Formatters are a way for content pages to control how objects will be rendered in DevTools (console, debugger, …). It’s especially useful for debugging library custom data, like Immutable or ClojureScript.
  • We fixed a nasty bug where DevTools would freeze when trying to inspect an iframe blocked by CSP (bug). Thanks Christoph Kerschbaumer for helping us on that.
  • Julian fixed an issue about:debugging where the tab list wasn’t updated properly (bug)
  • You can now see CSS layers data displayed in the rule view (bug). We took this opportunity to change how we display media queries data (bug), and display the full list of nested media queries/layers (bug)
    • CSS layers are now being shown above a rule in the Firefox DevTools Inspector Style pane.

      Layers. Like an onion!

  • bomsy and ochameau are working on making the debugger more reliable and already landed a few patches to make the codebase easier to navigate and the test more robust and legible.

Form Autofill

New Tab Page

  • Bug 1749583 – [Dão] added colorways section placeholder in about:newtab’s personalize panel behind a pref (browser.newtabpage.activity-stream.colorway-closet.enabled).

Password Manager

Picture-in-Picture

  • We’re going to experiment with different toggle behaviours for first-time users of Picture-in-Picture, and have added telemetry for that.

Performance Tools (aka Firefox Profiler)

  • Support profiling of private browsing windows (github #3671, bugzilla #1639716)
  • Enable the new performance devtools panel by default in release (bugzilla 1451902)
  • Performance improvements when there are a lot of threads (github #3813, #3829, #3842)
  • Improvements in the range selection behavior
  • Syntax highlighting for the new source view – (#3794) thanks Markus! Link to a profile
    • The source view in the Firefox Profiler UI is shown with the source to some graphics code. The code is syntax highlighted.

      The syntax highlighting makes the source much easier to read.

  • Experimental support for per-process CPU usage capturing
    • Enable the “Process CPU Utilization” feature in about:profiling first.
    • Then in the profiler viewer, open the console and run experimental.enableProcessCPUTracks()
  • Use ResizeObserver instead of DOM resize events to track window resizes, which fixes a few issues and improves performance
  • Fixes in how we capture the data from subprocesses: previously we were simply waiting for a timeout which could be a problem on slower machines, now we’re getting progress information which makes it possible to wait longer (Bugzilla 1673513)
  • Enable stackwalking on MacOS – always (Bugzilla 1753272). On ARM64 you’ll get all stacks, in Nightly and Beta too. For release x86-64… maybe soon?

Search and Navigation

  • Bug 1749397 and Bug 1751819 – When you type a url in the urlbar or the searchbar, press enter, and press a character, that character gets inputted. For example, “google.com” and enter, and “t”, which becomes “google.comt”. This was fixed by [daisuke].
  • Bug 1752251 – Drew [adw] implemented best match rows in the urlbar view, these rows have a large 52×52 icon with title and URL vertically centred. This is on en-US only for now and is always part of quick suggest results.

Screenshots

15 Feb 06:41

SQL Databases in the Browser, via WASM: SQLite and DuckDB

by Tony Hirst

Several years ago, in a post on Asking Questions of CSV Data, Using SQL In the Browser, I described a rather nifty application called franchise, (from the repo, it seems to have been deprecated for some time, or at least, is no longer actively maintained there). It worked as a general SQL database client, or could be used to manage and query a SQLite database powered by sql.js.

In this post, I’ll review a couple of WASM compiled databses that you can run purely within a browser: SQLite and Duck.db.

SQLite

Several ways of working with SQLite in the browser exist; the following does not claim to be a complete list, just a representative sample, and includes:

  • sql.js and sql.js-httpvfs;
  • SQLime SQLite Playground;
  • JupyterLite xeus-sqlite-kernel.

See also: Seven Ways of Making Use of SQLite.

sql.js

The sql.js package provides a WASM compiled version of SQLite that runs purely in the browser. Databases can be loaded from an uploaded file, or retrieved from a remote URL. If you want to try it out, there’s a simple demo page here:

Barebones sql.js UI

Applications moving off-the-server and into the browser is really handy in many educational contexts because it means:

  • there is no requirement on the user to install any software on their desktop: all they need is a web browser, a network connection to download the environment, and a powerful enough computer to run the application in the browser;
  • there is no requirement on the provider to provide a code execution server: a static web server is all that is required to provide the environment to the user.

A Brief Aside – Serving Webpages Locally Without a Webserver

For purely local running, there may be requirement for the the user to run a local webserver to serve the environment: if you double click an HTML file on your desktop and open it in a broweser with a URL starting file://, the browser may well throw CORS (cross-origin) security errors as it tries to load the page. Fortunately, applications such as servefolder.dev make it possible to run a webserver in your web browser to serve content held locally by uploading it to the browser and serving it from there:

Unfortunately, you can’t run that application locally from a file:// addressed location.

Fortunately, you can install the application as a Chrome app that does work when you are offline:

Install serverfolder.dev for offline running as a Chrome App

Essentially, Chrome will trust apps you have installed from the web into Chrome, but not things you want to run from you own desktop…

Serve folder app

For running simple applications, installing something like servefolder.dev as an app so you can run it offline is really handy when it comes to not requiring a user to run their own webserver. But there is another huge issue that is perhaps currently a blocker for using in-browser apps in an educational setting: if you edit content in the app – for example, a SQL query you spent ages crafting – you lose it when you close the web page: there is nowhere you can save it to and then reload it, nowhere you can persist it, unless you export it / downlad it to the desktop, and then import it / upload it from the desktop next time you run the application.

In the case of sql.js, the minimal demo UI does not persist the database, nor provide any means for saving and reusing queries: it is just a minimal, temporary UI. IndexedDB is a NoSQL storage solution that is supported inside contemporary browsers. Packages such as dexie.js provide a convenient wrapper around it and tools such as manics/jupyter-offlinenotebook can use it to persist items in the browser from otherwise transient web application sessions, such as MyBinder powered Jupyter notebook sessions. It would be handy if a simple template for creating sql.js apps with custom queries and database and query persistence using IndexedDB were available. If you know of such an example, please let me know via the comments.

sql.js-httpvfs

If the database you want to query is hosted via a web URL, sql.js can load the database from the URL. If the database is large, however, this could cause a delay as the database is downloaded, or knock your browser over completely if the database file is very large. Via @simonw, I learned of the phiresky/sql.js-httpvfs package, a fork of sql.js that “provide[s] a read-only HTTP-Range-request based virtual file system for SQLite”. This means that you can host an arbitrarily large SQLite database on a (static) file hoster and then query the database from the browser without needing to download the whole database. The techique used is described in Phiresky’s blog post Hosting SQLite databases on Github Pages (or any static file hoster) (for a full demo, use the netlify hosted version of the post).

The Phiresky blog post also includes a rather nifty web component for embedding, editing and executing SQL queries over the (remote) database, as well as displaying the results.

The results can be displayed in the context of that component, or embedded into the DOM (that is, anywhere in the web page) as inline content. This raises the intriguing prospect of having a web page is essentially a set of SQL queries over a remote database that are then rendered as the web page content.

Also notably, the source code for the original blog post is a markdown file that is rendered to HTML via a custom pandoc filter. I tried to make sense of the source code repository to see how easy it would be to just copy and paste the bits I’d need to run my own minimal demo of rendering a simple markdown file to HTML, with SQL editor components embedded, and querying my own online database, but it’s too web-dev uber-foo for me to be able to even rebuild from the source repository. (Again, if you know of, or create, a minimal example repo that shows how to build a Github Page from the repo that lets you query a database hosted in the repo using the above components – assuming there’s a license or implied license that allows their reuse – please let me know via the comments…)

In passing, I was also prompted to this fascinating interview with Richard Hipp, creator of SQLite, via @simonw. It’s well worth a listen.

SQLime SQLite Playground

Another way of exploring SQLite in the browser that does provide a means of persistence if you have a network connection available is the SQLime SQLite Playground [repo]:

This client can upload a locally available database file, or download and then connect to a database from a remote location:

SQLime “remote” database access is a download rather than a connect…

It would be interesting if SQLime wrapped phiresky/sql.js-httpvfs and also offered its remote query support, methinks (issue)…

File persistence is supported by connecting to Github:

If you then “share” a query, it is saved to a gist and you are provided with the gist link:

The content of the database and the query are then saved as a private gist:

This is obviously quite an expensive operation – each time you save a query to new gist you also save the contents of the database there – so it would be neater if you could alternatively just save the URL location of the database, or be able to support remote connections as per sql.js-httpvfs (issue).

JupyterLite xeus-sqlite-kernel

JupyterLite is Jupyter distribution that runs purely in the browser. One of the available kernels is the jupyterlite/xeus-sqlite-kernel (based on the jupyter-xeus/xeus-sqlite Jupyter kernel). Code cells in this kernel run SQL queries against an in-memory SQLite database, with additional magics defined to support loading of data and rendering of query results as Vega charts.

An example notebook demonstrates how databases can be created and queried.

Example RetroLab notebook running with a xeus-sqlite-kernel .

You can try a live example of the notebook running, via JupyterLite in the browser, here: https://jupyterlite.github.io/demo/retro/notebooks/?path=xeus-sqlite/simple-operations.ipynb

Currently, databases must be created and populated within the notebook. However, a repo issue comment claims a recent PR to the upstream xeus/xeus-sqlite supports magics for downloading a database from a URL (although I haven’t been able to get it to work as yet [issue]) and then opening a database connection to it, so this support will hopefully soon make its way into the xeus-sqlite-kernel at some point.

Notes are persisted in browser storage, and the previously mentioned PR looks like it will also allow the database to be persisted in storage too (though I’m not sure whether browser permissions will allow it to be accessed from other JupyterLite notebooks with a different filename/URL?)

DuckDB

DuckDB is available as a WebAssembly compiled application that can run purely in the browser (Chrome, Firefox, Safari) that claims to offer full support for Apache Arrow.

The intial release blog post – DuckDB-Wasm: Efficient Analytical SQL in the Browser – suggests that DuckDB “reads Parquet, CSV and JSON files from either your local filesystem or HTTP servers”, but whilst it was easy enough to figure out how to download a file from a web URL to my desktop from the DuckDB CLI (.files download $URL) I couldn’t work out how to open a file from my desktop (I thoought .files add might open a desktop file picker, but it just seems to hang the browser without any error messages I could see anywhere…). And whilst I had no trouble querying web-hosted parquet or CSV files, I didn’t manage to query a JSON file. (I also note that it would be hand to query a remote sqlite databse, especially one configured to best support efficient remote sql.js-httpvfs style connections).

The WASM client is fronted by a simple terminal, shell.duckdb.org. (I found that if I did anything wrong it would just hang and I had to reload the page; no ctrl-c etc to get out of trouble.)

DuckDB WASM terminal

The client appears to support queries onto remote files. For example, queries can be run over remotely hosted CSV files found randomly on Github:

The first query appears to download the whole file into memory, and the second query then essentially runs against that.

Queries can also be run over remote parquet hosted files, which I assume could be of an arbitrary size, without the need to download them in full:

Queries also seemed to run against arbitrary parquet data files I found on Github:

I couldn’t find a way to load or query a JSON file, though. Or persist and save and retrieve queries? If you know of a simple DuckDb tutorial that gives a complete set of worked CLI examples, please… let me know via the comments:-)

15 Feb 06:39

Dolby Atmos’ role in better digital experiences

by Robert Scoble
Photo by Robert Scoble. Empire of the Sun performs at Coachella. So far the experience of concerts are out of reach of most people. Dolby Atmos promises to close the gap between “real life” music and recorded music you can enjoy in your home or car.

First of all, what is my goal? It is simply to find ways to make my systems (which include many headphones, cars, and Sonos system) sound better and to help you enjoy your system.

There is a bigger goal I have, which is to get the Spatial Computing industry to care a lot more about audio, since music is a foundation for a lot of storytelling, and a huge amount of the difference of, say, watching the Olympics in person or on TV. Even “silent” films from 100+ years ago have music as part of the story. What is Dolby Atmos and why am I so excited by it (enough to make playlists that have tens of thousands of songs on them, all in Atmos, and to talk with the music industry frequently)?

Neil Young took me into his studio to teach me this “gap” between a real-life performance, what was captured on the master recordings, and what people hear coming from their headphones or speakers. On most equipment the gap is huge. But now consumers are getting systems that greatly close the gap. Or, could, if they are fed music with higher resolutions and with the ability to build surround sound stages that sound closer to real concerts. That’s where Dolby Atmos comes in.

When you go to a real game, the sound is incredible. So far consumers don’t have the equipment, nor the source, to help close that gap. Dolby Atmos closes the gap between a real concert and something you would experience digitally. And closes it in a huge way. It used to be that only wealthy schools could do what my Sonos is now doing.

It gives us several things:

1. It virtualizes speakers. So that sound can be put all around a listener.
2. It turns audio into objects that can be played properly on everything from a $250,000 speaker, to cheap speakers on a modern iPhone.
3. It still includes a stereo render so that the music can play on all equipment, even those that don’t support Atmos (since that’s the vast majority of devices that people listen to music on).
4. More bit depth, so sound is better quality.

Putting audio on things, either real or virtual, will be a big deal. The #1 app on Meta’s (formerly known as Facebook) VR headset, the Quest 2, is Beat Saber. Which uses music. But which sounds like crap because it’s 2D music, not Spatial Audio, like what Dolby Atmos delivers.

I’m not paid/compensated in any way by Sonos, Dolby, Apple, Amazon, or any company I discuss online (if I ever am, I will disclose that).

My qualifications? I’ve collected tens of thousands of Dolby Atmos songs on Apple Music and moved a lot of those over to other services like Tidal and Amazon so that I can compare music services. If you want help with a specific kind of music, drop me a line, and I’ll send you my playlists on Amazon or Tidal. Apple is the best place because Apple has the biggest catalog of Dolby Atmos that I’ve been able to find. Amazon sounds better, even on Apple headphones, due to using newer Dolby Atmos technology than the others, but it has fewer songs, particularly for those of you who like classical music.

Spatial Audio is something I’ve been studying for decades. I’ve been in Virginia Tech’s building for Augmented Reality research which has 1,600 speakers in one room. When I visited they put me in a recorded football game which blew my mind.

Neil Young had me in his studio to understand what his analog masters caught of his performance and how much of that is stripped away by technology delivering music at home. I’ve visited with many audio engineers in many studios. Just so you understand that while I’m not an audio engineer, I do have more education on the topic than most people who aren’t audio engineers and I’ve even met audio engineers who are completely working in stereo and who don’t understand Atmos. The music industry is cleaning those people out and building new studios around the world for Atmos.

++++++++++

What is Dolby Atmos?

Instead of talking about bits and bytes and nerdy stuff, let’s ask ourselves “what is the goal for us to recreate music recordings in our home?”

For me, I have seen hundreds of performances from the front row. Buddy Guy played guitar sitting right next to me for 20 minutes. Reggie Watts performed two feet in front of me in Preservation Hall with the band there. I’ve been to Austin City Limits, Coachella, and many festivals.

My goal has been to recreate this concert experience at home. Most people can’t afford to go to, say, Coachella, to listen to live music. Marshmellow played there to about 30,000 people. A few years later he was on Fortnite performing to 11 million. And it sounds like shit compared to Atmos on my Sonos system. The gap between the performance on Fortnite and what his concert in real life was like is huge.

We can do better.

So, let’s start out with something simple.

A three-piece band. A singer. A drummer. A guitar.

The old way was to record in “stereo.” Two audio channels. And distribute that at 44.1 khz, or worse (Spotify is usually compressed on top of that). That is what is on CD’s (which I first started selling around 1980 in the consumer electronics store I worked at).

In stereo the band is “stuck” mostly between your two speakers with a little that goes outside of that. When we sold audio gear in the 1980s we’d say “this speaker has a wider soundstage.” Because in front of you you could more clearly hear where a flute or clarinet was in, say, a symphony.

Today, with Atmos that soundstage can be all around you. The guitar can be in a specific place in 3D now. That wasn’t the case with stereo. In theory Atmos can move things around differently in the future, too. The Atmos technology has separated where sounds are coming from apart from the sounds themselves.

The process of making Dolby Atmos is different than it used to be. Now a technology team needs to “program” where sound should be around you.

That is impossible to do in just stereo. Audio engineers sometimes even put each performer on a different speaker in their studios and move those physical speakers around to decide where to put each on the computer, which translates to your Sonos as “drums in back, guitar on right, singer in front.”

In my home, with my system, this sounds like my whole room comes alive with audio that extends behind my speakers, over my head, and even behind me if I have the speakers directly to my sides, or a little behind me. Sometimes it even “fakes” sounds behind you where there aren’t any speakers. You can hear this actually on an iPhone 13 Pro or Max phone. Play Dolby Atmos music on such, make sure you see the Dolby Atmos logo (if you don’t there are a couple of places in settings you need to change, and you need to pay for the top tier of music services (particularly important on Amazon Music) to get it. Turn your phone and you’ll notice that sound often appears like it’s coming from next to you or, even, behind you where there are no speakers!

I also noticed in my headphones and in my car that Atmos music has better bass and music clarity when Apple turned on Atmos last year. That’s what got me interested in Atmos. Soon after I had purchased my Arc bar and started talking with musician friends and audio engineers about this.

The reason, the engineers tell me, that Atmos has better bass and audio, is because when the music is sampled it not only has more samples (48 khz vs 44.1) but also has more bit depth (the numbers are longer, which makes for better sound, thanks to more information).

Some of those benefits come from “high resolution” music (music recorded at higher sampling rates than what was used to record CDs) but if you have a full surround sound system you hear it isn’t just that: that the music is fundamentally different than it used to be.

Some purists argue that it isn’t what we should do. That stereo is how “God” made recorded music and we shouldn’t mess with that.

I come from a different place: if we really are going to take audio to the next level we must go way beyond stereo.

I hear another resistance: that there is a better way to do Spatial Audio, particularly in VR, since the platforms that make VR can put sound on any of the virtual polygons that make up what you are seeing in a VR headset. The problem here is that the music industry has decided to go with Dolby Atmos, or a similar technology, 360, from Sony.

So, we need to see VR headset manufacturers really support Dolby Atmos at a deep level and make it so that the virtual box around the listener can be “attached” to the real world, so that we can really recreate a concert experience (I’ve been on stage at concerts where musicians are playing and in real life you can hear what it sounds like between, say, the guitar and drums. You can’t do that at home yet.

+++++++++++++++++++++

What about the future?

The holy grail is to “fool” the listener into thinking she/he is at a concert, where sound is coming from all around you, particularly when you are at something like Coachella. There they have dozens of speakers in front, above, and behind you, and that sound is bouncing off of everything else.

We aren’t there yet.

Now add on augmented reality or virtual reality glasses. They could “lock” the Atmos virtual box to the real world, letting you “walk around” a band. Like you can in a real concert.

It is this goal that has me most excited. If we can put a 3D sensor on your face, along with screens that cover your eyes, and headphones that bring real surround sound, and cover your ears, we can deliver much better audio than headphones can today.

So far we haven’t seen this “holy grail” ship to consumers. I expect that in the next year that will change.

Which is why I’m collecting all the Atmos music I can. When you get one of the devices that I know is being built by Apple, Meta, Tesla, and others, you’ll be able to hear the magic of Atmos.

Until then, start “future proofing” your playlists, by choosing to collect Dolby Atmos. By the end of next year you’ll see that will be much more important than it is today.

Music never sounded so good!

Here are the largest collections of Dolby Atmos music anywhere:

Apple: https://music.apple.com/profile/scobleizer

Amazon: https://music.amazon.com/profiles/s5yxpchb5am5nbpi5ylmmrqrry?ref=dm_sh_gEk0YWvS1hxV9Tgn0JGEfkFuQ

Tidal: https://listen.tidal.com/playlist/6603219c-65cf-4299-87e9-54cad6e729ab (search for “100% Dolby Atmos” to find 50+ other lists).

15 Feb 06:39

Why Bad Code Exists

“How dare you call my code bad! <gnarl> <gnash>”

We’ve all had the experience of opening up a source file where everything just makes sense. Nothing is surprising or confusing, and we can easily make changes. Perhaps there is some passage that we don’t immediately grok, but when we reason it out, we’ve happily learned a valuable skill or technique. We’ll call this good code. It is profitable.

We’ve all also encountered code that’s just the opposite–it’s hard to read, hard to follow, and difficult to change. On puzzling through a confusing passage, all we get out of the deal is an understanding of what that difficult chunk of code does; there is nothing to raise our skill level. This is bad code. It is not only unprofitable, it increases costs for those who must later work on it.

alt-text

We don’t believe programmers intentionally seek to cause pain. Pretty much everyone is just trying to do a good job and be helpful. Still, we all write good code and bad code. We learn. We fix things. Let’s move on and not sweat the labels so much.

No continuous (active) review process

Back in our solo programming days, we’d whip up code all afternoon, then head into a test/fix cycle near day end. We’d look at our working code with pride–”gosh, that looks good”–then integrate it. Pull reviews weren’t really a thing back then, though sometimes our code would endure a semi-formal review process. We were often surprised and offended when others didn’t agree that our code was wonderfully made.

Code written by a solo developer makes a lot of sense to its author… at least while it’s fresh in their head. But others usually find it harder to follow–and that later includes the developer themself. This can even be true when the original developer tried hard to keep code clear via refactoring.

Post facto (not active) review processes come with a host of challenges:

  • With only a sole reviewer and a closed process, the whole codebase can become subject to the whims of one person.
  • The review process can devolve into a gate slowing the flow to production, particularly when the team insists on a large number of reviewers (which is one potential reaction to the previous concern).
  • Most developers find post facto reviews a distracting nuisance, and thus minimize their efforts on them. The resulting rubber-stamp process creates false confidence and pointless delay.
  • Even with the right number of folks each trying hard, post facto reviews typically miss deeper problems. Reviewers weren’t privy to the deep conversations and decisions that were distilled into the code, and often offer only surface-level complaints as a result.
  • Even when significant problems are found, it’s often too late and too expensive to fix them. A cycle of code/review/rewrite/re-review isn’t effective. Nor is code/review/release-bad-code.

We want to instead examine the code, learn from it, propose alternatives, improve it, and grow the skills of the whole team all at the same time. A review process is an opportunity for rich communal learning.

An active review process like mob or pair programming dramatically reduces the potential for inscrutable or otherwise bad code to escape our development session. Errors are spotted and corrected before we move on. “Given enough eyeballs, …

This bad code exists because it was the product of one person’s cleverness, rather than a solution the entire team has blessed.

No editing process

When writing, your first job is to get your ideas onto the page. But those first thoughts of yours are almost never expressed in a way that is crystal clear to others. Your second job, then, is to edit the first draft so that it makes sense to readers. All writers, even the great ones, review and edit their prose.

Programming should work no differently: Once you get a brilliant bit of code working, you must edit, or refactor, the resulting code. Why? Because it’s easy to introduce numerous design flaws, both small and large, in every few lines of code. You refactor to fix these inevitable deficiencies, to make the code less costly for others to understand and maintain.

Too many developers don’t have an ingrained editing process, however. They get the code working, then move on: “We need to start the next assignment.”

There’s also little impetus to change code once you get it working. “If it ain’t broke, don’t fix it”… because fixing it increases your likelihood of breaking other things without even knowing it.

In contrast, test-driven development (TDD) is one possible disciplined approach that insists on code editing every few minutes. The built-in refactoring step of TDD allows developers to maintain a high level of quality, rather than yield to the typical slow-but-sure degradation of a codebase.

This bad code exists because it represents only an initial draft, and not an edited final product.

Insufficient technical knowledge

When we work with “hyperproductive” folks, we find they have three key characteristics. Developers lacking any one of these characteristics lack what’s needed to efficiently produce code that works without unintended consequences:

  • Knowledge and understanding of the technical stack. When we don’t understand the stack well enough, our work can take the form of overly-complex and/or fragile work-arounds (hacks). Not only does this foster errors, it also results in convoluted, rigid, bad code.
  • Disciplined, habitual use of quality practices. Habits and practices like TDD, small steps, refactoring, or ensemble programming move us toward a disciplined, engineering approach to software development. These good habits don’t slow us down; they power us up and allow us to produce good code quickly and sustainably.
  • Key understandings of software design principles. Not adhering to long-established software design principles is a sure way to dramatically increase the costs of maintaining systems. Unfortunately, we’ve moved into what seems to be a post-design era. Modern development processes have been misinterpreted to the point where we’ve heard things like “agile says we must not do design.”

    To us, the accumulated wisdom of most developers seems like a random collection of acquired experience rather than a consistent and holistic design perspective. Many once learned about such a perspective, but over time replaced its legitimate principles with stories based on contextual biases–i.e. what they managed to get working at one time. Success can encourage the logical fallacy of hasty generalization.

    Undisciplined code resulting from a defective or incomplete understanding of software design creates immediate costs. It takes longer to navigate, understand, and maintain code as the result of things like poor naming, overly-complex logic, redundant logic, poor organization with misplaced responsibilities, and complex dependency chains.

    For many, that significant accomplishment of “making it work” is good enough. As a result, it’s usually tough to convince them that their code is only going to make it harder on others.

The importance of maintaining the quality of a codebase is well-documented, as are the techniques to do so, but far too few developers engage with the literature.

This bad code exists because it was created by people who didn’t know enough to build it well.

Time pressure

When we ask why people have defects, or have neglected their codebase in any way, the near-universal answer is “we were in a hurry.” Often they provide a legitimate reason for their hurry. Some deadlines can’t be moved.

Managers pressure people to turn around their tasks more quickly, to complete things that are started, to move on to the next thing, and to address completed-but-defective work: all at the same time; all Right Now. Why? Because the managers themselves are under pressure to deliver, as are their managers, as are theirs.

Some aspects of time pressure are positive:

  • It helps us learn to be more efficient.
  • It reminds us that our users need solutions to problems sooner.
  • It keeps our sponsors and stakeholders happy.

But far more are negative:

  • It instills fear of being fired or reprimanded for missing a date.
  • It motivates us to cut corners.
  • It creates resentment when deadlines are bogus–for something other than the delivery of true business value (“we’ve got to finish this document by Monday”).
  • It fosters assessments of people (for promotion, raises, or even continued employment) based on how busy they look rather than how productive they are.
  • It results in naive managers trying to make up time by pushing people harder, particularly when delays are built into the company’s software process.
  • It creates more work for others down the line, particularly in the code.
  • It prevents us from learning what we should. While we know that learning a tool, technique, or framework can make us more efficient and effective, we know that it will take away precious time now. We want to be experts, but we aren’t sure we can afford the time to get there. As a result, we and our teams muddle through.

There is always pressure to begin, perform, and complete work. But a strategy of rushing and cutting corners can only work for a while before it collapses. Eventually, there is so much half-done and hastily-dispatched work piled up that it becomes difficult to get anything done at all.

This bad code exists because it was the quickest thing that a person under pressure could accomplish without learning anything new.

Inadequate technical controls/fear

Nobody wants to be the scapegoat for a production disaster, particularly when it involves changing code that was working before. You try to add functionality by minimizing the impact to existing code out of fear–even if you know that your changes violate every principle of software design ever written. You pass around another boolean flag; you deepen a nest of if statements, you duplicate a complex function in order to add a tiny new behavior–because that’s safer than doing the right thing. The right thing involves re-shaping to well-designed code, a highly risky activity without test controls.

Bad code got you into this mess. More bad code won’t get you out of it.

What to do? You can initiate a rewrite, which is tricky: Without requirements captured in tests, it’d take forever to determine every last thing the rebuilt system needs to do. As you rewrite, new requirements will keep coming. Good luck keeping up with implementing them in the old (live) system as well as the new.

Alternatively, you can start adding characterization tests to support refactoring the code, which can foster more tests and more good code. You can eventually get the whole system under the safety of a significant umbrella of automated tests. It sounds like a lot of work, but not getting things under control also sounds like a lot of work… and a lot of fearful risk. No one should have to live in fear.

A good suite of tests provides you with high confidence to change code, by revealing most errors before they end up in production and usually before they can escape your desk. These protections prevent financial loss and catastrophic runtime failures.

This bad code exists because it’s the product of someone afraid to do the right thing.

Lack of care

Yes, there are people who literally do not care if their code is bad. It’s hard to imagine for most of us, we know.

Why would someone take a job where they have no interest in being skillful? Ah. Imagine the jobs you might have taken as a teenager–slinging fast food, counting change at a register, or hefting packages at a warehouse. You knew you weren’t in it for the long haul, so you learned enough to draw a paycheck, but you didn’t make it a specialty or become an expert at the work. You learned enough to not get canned, hoping to move on to better jobs.

Many things in software demand attention, but people have to choose where to focus–to each, what they consider the real work. The other things are the silliness that they have to endure so that they can get on with the real work. Time cards, status reporting, writing unit tests after-the-fact, and pull requests are a few things that people drop into the silliness category.

Fairly common are those who only know enough, say, HTML + CSS + Javascript to be able to survive making changes in their team’s front-end environment, partly because they only occasionally find themselves working in it. Because these folks aren’t deeply invested in the environment, they muddle through the work rather than learn enough to do it properly. Certainly many of these folks care, or want to care; we might graciously chalk up their bad code to time pressure. They need the room and the permission to care.

This bad code exists because someone didn’t care about you or your teammates.

You care, because you’re taking the time to read this article. Help others find the knowledge, room, and permission to care.

Keep an eye on our public courses or enroll in one of our technical workshops for help in curing the causes of bad code.

15 Feb 06:36

The Trucker Convoy, Public Space, and Public Law

by Book Reviews
The Canadian protest movement known as the trucker convoy or freedom convoy has garnered national and international attention. The protest started as a response to the Federal governments’ expansion of the vaccination mandate to include …
15 Feb 06:36

Stripe: Platform of Platforms

by Ben Thompson

Stripe's announcement of Treasury — banking-as-a-service — manifests the breadth of the company's ambition.


Today Stripe is announcing Stripe Treasury; from the company’s press release:

Stripe, the technology company building economic infrastructure for the Internet, today announced that it is launching Stripe Treasury. This gives Stripe’s platform users powerful APIs to embed financial services, enabling their customers to easily send, receive and store funds…

Stripe Treasury…enabl[es] platforms like Shopify to easily offer its merchants access to critical financial products to manage their businesses’ finances. With Stripe Treasury, platforms can offer their users interest-earning accounts eligible for FDIC insurance in minutes, enabled by Evolve Bank & Trust. Platform business customers can have near-instant access to revenue earned through Stripe, spend this directly from their balance with a dedicated card, transfer it via ACH or wire transfer, pay bills, and more.

Stripe Treasury, as its website notes, is banking-as-a-service, but, critically, Stripe is not a bank; look carefully at the product’s press image:

The promotional image for Stripe Treasury

That is an API call creating a bank account at Goldman Sachs for a pilot on the Rocket Rides platform. Notably, Goldman Sachs is not the only big bank on board; again from the press release:

Stripe is enabling standardized access to global banking capabilities via APIs by developing its bank partner network to include Goldman Sachs Bank USA and Evolve Bank & Trust as US partners, and Citibank N.A. and Barclays as global expansion partners. Stripe will fulfill compliance and regulatory requirements in partnership with its US banking partners to make it easy for platform customers using Stripe Treasury to embed banking experiences into their products. And through Stripe, these banks are able to extend their reach to millions of businesses.

This is a textbook example of the power of platforms; consider an operating system like Windows: any number of applications can run on any number of computers thanks to there being an abstraction layer in the middle:

A drawing of The Concept of an Operating System

This is analogous to the layer for banking that Stripe is offering with Treasury:

Stripe's position as a platform

This explains that API call above: a Rocket Rides pilot doesn’t have the wherewithal to open a business bank account at Goldman Sachs, and Goldman Sachs doesn’t have the flexibility to offer a banking account to individual entrepreneurs. This, though, is the exact sort of problem platforms solve: they provide an abstraction layer that connects different sides of a market, even if those different sides have dramatically different needs and capabilities.

Stripe and Shopify

It is Stripe’s partnership with Shopify, though, that is particularly compelling, and emblematic of both how powerful Treasury can be, and how extensive Stripe’s platform ambitions are. Again from the press release:

For businesses today, accessing financial services can typically involve a series of bureaucratic hoops and a lengthy application process. According to recent Stripe research, setting up an account takes 5 and a half days on average (and 7 days on average for online businesses), around one in four (23%) businesses have to send a fax to open an account, and over half of businesses (55%) are required to visit a branch in person to open a bank account. Financial services simply weren’t designed for the modern internet, and this is a pain point for businesses today: nearly half (46%) of companies report that their banking experience has hindered their company growth.

This is a pain point I know quite well; Stratechery is incorporated in the U.S., and I had to fly back to the U.S. for the express purpose of opening a business bank account!

This kind of off-line banking experience is increasingly incongruous in a world where 76% of businesses (e.g. retailers) use an industry-specific software platform to manage their business, a figure that increases to 92% for businesses with more than 500 employees. The feedback from Stripe’s users is that they want a digital solution for financial services available directly within the software platform that powers their operations. On the flipside, Stripe’s platform customers are increasingly looking to embed financial services into their own product, but oftentimes face barriers to doing so.

Now with Treasury, someone starting up a new Internet business can simply start selling goods, services, or yes, subscriptions, and have their banking needs met by the same software which is powering their business. Stripe co-founder and President John Collison explained in an interview:

Which seems more ergonomic for a business? That they decide they’re going to start an online store and the very first thing they do is go down to a bank, and maybe in person, and they’re going through that process, they’re setting up their accounts, then they come back and do some white boarding. And they’re like, “Hmm, what should our business be?” That’s not how it works.

How it works is they have this cool idea and they try it out and they open a Shopify store for it and they have this money coming in. So we need a way to access those funds, now they will be able to, with Shopify Balance, manage their funds directly within Shopify. That latter thing sounds like a much more natural and ergonomic way to handle the cash flows of their business.

What is notable about Shopify is that it too is a platform, and a very powerful one at that. This is how I described the company’s then-new logistics offering in 2019’s Shopify and the Power of Platforms:

What Shopify is doing is what platforms do best: act as an interface between two modularized pieces of a value chain.

A drawing of The Shopify Ecosystem
Every referral partner, developer, theme designer, and now 3PL provider are simultaneously incentivized to compete with each other narrowly and ensure that Shopify succeeds broadly, because that means the pie is bigger for everyone.

On one side are all of Shopify’s hundreds of thousands of merchants: interfacing with all of them on an individual basis is not scalable for those 3PL companies; now, though, they only need to interface with Shopify.

Thus the title of this Article: Stripe isn’t simply a platform, it is a platform for platforms.

Stripe Capital

This broader understanding of Stripe’s ambition became clear to me earlier this week with another announcement, Capital for platforms. Stripe Capital itself is not new; launched in 2019 the service lends money to businesses that use Stripe’s payments processor; as Bloomberg noted at the time:

As the industry has become more digital, PayPal Holdings Inc., Square and even Amazon have introduced small business lending programs, as have a slew of startups including SoftBank Group Corp.-backed Kabbage Inc. and public company OnDeck Capital Inc. Though lending poses risks, Stripe, much like other payment services, says the extra data it has on customers will give it a better idea of whether borrowers can repay loans. The company believes that edge will protect it from significant losses during an economic downturn.

Stripe Capital seemed both obvious and, as the article notes, rather unoriginal; this week’s expansion — which was announced with a 29-word blog post — makes clear it is much more. Carefully read this tweet from founder and CEO Patrick Collison:

Note the word Patrick Collison emphasized: *your*. Capital for platforms is not for Stripe’s customers, but rather the customer of Stripe’s customers, which is to say, Stripe is asserting itself as the platform of platforms; go back to the news that Shopify Balance will be powered by Treasury:

Stripe as a platform for platforms

Stripe does not have a customer relationship with all of the Shops on Shopify; that is exactly what Shopify is good at, so why would they? Instead, Stripe is focusing on what it is good at: providing that API layer to banks that will never have the capability to serve Shopify Shops, and exposing said layer to Shopify to incorporate into their product.

Notably, Treasury skipped the intervening step that Capital started with: Stripe isn’t exposing banking-as-a-service to customers directly on Stripe, but rather making an API available to those customers to offer to their customers. John Collison explained to me:

We have a lot of conviction about this idea that the financial services that a plumber needs will be different from financial services that an e-commerce company needs will be different than financial services that a gym or a yoga studio needs, and they will be provisioned by different companies. Given that we have lots and lots of exposure to those kinds of businesses with our platform partners, this is a great way to get started with that.

This means the above illustration, fully realized, looks a bit like this:

Platform of platforms

Stripe’s Ambition

Here I think Stripe’s goal — building the economic infrastructure for the Internet — is instructive. Consider the Internet itself: you are reading this Article on the Internet via a connection provided by an Internet Service Provider, which is a relatively local affair that is designed for a particular geography. It is Internet Service Providers that connect to a grand network of cables that is known as the Internet backbone; this map from Telegeography, for example, shows the world’s submarine cables:

The Internet's submarine backbone

This image is incomplete — major portions of the Internet backbone obviously run overland — but is sufficient for the analogy: Stripe isn’t necessarily competing with other fintech providers — ISPs in this analogy — but instead is seeking to be the backbone for all of them, as well as an entirely new universe of platforms that can offer their unique customers financial services that are perfectly tuned to their needs.


Stripe is ten years old now, but the ambition implied by these announcements explain why the founders claim they are just getting started. John Collison noted:

We are still very early in developing the set of Stripe products beyond the core payments engine, things like Treasury. We’re building a global payments and treasury network, and we are in November of 2020 launching the Treasury part of it, and so we are just now filling out all the acronyms in our product suite, and that’s the version one of the product. And from a growth point of view, our business is growing really rapidly in APAC and EMEA, and so we’re just early in the business trajectory with all the helter-skelter-ness that comes from that.

Speaking as an analyst, I would like nothing more than to see an S-1 from Stripe, but it sounds like it’s not coming anytime soon (and I can state with a high degree of confidence that Stripe will not be doing a SPAC with any of its rumored suitors); the company is reportedly raising more money, but is increasingly spending the money it raises on acquisitions and investments (one would certainly assume that the core payments business is not only profitable but also has a very attractive cash conversion cycle).

Instead the company is busy building, well, exactly what it has said it was building all along: economic infrastructure. And, I will freely admit, until this week I didn’t completely appreciate just how mammoth an undertaking that was.

Stratechery subscribers can read the full interview with John Collison here; it is also available for subscribers via podcast.


Subscription Information

Member: Roland Tanglao
Email: rolandt@gmail.com

Manage your account

15 Feb 02:35

How to Get the Most Out of Your Dishwasher

by Christina Williams
How to Get the Most Out of Your Dishwasher

You’ve cooked, you’ve eaten, and now it’s time to clean up. It helps if you have a good dishwasher. There’s nothing quite like sitting back and letting an appliance do the work for you, especially when your dishes come out sparkling clean. But what happens if they don’t?

Dismiss
15 Feb 02:35

The Lindsey Vonn Book

by bob
“Rise”: https://amzn.to/3uKX5kO She’s not the person I thought she was. Not that I had a huge desire to read this book. I just reserved it at the library and when another book I was reading lost my attention I decided to skim “Rise,” but I got hooked. Lindsey’s image… Beautiful untouchable champion. Smiling and fabulous […]
14 Feb 16:58

Twitter Favorites: [tomhawthorn] A thing too many Westerners don't understand about electoral seats: Greater Toronto has more people than British C… https://t.co/IeCzCzUcoQ

Tom Hawthorn @tomhawthorn
A thing too many Westerners don't understand about electoral seats: Greater Toronto has more people than British C… twitter.com/i/web/status/1…
14 Feb 16:55

Canadian antivaxxers try shilling crypto after failing to fund their trucker protest

A group of protesters gathering outdoors. One is holding a Bitcoin flag, several others hold Canadian flags.

A protest in Canada against COVID-19 vaccine requirements for truckers re-entering the country, known as the "Freedom Convoy" has tried to crowdfund in several ways. A GoFundMe campaign that raised over CA$10 million was taken down after terms of service violations. A campaign on the right-wing favorite GiveSendGo raised over CA$8.2 million, but funds were frozen after an injuction by the Ontario Attorney General. The GiveSendGo platform also catastrophically failed to secure sensitive user data, and suffered a huge leak of donor data including scans of passports and drivers licenses, which is being made available to journalists and researchers by the inimitable DDoSecrets.

The protesters eventually turned to Bitcoin and other cryptocurrencies for crowdfunding, even appointing a "Bitcoin team lead" who rambled on in a livestream about not "being shackled by the censorship put in place by our legacy financial system", much to the confusion and annoyance of some viewers. One commenter asked, "Are we at a press conference for Freedom Convoy 2022 or having some guy shove Bitcoin down our throats?" As of February 9, the group claims to have raised $300,000 in Bitcoin, and $500,000 in other cryptocurrencies.

14 Feb 16:55

Twitter Favorites: [Flickr] Happy birthday to Flickr! We’re celebrating the only way we know how - with the wonderful Flickr community. Join… https://t.co/dZ5IfxzHh3

Flickr @Flickr
Happy birthday to Flickr! We’re celebrating the only way we know how - with the wonderful Flickr community. Join… twitter.com/i/web/status/1…
14 Feb 16:46

Twitter Favorites: [RobCottingham] There's something I find warming, charming, reassuring and helpful in the little wave so many people give at the end of a Zoom call.

Rob Cottingham @RobCottingham
There's something I find warming, charming, reassuring and helpful in the little wave so many people give at the end of a Zoom call.
14 Feb 06:38

jless

jless

A really nice new command-line JSON viewer, written in Rust, created by Paul Julius Martinez. It provides a terminal interface for navigating through large JSON files, including expanding and contracting nested objects and searching for strings or a modified form of regular expressions.

Via Hacker News

14 Feb 06:37

No, Google isn’t making college degrees obsolete

Ben Wildavsky, Work Shift, Feb 11, 2022
Icon

"It seems reports of the demise of the bachelor’s degree have gotten ahead of the facts on the ground," writes Ben Wildavsky as he reports on a study (30 page PDF) released by the Burning Glass Institute. "Last year nearly eight in 10 information technology postings at Google and more than seven in 10 at Apple specified a bachelor’s or above." That said, the report begins with the following observation: "Employers are resetting degree requirements in a wide range of roles, dropping the requirement for a bachelor’s degree in many middle-skill and even some higher-skill roles." In particular, "Some 46% of middle-skill and 31% of high-skill occupations experienced material degree resets between 2017 and 2019." The trend described in the report is the opposite of the interpretation offered by Wildavsky. Which is why you should always read the report.

Web: [Direct Link] [This Post]
14 Feb 06:37

Getting Some 1980’s Closure

by Ton Zijlstra

Favorited The Cube: solved after decades by E

Back in the 1980’s while in secondary school Rubik’s cubes were everywhere. I tried them, but never learned to solve it. When instructions started appearing in mags I thought that was a kind of cheating. Y brought a cube home recently and simultaneously Kev Quirk posted his videos of how to solve the cube. There’s method and alogrithms involved, and even just recognising the method (a cross on one face, then the corners, then the 2nd layer, then the cross on the opposing face, then the final corners) is already an immediate help, even without the turning algorithms. So some 40 years on, I finally get closure on a 1980’s loose end. All because of some pandemic induced time on hand. 😉

I’m not as practiced as E yet, who can solve it anytime now. But using the instruction videos I did solve it once.

More than thirty years later, Daughter came home with a mini-cube in her bag. A birthday gift from one of her classmates. A few weeks later Man stumbled upon a series of videos made by one of his indy web connections. …. Last Saturday I started practicing and yesterday I finally solved it without looking at the instructions.

E

14 Feb 06:36

Weeknote 06/2022

by Doug Belshaw
Khai Khai restaurant

Apparently you can’t diagnose ‘Long Covid’ until at least 12 weeks after infection. Hence I’ve been talking about having ‘Medium Covid’ as it’s been a couple of weeks since I finished my self-isolation I’m still tired. This tiredness manifests itself as getting up later (08:00 instead of 06:30) and my baseline energy levels being on the whole lower.

I’m not a believer in mind/body dualism, so I’ve been going out of my way to ensure that I can discount the psychological element. As a result, I’m still trying to do exercise every day — mainly either arm or leg weights at the gym and the exercise bike in my home office. The thought of running, as I did last week, and my heart rate spiking up to 170 worries me.

Tomorrow, I’m planning to walk the 9.2 miles to Druridge Bay. That’s not particularly far (and in fact, I’ve walked there and back before) but it’s a bit of a test to see whether I’ll need to postpone my plans to walk Hadrian’s Wall during the first week of April. The idea was to walk about 15 miles for five days and camp each night. If I’m particularly tired after walking ~10 miles it wouldn’t bode particularly well.


This week, I did a mix of really interesting work and clocked 26.75 paid hours. My theory is that people who are full-time employed pay a two-hour coordination meeting tax per day that I don’t have to because of my tight alignment with Laura.

That’s not to say, of course, that we don’t disagree or have any conflict. Of course we do. The important thing is how we deal with it, and the two-part Reframing Conflict workshop we did has really helped. The FONT framework that Outlandish use is a form of non-violent communication which I think is particularly useful for people working remotely.

It’s also quite useful as a parent, especially of teenage kids, and can also be used with one’s partner. Talking of Hannah, I booked a suite at Malmaison in Newcastle last Sunday night and we had a fabulous dinner at Khai Khai. We both took Monday morning off. The older I get, the more I realise how much important relationships take work, even when things are going well.

Here’s some of the things I’ve been working on, both through WAO and Dynamic Skillset this week:

  • Bonfire Zappa project — this is my favourite project at the moment, and you can tell because I not only did some user research and desk research, but wrote one blog post about it and one that was inspired by it.
  • Greenpeace — we continued to try and reduce the amount of ambiguity in the web strategy project, and we worked on other project with them that I can’t talk about.
  • Keep Badges Weird — the main action this week was to run the first community call for the project, which we’re doing in collaboration with Participate.
  • Julie’s Bicycle — we’re trying to move the Creative Climate Digital Platform from the planning to the discovery stage, but are bumping up against some ‘treacle’ which is slowing us down. I’m hoping that is resolved soon so we can get on with doing some user research, after delivering a well-received digital strategy.
  • Tao of WAO — Laura and I recorded an episode of our podcast about dis/misinformation and we released one we recorded with Kerri Lemoie on verifiable credentials.

I’ve signed up for a free course from Tethix next month about tech ethics. It looks like it’s going to be excellent, the only fly in the ointment being that the difference in timezone between me and the facilitators. I had the choice of 6am to 9am every Tuesday, or 8pm to 11pm. I initially went for the former, as I consider myself a ‘morning person’, but given my Medium Covid, I’ve asked to switch to the latter!


Other than the above, the only things really to note are that I’ve returned my Asus UX325 laptop as there were random restarting issues that seemed to be resolved by reinstalling the operating system each time. I bought a Mac Mini M1 to replace it, which might seem like an odd move, but ultimately I’m happy with a combination of the (family) Google Pixelbook on which I’m writing this, and my trust Lenovo ThinkPad X220.

The Mac Mini now sits upstairs in what I’ll refer to as “Hannah’s office”, despite that being a rather grand title for the space, and the fact that we try to switch for at least part of the day. (I’ve got a sit/stand desk in my office, you see…)


Next week is the last of the half-term for my kids. It’s usually one where kids, teachers, and parents are tired and I don’t think this one is going to be any different. I think I’ll probably end up having the Wednesday of the half-term holiday (week after next) off, but we’ll see.

The post Weeknote 06/2022 first appeared on Open Thinkering.
14 Feb 06:27

The Kobayashi Maru of Comparing Dates with Times

Saw a fascinating tweet this morning from the excellent Userlist team.

At a minimum, one hundred replies in a Slack thread is the going rate for asking a question about an edge case about times and dates in programming. Just for future reference.

Since Twitter embedding crops things a bit aggressively, here’s the image in the tweet directly:

Tweet screenshot

Immediately, the tweet replies were chaos. The answers included “Yes/Yes/No”, “No/No/No” (which was my initial response, but I’ve also chaotically changed my mind since then), “No/No/Yes”, “Dates are the worst”, and “Have you tried using 🍺? Maybe lots and lots of 🍻 and then maybe just like pretending this never happened?”

As someone who wrote entirely too much about dates and times and edge cases, I found this discussion to be an exciting, total waste of time, and I really couldn’t wait to dig into it some more.

First of all, it’s all wrong

If you find yourself in this position, clearly something has gone wrong. And I say this without judgement, because unless you work in a clean room on a product that has no users and the code is no more than one hour old, you’re going to have issues with inconsistent data, and inconsistent storage of datestamps and timestamps is incredibly common. I ran into a similar problem this just this week with a multitude of inconsistent datestamps and timestamps I had inherited.

And that’s what happened here:

What’s more, there’s an additional issue in the original question that was left out, which astute readers of UTC is Enough for Everyone, Right? might have picked up on already: there’s no timezone data! That’s fairly understandable for the date values, since timezones don’t tend to be needed (which, like most things in this realm, is not always true), but it would be needed for the time values to ensure a valid comparison (conceivably a comparison of 00:00:00 and 12:00:00 on the same “day” could be off by as much as a couple of actual days, depending on the timezone). And, of course, you’d need to store more than just the offset if you properly wanted to account for historical daylight saving time.

Apples and oranges and orange-colored apples

So this is kind of a no-win solution. I can make a valid argument for pretty much every answer in the tweet replies (especially the one about beer). The reason why it’s particularly frustrating is because we make these snap decisions all the time in our day-to-day lives, and it’s pretty easy. When I tell you to meet me for lunch at noon today, there’s a highly likely possibility that we’re talking about being in the same place, the same timezone, and the same day as each other, so we don’t have to spend a lot of time thinking about this.

The issue is that dates and times are kind of supersets of each other. Which is a bit of a paradox. But let’s look at it further:

  • A Date can be thought of a superset of a Time, because all hours and minutes and seconds naturally belong to a certain day.
  • A Time can be thought of a superset of a Date, if you consider timespans to be an extention of a particular Time. Noon to noon spans two separate days. Or, well, just one day, if it’s a 24 hour day instead of calendar day. Even my paradox explanations have paradoxes in them.

Both of these are kind of wrong definitions, and also kind of right, which is why you can make these justifications for so many answers here. It really comes down to what you value.

Literally we’re all just making it up

This is the crux of why I find this stuff so fucking fascinating. We programmers famously tend to view the world in a real binary sense: the code runs or it doesn’t. The tests pass or they don’t. The record is valid or it isn’t. It’s a very helpful way of looking at the world… until it isn’t. Usually it’s not baked directly into the system, though.

There are certain examples where inherently correct answers don’t exist. My favorite example of this — and yes, I have favorite examples of time issues — is recurring events over a location-dependent daylight saving boundary.

Say you have a weekly 10am Pacific Time recurring calendar event with the rest of your dev team. Like a proper remote-first company, you’re broadly distributed instead of just having a main team in one city and one rando working “remote”. That’s great, but it also increases the odds of having one city or region or country having different daylight saving policies than the others (if they even have one at all).

You keep having your 10am call for a few months, and then Virginia, who lives in West Virginia, starts her daylight saving time in March. So now the 10am Pacific meeting time, which was 1pm her time, would still be 1pm for her since Pacific time always follows DST, too (except for Yukon, in Canada, which decided in 2020 to stop following DST, of course). But your teammate Brooklyn, who lives in Phoenix, doesn’t have daylight saving time because she lives in Arizona, which doesn’t follow daylight saving time (but don’t forget that the Navajo Nation in the northern part of Arizona does follow DST, so be sure to keep that in mind, too).

So: does Brooklyn keep at her normal 11am meeting time, or does she move forward with Brooklyn and have to start meeting at noon? Nothing in her life changed. It’s weird for a meeting to suddenly span her lunch break when it didn’t before.

The answer is: there is no answer. We’re just making it up. And that’s the answer. Google has a writeup on their developer API docs for Calendar broadly talking about how recurring events interact with invited attendees. One aspect:

For recurring events a single timezone must always be specified.

This is really the only reasonable approach that can be taken here. They decided that the creator of the original event wins out, and the effects of that permeate out to attendees as well.

This is also detailed in RFC 5545:

* The “DTSTART” and the “TZOFFSETFROM” properties MUST be used when generating the onset DATE-TIME values (instances) from the “RRULE”.

(RFC 5545 is a great, titillating read, too. Thought I was reading a Harlequin romance novel with how vividly they describe all the RRULE specifications and permutations.)

So just make it up

So: bringing it back to the original topic at hand… I think this is a case where we get to just make the arbitrary decision. There’s no “right” or “wrong” answer.

I was curious how others broadly thought about the question, so I looked into it some more.

Ruby has a lovely treatise about Shakespeare while they discuss using Time versus DateTime which touch on some of these issues- it’s worth reading the whole section, but this part is most relevant here:

So when should you use DateTime in Ruby and when should you use Time? Almost certainly you’ll want to use Time since your app is probably dealing with current dates and times. However, if you need to deal with dates and times in a historical context you’ll want to use DateTime to avoid making the same mistakes as UNESCO. If you also have to deal with timezones then best of luck - just bear in mind that you’ll probably be dealing with local solar times, since it wasn’t until the 19th century that the introduction of the railways necessitated the need for Standard Time and eventually timezones.

.NET also kind of goes with a “oh god just try to avoid any of this type of thing” philosophy:

To determine the relationship of t1 to t2, the Compare method compares the Ticks property of t1 and t2 but ignores their Kind property. [Ed. note: Kind here is effectively timezone-related data.] Before comparing DateTime objects, ensure that the objects represent times in the same time zone.

Something called a “TIBCO ActiveMatrix BPM 4.2” punted on it entirely:

The method still works if the date/times are more than 14 hours apart, but if they are less than 14 hours apart, the result is deemed to be indeterminate.

Moment.js also has some caveats with comparisons:

As the second parameter determines the precision, and not just a single value to check, using day will check for year, month and day. [Ed. note: this basically means you have to choose which precision to decide- in the case of the original tweet, you’d pick either days or seconds.]

[ … ]

If the two moments have different timezones, the timezone of the first moment will be used for the comparison.

I don’t believe in the no-comparison date scenario

This whole post is basically a long-winded way of reiterating that humans create some very weird scenarios when it comes to dates and times. Raphael Schaad, founder of the fantastic Cron calendar, has a long-running thread on broken assumptions of calendaring that, frankly, don’t always have logical solutions. It’s all a bunch of trade-offs.

And that’s why I found the original tweet so interesting. We’ve all had situations where the data wasn’t consistent, or a third party munged data incorrectly for us, or where we’ve inherited data that was saved under incorrect assumptions (correct as they might have been at the time). The thought process can lead to a hundred-reply Slack thread. Or an entirely too-long and too-detailed Saturday morning post about dates and times.

So, with all that said… enjoy the rest of your Saturday!

Just kidding. I know some of you are on to Sunday already. And some of you will — gasp — read it years from now! Pretty sure no one read this a week ago, though. If you did, please remind me a few days ago that I will need to write this a few hours ago from now.

You can discuss this on Hacker News if you'd like.
14 Feb 06:25

This will one day kill my Apple Music subscription

by Volker Weber

I have switched from Spotify to Apple Music six years ago. I am happy with their service. But this attempt to upsell is driving me out.

I am the only user of Apple Music in my household. I only listen on one device. But do as much as picking up your headphones, it will start playing and kill the music on your other device trying to upsell to a family plan. Remove the dust from a HomePod. BOOM. Put your iPhone in your pocket. BOOM. Tell Siri to switch off the light. “Now playing …”. BOOM.

This. Happens. Every. Single. Fucking. Day.

14 Feb 06:16

Getting Back 2 Good

by hrbrmstr

If you’ve been following my inane tweets and non-technical blog posts for any length of time since 2015, you likely know the 2016 election cycle broke me more than just a tad, with each subsequent month of the Trump presidency adding a bit more breakage. My brain is constantly trying to make sense of the systems of the world, from the micro (small personal/home things) to the macro (global-scale things). There’s a Marvel character (no, this isn’t about “Cap”), Karnak, who’s chief ability is that he can see the flaws in all things, and it’s the closest analogy I can make to how deep down the rabbit hole my brain goes with this global-systems analysis. There’s always been a deep seated need to grasp the “why”, and “how” of any “what” (which, combined with being adept with silicon-laced glowing rectangles, explains the gravitation towards cybersecurity, though all my research scientist mates out there have that same Columbo-esque desire to get to the bottom of things).

I really thought I knew the histories and trajectories of a decent percentage of the “what”s in these world systems, believing that a slew of modern critial events, like Obama’s two-term presidency (to point to just one), were clear signs of the progress society had been making, despite the laundry list of overt divisions and inequities that remain. Even though we’ve lived in a rural Maine town for many years, I was blindsighted by the massive public support and normalization of hate, largely based on fear. For some reason, it was easy to dismiss partisan games in Congress as just the way things get done in a suboptimal system. It was too easy to compartmentalize the fact that supposedly decent folks, like my in-laws, hung on every word influencers like Rush Limbaugh and FOX News hosts spewed, thinking that it’s just a fringe element feeding off of such tainted information flows.

When signs of the then-impending pandemic first emerged, I naively thought it was going to be a catalyst for positive change. I thought even someone as narcissistic as Trump and his minions would see the need to unite folks under a banner of helping to ensure we protected as many people from the ravages of Covid as possible, and lead a coordinated, global effort to create and distribute treatments and vaccines as quickly as possible. I believed I knew how solid our CDC was, and saw so many talented scientists use their skills to model and explain various outcome paths, based on how we approached the handling of thie virus. I knew Bush helped orchestrate an initial modern pandemic playbook and that Obama built upon it, and that it was actually quite good.

Then I saw that we, collectively, just don’t care if scores of people are sickened and/or die. I heard so-called leaders say that the economy is more important than human life; heard entitled citizens that wearing a piece of cloth or paper over your mouth and nose was too much of a sacrifice to make; read countless stories from even so-called faith leaders that refraining from large indoor gatherings for a while, and periodically, to help ensure we don’t overwhelm our emergency medical systems and crush the healthcare workers in them was Nazi-like oppression. And, I saw the last leader of the free world (since we’ve now permanantly ceded that position to random agents of chaos) actively downplay and subvert the crisis, leading millions to follow his lead, which ultimately leads to the impending 1 million needlessly lost lives.

When those signals emerged in March of 2020, the break got a bit worse (picture one of those window or lake-ice cracks that spider out with each additional vibration), as it did with the drumbeat of terrible event of 2020 (of which there were many).

Like I suspect was the case with many readers (assuming there are many readers), I plain-up cried (the good kind) when Biden officially won the 2020 election. I foolishly thought, like so many others, that the sinking ship was at the start of being righted, and we’d be on a slow path towards sailing again.

Then, January 6th, 2021 happened. Since then, I’ve seen state, after state vie for the “Most Failed State” top spot. I’ve seen faith leaders and communities give their all to see who can be the worst possible verison of themselves. And, I’ve seen even the most stalwart among us declare the pandemic over because they’ve no stamina left to make any effort into caring for or about the least of us and those who provide medical care to our communities.

Talk about being broken.

We have this term in cybersecurity called “fuzzing”. It’s a technique where you send inputs into an application that it is not really designed to handle (e.g. imagine sending the entirety of Webster’s dictionary to a simple date field), and then doing this repeatedly to see if you can get the application to crash, change expected behavior, or end up in a state where you can compromise it. The events of 2015 through this very day feel like this has been/is one massive fuzz against the all the clear-thinking, decent members of society; and my human operating system just plain crashed.

In the spirit of “I can do this all day”, I may have been/be broken, but was/am not content to remain that way.

  • I’ve read more tomes than you would possibly believe if I were to list them out.
  • I’ve listened to so many podcasts that I was expecting Apple’s Health app to counsel me to, perhaps, shut off all audio devices for a month or two.

  • I’ve filled my RSS reader with feeds from exceptionally gifted humans who, too, have been trying to make sense of what has happened and where we are going.

  • (I’ve also prayed, walked, rode (bike), de-screened, socmed sabbaticaled, read more fiction than ever before, and intensified healthy cooking/eating to try to balance out all the bad inputs.)

I’ve done all this because I feel compelled to not only just understand (I actually need to understand), but also help fix this situation we’re in. Selfishly, a large part of that desire to leave a better world behind for my kids and our new grandson.

Of late, I’ve seen most of my input sources devolve into the same thing: chronicling the end of America as most modern folks know it. They’ve gone from working to make sense of why/how we got here and what can be done about it to doing the same thing we all pretty much did during 2016-2019: shaking our heads at every bad news item and noting how bat guano crazy the individual behind the bad news was. Not exactly hope-filling. In fact, I could sum up things up with two lines from Matchbox 20’s “Back 2 Good”


“And everyone here’s to blame
And everyone here gets caught up in the pleasure of the pain”

A recent entry into the aforementioned tomes was Jeremy W. Peters’ book “Insurgency: How Republicans Lost Their Party and Got Everything They Ever Wanted”. I’ve been a bit more choosy in what “Jan 6” analysis tomes I toss coin at, and was dismayed yet-another reporter was releasing a book, but I listened to the little voice, and dropped an Audible credit on it and I has been a literal Godsend.

A big reason for remaining broken is that there were many missing (key) system components. You can’t identify the failure modes without seeing the complete system, and Jeremy managed to fill in (most of) those gaps. He did an amazing job going back far enough, and walking through the event trees paintakingly enough that I could actually feel the puzzle pieces fitting into place. Where there were once clouds, there is now clear sky. Items with chasms between them now have bridges.

Having the systems functionally and nearly fully documented has been immensely theraputic. It’s astonishing to realize just how many personal mental processing cores had been dedicated to this problem. It’s also all kinds of amazing to have to have some of the cognitive processor faculties back to do things like code for fun, again.

Since this is not a book review (nor a book itself), I won’t go into each and every component that was made clear. That’s not really the point of this post.

I guess the first point is that if 2015-2022 also broke you in some way, realize you’re not alone. I don’t think anyone was fully (or even partially) prepared for what we all ended up enduring and continue to endure. Hopefully knowing you’re normal, and that there we broken folk are legion will help quell at least that part of being broken.

The second point is that there was a rhyme and reason to how we got to where we are now. It is, perhaps, more of a crass limerick than poetic rhyme, and the reasons aren’t great, but events weren’t random and they did not emerge from nowhere.

The third and last point is that knowing there are “why”s and “how”s to the “what”s means it is possible to work on forging compensating controls (i.e. there can be concrete actions we can take to make things better and setup hedges to prevent us from heading down similar chaotic paths). We’re still not on a great collective path forward, and there’s no magic wand we can wave to make things better. But, we all can make individual and incremental progress in our own ways. For some, like me, it may mean breaking out of some comfort zones to do things you would not normally do. For others, it may be applying aligned talents to triaged areasm, doing what you can to make even the smallest thing a tiny bit better. We’re not going to A-bomb our way out of this conflcit. It’s going to take a long period of incremental, positive change.

If you’re still working on figuring out what went awry, I highly recommend Jeremy’s book. You can also reach out if you need some personal reassurance that all is not, in fact, lost. Unlike the hopeless ending of the aforenoted Matchbox 20 song, I do, in fact, believe there is a way of “getting back to good” and, for me, that journey starts now.

I close with a heartfelt thank you for the patience and kindness many folks have shown and expressed over this period. You’ve done more than you can possibly know.

14 Feb 06:15

TK Maxx

by peter@rukavina.net (Peter Rukavina)

James A. Reeves’ luggage went missing at Heathrow:

Our luggage went missing somewhere in the depths of Heathrow, so I bought a cheap change of clothes at a discount chain called TK Maxx, which has the same logo and chaotic atmosphere as TJ Maxx in the States. Only one letter was different. This minor tweak captures the uncanny sensation of being on the other side of an ocean, yet everything feels more or less the same now that we’re living in the shadow of an end-game corporate colossus.

From Wikipedia:

TK Maxx is a subsidiary of the American apparel and home goods company TJX Companies based in Framingham, Massachusetts. … The chain uses a slightly different name from that of the TJ Maxx stores in the United States, to avoid confusion with the British retailer T. J. Hughes.

14 Feb 06:15

Week Notes 22-06

by Ton Zijlstra

This week felt sluggish. There was nothing wrong as such, but it didn’t feel like I was getting in a good rhythm. In the weekend I didn’t feel very well physically. This week I:

  • Had our monthly half day work session with my business partners, and our monthly stand-up about our company fiancials with the entire team.
  • Had a thorough discussion about where a client wants and needs to focus when it comes to data sharing. The to be newly created legal instruments also allow us to ask different strategic questions about the use and value of datasharing and shared data.
  • Did some bookkeeping for the company.
  • Had the weekly client meetings
  • Read the proposed EU Digital Rights and Principles and did a first round of highlights and annotations. It’s a so called ‘communication’ so some of the critique I saw w.r.t. it lacking actions or commitments I see as a misinterpretation of the role of this document. Aspects already have become part of proposed laws that do have teeth, such as most clearly visible in the proposed AI Regulation.
  • Was pointed to DeepL as a dekstop app. This will be useful to blog in German more frequently.
  • Finished my Microsub reader with integrated micropub functionalities. In the past few days I used my self-built feed reader, and responded to things by posting direclty to my blog from inside my feed reader.
  • Released a wiki about the EU data laws on a client URL (until now it was living on a github.io URL). This thing is automatically generated from my markdown notes on my device (The notes get pushed to Github, where a Respec script grabs them and publishes them as web pages)
  • Learned to solve a Rubik’s cube
  • Enjoyed that Y enjoyed her weekly swimming lesson a lot again.
  • Enjoyed walking with Y while she rediscovered roller skating again.
  • Had a board meeting of the Open Nederland (Creative Commons) association, where we mostly aimed to pick up our activities again. Our work had lost pace in the past year, due to the pandemic.
  • Had an interesting first conversation with someone who recently started as a self employed consultant w.r.t. ‘applied’ ethics.


This is a RSS only posting for regular readers. Not secret, just unlisted. Comments / webmention / pingback all ok.
Read more about RSS Club
14 Feb 05:53

A Morning with Billy Collins

by Eugene Wallingford

It's been a while since I read a non-technical article and made as many notes as I did this morning on this Paris Review interview with Billy Collins. Collins was poet laureate of the U.S. in the early 2000s. I recall reading his collection, Sailing Alone Around the Room, at PLoP in 2002 or 2003. Walking the grounds at Allerton with a poem in your mind changes one's eyes and hears. Had I been blogging by then, I probably would have commented on the experience, and maybe one or two of the poems, in a post.

As I read this interview, I encountered a dozen or so passages that made me think about things I do, things I've thought, and even things I've never thought. Here are a few.

I'd like to get something straightened out at the beginning: I write with a Uni-Ball Onyx Micropoint on nine-by-seven bound notebooks made by a Canadian company called Blueline. After I do a few drafts, I type up the poem on a Macintosh G3 and then send it out the door.

Uni-Ball Micropoint pens are my preferred writing implement as well, though I don't write enough on paper any more to make buying a particular pen much worth the effort. Unfortunately, just yesterday my last Uni-Ball Micro wrote its last line. Will I order more? It's a race between preference and sloth.

I type up most of the things I write these days on a 2015-era MacBook Pro, often connected to a Magic Keyboard. With the advent of the M1 MacBook Pros, I'm tempted to buy a new laptop, but this one serves me so well... I am nothing if not loyal.

The pen is an instrument of discovery rather than just a recording implement. If you write a letter of resignation or something with an agenda, you're simply using a pen to record what you have thought out. In a poem, the pen is more like a flashlight, a Geiger counter, or one of those metal detectors that people walk around beaches with. You're trying to discover something that you don't know exists, maybe something of value.

Programming may be like writing in many ways, but the search for something to say isn't usually one of them. Most of us sit down to write a program to do something, not to discover some unexpected outcome. However, while I may know what my program will do when I get done, I don't always know what that program will look like, or how it will accomplish its task. This state of uncertainty probably accounts for my preference in programming languages over the years. Smalltalk, Ruby, and Racket have always felt more like flashlights or Geiger counters than tape recorders. They help me find the program I need more readily than Java or C or Python.

I love William Matthews's idea--he says that revision is not cleaning up after the party; revision is the party!

Refactoring is not cleaning up after the party; refactoring is the party! Yes.

... nothing precedes a poem but silence, and nothing follows a poem but silence. A poem is an interruption of silence, whereas prose is a continuation of noise.

I don't know why this passage grabbed me. Perhaps it's just the imagery of the phrases "interruption of silence" and "continuation of noise". I won't be surprised if my subconscious connects this to programming somehow, but I ought to be suspicious of the imposition. Our brains love to make connections.

She's this girl in high school who broke my heart, and I'm hoping that she'll read my poems one day and feel bad about what she did.

This is the sort of sentence I'm a sucker for, but it has no real connection to my life. Though high school was a weird and wonderful time for me, as it was for so many, I don't think anything I've ever done since has been motivated in this way. Collins actually goes on to say the same thing about his own work. Readers are people with no vested interest. We have to engage them.

Another example of that is my interest in bridge columns. I don't play bridge. I have no idea how to play bridge, but I always read Alan Truscott's bridge column in the Times. I advise students to do the same unless, of course, they play bridge. You find language like, South won with dummy's ace, cashed the club ace and ruffed a diamond. There's always drama to it: Her thirteen imps failed by a trick. There's obviously lots at stake, but I have no idea what he's talking about. It's pure language. It's a jargon I'm exterior to, and I love reading it because I don't know what the context is, and I'm just enjoying the language and the drama, almost like when you hear two people arguing through a wall, and the wall is thick enough so you can't make out what they're saying, though you can follow the tone.

I feel seen. Back when we took the local daily paper, I always read the bridge column by Charles Goren, which ran on the page with the crossword, crypto cipher, and other puzzles. I've never played bridge; most of what I know about the game comes from reading Matthew Ginsberg's papers about building AI programs to bid and play. Like Collins, I think I was merely enjoying sound of the language, a jargon that sounds serious and silly at the same time.

Yeats summarizes this whole thing in "Adam's Curse" when he writes: "A line will take us hours maybe, / Yet if it does not seem a moment's thought / Our stitching and unstitching has been naught."

I'm not a poet, and my unit of writing is rarely the line, but I know a feeling something like this in writing lecture notes for my students. Most of the worst writing consists of paragraphs and sections I have not spent enough time on. Most of the best sounds natural, a clean distillation of deep understanding. But those paragraphs and sections are the result of years of evolution. That's the time scale on which some of my courses grow, because no course ever gets my full attention in any semester.

When I finish a set of notes, I usually feel like the stitching and unstitching have not yet reached their desired end. Some of the text "seems a moment's thought", but much is still uneven or awkward. Whatever the state of the notes, though, I have move on to the next task: grading a homework assignment, preparing the next class session, or -- worst of all -- performing the administrivia that props up the modern university. More evolution awaits.

~~~~

This was a good read for a Sunday morning on the exercise bike, well recommended. The line on revision alone was worth the time; I expect it will be a stock tool in my arsenal for years to come.

14 Feb 04:52

Enabling a user to execute a specific command as root without a password

by Simon Willison

I wanted a script running as a non-root user to be able to restart a systemd service on my Ubuntu machine without needing a password.

I figured out how to do that by adding the following line to the sudoers file, which can be edited as root using the visudo command:

# dogsheep user can restart datasette service
dogsheep  ALL = (root) NOPASSWD: /usr/bin/systemctl restart datasette

Having added this line, my dogsheep user account could now run the following:

$ sudo /usr/bin/systemctl restart datasette

But if it tries to run the command with any other arguments it gets prompted for a password:

$ sudo /usr/bin/systemctl restart datasette2
[sudo] password for dogsheep: 
14 Feb 04:49

Building a Relationship Economy

by Doc Searls

In faith that nothing lasts forever, and that an institution that’s been around since 1636 is more likely to keep something published online for longer than one that was born in 1994 and isn’t quite dead yet (and with full appreciation to the latter for its continued existence), I’ve decided to re-publish some of my Linux Journal columns that I hope have persistent relevance. This one is from the February 2007 issue of the magazine.


Building a Relationship Economy

Is there something new that open source development methods and values can bring to the economy? How about something old?

I think the answer may come from the developing world, where pre-industrial methods and values persist and offer some helpful models and lessons for a networked world that’s less post-industrial than industrial in a new and less impersonal way.

This began to become apparent to me a few years ago I had a Socratic exchange with a Nigerian pastor named Sayo, whom I was lucky to find sitting next to me on a long airplane trip.

We were both on speaking junkets. He was coming from an event related to his latest work: translating the Bible to Yoruba, one of the eight languages he spoke. I was on my way to give a talk about The Cluetrain Manifesto, a book I co-authored.

My main contribution to Cluetrain was a chapter called “Markets are conversations”. Sayo asked me what we meant by that. After hearing my answer, he acknowledged that our observations were astute, but also incomplete. Something more was going on in markets than just transactions and conversations, he said. What was it?

I said I didn’t know. Here is the dialogue that followed, as close to verbatim as I can recall it…

“Pretend this is a garment”, Sayo said, picking up one of those blue airplane pillows. “Let’s say you see it for sale in a public market in my country, and you are interested in buying it. What is your first question to the seller?”

“What does it cost?” I said.

“Yes”, he answered. “You would ask that. Let’s say he says, ‘Fifty dollars’. What happens next?”

“If I want the garment, I bargain with him until we reach an agreeable price.”

“Good. Now let’s say you know something about textiles. And the two of you get into a long conversation where both of you learn much from each other. You learn about the origin of the garment, the yarn used, the dyes, the name of the artist, and so on. He learns about how fabric is made in your country, how distribution works, and so on. In the course of this you get to know each other. What happens to the price?”

“Maybe I want to pay him more and he wants to charge me less”.

“Yes. And why is that?”

“I’m not sure.”

“You now have a relationship”.

He went on to point out that, in his country, and in much of what we call the developing world, relationship is of paramount importance in public markets. Transaction still matters, of course. So does conversation. But the biggest wedge in the social pie of the public marketplace is relationship. Prices less set than found, and the context for finding prices is both conversation and relationship. In many cases, relationship is the primary concern, not price. The bottom line is not everything.

Transaction rules the Industrialized world. Here prices are set by those who control the manufacturing, distribution and retail systems. Customers do have an influence on prices, but only in the form of aggregate demand. The rates at which they buy or don’t buy something determines what price the “market” will bear — in a system where “market” means aggregated demand, manifested in prices paid and quantities sold. Here the whole economic system is viewed mostly through the prism of price, which is seen as the outcome of tug between supply and demand.

Price still matters in the developing world, Sayo said, but relationship matters more. It’s a higher context with a higher set of values, many of which are trivialized or made invisible when viewed through the prism of price. Relationship is not reducible to price, even though it may influence price. Families and friends don’t put prices on their relationships. (At least not consciously, and only at the risk of cheapening or losing a relationship.) Love, the most giving force in any relationship, is not about exchanging. It is not fungible. You don’t expect a payback or a rate of return on the love you give your child, your wife or husband, your friends.

Even in the industrialized world, relationship has an enormous bearing on the way markets work, Sayo said. But it is poorly understood in the developed world, where so much “comes down to the bottom line”.

I shared this conversation a few weeks later with Eric S. Raymond, who put the matter even more simply. “All markets work at three levels”, he said. “Transactions, conversations and relationships”. Eric is an atheist. Sayo is a Christian. With those two triangulating so similarly on the same subject, I began to figure there was something more to this relationship business.

I began to ask questions. For example, What happens when you view markets through the prism of relationship? Why do we write free or open source code?

Linus says (in the title of his only book) he does it “Just for Fun”. Yes, there are practical purposes — there have to be. Scratching itches, for example. Development communities are notoriously long on conversation (check out the LKML for starters), and on relationship as well. Not a whole lot of transaction there, either, since the code is free. Next question: Are there economies involved?

I think the answer is yes, and they are concentrated on the manufacturing end. We make useful code for its “because effects”. Thanks to Linux, much money will be made; but because of it, far more than with it. Just look at Google and Amazon as two obvious examples. Perhaps a billion of the world’s Websites are Apache on Linux.

Relationship is involved here, too. Writing code that serves as abundant and free building material is an act of generosity. Dare we say we do it for love? Certainly a lot of us love doing it.

Likewise with performing artists. Musicians don’t take up an instrument and develop their skills just to make money at it. They do it for love of the experience, of playing together with other musicians, of giving something to an audience, and to the world.

Of course, professionals like to get paid for their work too. That’s what makes them professionals.

What if the goods are essentially free (as in beer, air or love)? That’s the case with code, music, art, and anything else that can be digitized and copied. Many artists want or need to be paid for what they do. The question is how we get our love to fund theirs — how we can relate in ways that work financially for both the supply and the demand of essentially free stuff.

The entertainment industry has had an answer ever since the Net showed up. Hollywood wasn’t blind to the Net. Quite the opposite. They correctly saw the Net as a way for every device to be zero distance from every other device — and to pass identical copies of anything between anybody a cost that rounded to zero. They saw this a threat to their incumbent business model. So they came up with a way to deal with that threat: DRM, or Digital Rights Management. DRM worked by crippling recorded goods so it can’t easily be copied except by those whose rights were managed by suppliers.

It hasn’t worked. A few days ago Steve Jobs said so himself, in a landmark essay titled Thoughs on Music, published on February 6. It not only notes the failure of DRM, but subtly recruits customers and fellow technologists to help Apple convince the record industry that it’s best to sell music that isn’t DRM’d. He concludes, “Convincing them to license their music to Apple and others DRM-free will create a truly interoperable music marketplace. Apple will embrace this wholeheartedly”.

The operative verb here is “license”.

Let’s ignore the record companies for a minute. Instead, lets look behind them, back up the supply chain, to the first sources of music: the artists. Part of the system we need is already built for these sources, through Creative Commons. By this system, creative sources can choose licenses that specify the freedoms carried by their work, and also specify what can and cannot be done with that work. These licenses are readable by machines as well as by lawyers. That’s a great start on the supply side.

Now let’s look at the same work from the demand side. What can we do — as music lovers, or as customers — to find, use, and even pay for, licensed work? Some mechanisms are there, but nothing yet that is entirely in our control — that reciprocates and engages on the demand side what Creative Commons provides on the supply side.

Yes, we can go to websites, subscribe to music services, use iTunes or other supply-controlled intermediating systems and deal with artists inside those systems. But there still isn’t anything that allows us to deal directly, on our own terms, with artists and their intermediaries. Put another way, we don’t yet have the personal means for establishing relationships with artists.

For example, I relate in some ways to Stewart Copeland, though he doesn’t know it. Stewart is best known as the drummer in The Police, even though the band hasn’t recorded an album since 1983 and Stewart has since then established himself as a first-rank composer of soundtracks, including “Rumble Fish”, “Talk Radio” and “Wall Street”. IMDb lists him as a composer of scores for sixty-nine movies and TV productions. You have to hit “page down” six times or more to get to the bottom of the listings. Still, much as I appreciate Stewart’s compositions, I’ve always loved his drumming. I’m not a drummer, but I’m a serviceable percussionist. (When I pick up bongos, congas, a rub-board or a tambourine, I get approving nods from the real musicians I jam with — as rarely as the occasion arises.) When the Police ceased touring and producing albums, I missed Stewart’s drumming most of all.

Last year I got a big charge out of hearing an IT Conversations podcast interview with Stewart, though I was disappointed to hear he doesn’t drum much anymore.

Then I heard last week on the radio that the Police may be getting back together and touring again. I can relate to that. But how? Stewart’s website is one of those over-produced flash-filled things that recording an performing artists seem to think they need in order to “deliver an experience” or whatever. Nearly every internal link leads to a link-proof something-or-other in the same window, among other annoyances. To call it relationship-proof would be an inderstatement.

So instead let’s look at relating through the IT Conversations podcast. I say that because yesterday Phil Windley, who runs IT Conversations, posted Funding Public Radio (and ITC) with VRM on his blog, and listed some of the things he might be looking for from VRM or Vendor Relationship Management. That is, from something that lives on the demand side, but can relate on mutually useful terms with the sjupply side — which in his case is IT Conversations.

Here’s the first answer: It can’t be limited to a browser. I want a button, or a something, on my MP3 player that allows me to relate not only to IT Conversations as an intermediary, but to the artist as well — if the artist is interested. They may not be. But I want that function supported. What we need on the user’s side is a tool, or a set of tools, that support both independence and engagement.

If what we’re looking for doesn’t exist, how hard will it be to build? I’m sure it won’t be easy, but it will be less hard than it was before the roster of open source tools and applications grew to six figures, which is where it stands now. And that’s not counting all the useful standards that are laying around too.

What do we need?

First, I think we need protocols. These should be modeled on the social ones we find in free and open marketplaces. They should work like the ones Sayo talked about in his Socratic dialogue with me on the airplane. They should be simple, useful and secure.

Second, we need ways of supporting transactions. This is a tough one, because to work they need to be low-friction. I should be able to pay IT Conversations (or any public radio station, or any podcaster) as easily as I pay for a coffee. Or better yet, as easily as I tip a barista. So PayPal won’t cut it. (Not the way I’ve experienced PayPal, anyway.)

Third, we need ways of selectively and securely asserting our identities, including our choice to remain anonymous. This means getting past sign-on hurdles on the Web, and past membership silos out in the physical world (such as the ones that require a special card, or whatever). Again, the friction should be as low as possible.

Fourth, we need ways of expressing demand that will bring supply to us. Let’s say I want to hear other interviews with Stewart Copeland. I don’t want to go through the standard Google/Yahoo text search. I want to tell the marketplace (in some cases without revealing yet exactly who I am) that I’m looking for these interviews, and then have them find me. Then I want an easy way to pay for them if I feel like it. As Sayo suggests, I might be more willing to pay something if I can relate to the source, and not just invisibly use goods produced by that source.

In Putting the Wholes Together, which I posted recently at Linux Journal, I said public broadcasting would be a good place to start — not just because public broadcasting needs to find ways to make more money from more listeners and viewers, but because payment is voluntary. Seems to me that when payment is voluntary, relationship will drive up the percentage of those who pay. It’s just a theory, but one that should be fun to test.

Soon as I get the time to put it together, I’ll put out a challenge for developers (that’s you, if you write code) to help out on this. Some developers are already collected at ProjectVRM, which is where we’re organizing the effort.

I’m meeting with NPR in Washington, D.C. in a couple hours, and again tomorrow. I’ll bring up the possibility of help from you guys when I talk to them. And I’ll be in many meetings and talks next week at the IMA Convention in Boston and Beyond Broadcast in Cambridge. Help is welcome.

Let’s show these folks how much more they can do because they relate. Let’s obsolete those annoying fund-raising marathons when they shut off programming, plead poverty and give you some schwag if you send money. There has to be a better way. Let’s build it.

14 Feb 04:48

2022 Crocuses

It is an annual tradition on this blog to celebrate the early-spring arrival, in our front yard, of the first crocuses. Winters suck everywhere in Canada and while Vancouver’s don’t freeze your ass they do subtract light from life for way too many months. Thus, giving the little purple fellas a hearty greeting is therapeutic. With notes on photography and dead leaves.

Our front yard is half-ish garden patches, the rest mossy/grassy green. Normally we shovel autumn’s leaves off the whole thing but last fall I only cleared the green space. I was a little worried that the leaves might get the in crocuses’ way — they’re such delicate little things — but as you can see, they cheerfully muscled their way through to the sun.

Crocuses pushing through leaf cover

We can all use the help; it’s been a shitty winter, what with the endless Covid grind, nasty notices of incoming climate change, and mental-health issues. Also, several people I’ve known a really long time, and been close to in various ways, are starting to exhibit dementia. (One’s younger than me, shudder) (One is treatable, yay!) Days are still grey, dark, and short.

But: The flowers are up! And I got to be on the anti-anti-vaxxer bike squad!

So, back to the purple. Here’s a picture that I want to talk about; take a moment and check it out.

Early-spring crocuses with shadows

I find that, among the pictures I take, there’s a huge gulf between what I like best and what other people think. I like this one really a lot, and whether you agree or not it’s an excuse for a little bit of camera geekery.

“Special”?

So, as you may have heard me say: All the cameras these days are great. Any old mobile phone or entry-level DSLR or mirrorless can routinely take pictures that were technically impossible a decade ago. So, what makes a picture special? Obviously, finding something special to photograph is the most important thing. Once you get past that, lenses are big difference-makers, and post-processing (for me anyhow) is crucial. Notice that I didn’t mention the choice of camera?

Anyhow, this was shot on a Fujifilm mirrorless using the 35mm F1.4 lens, which is now nine years old and remains by a wide margin my favorite lens ever. Yeah, it can take very sharp pictures but that’s not it, there’s just something in there that makes things look better. I’m not the only person who feels this way; lots of photogs are very emotionally attached. More evidence: In the decade since this was introduced, Fuji has shipped a 33mm F1.4 and a 35mm F2, but they’re still making and selling it. On top of which, it’s super-light and compact, which is great when you’re hunched over on soggy moss trying to get the right angle on little wee purple flowers.

I spent a lot of time in Lightroom fooling with that picture just above. I think I’m not alone in really enjoying this process; I stay up after everyone’s gone to bed with the lights low and maybe an adult beverage, and obsess enjoyably over fine tonal gradations and color intensity and so on.

I gripe about this or that Lightroom foible but it’s really become an old friend. Lots of times I find my hand going to one of the sliders without the conscious part of my mind having been noticeably involved and whaddaya know, the adjustment works. It occurs to me that maybe, the next time I shoot a bunch I should do a Twitch stream…

Cluster of spring crocuses in Vancouver

These guys had the poor taste to situate themselves right by a plastic rod which supports the raspberry climber, but I couldn’t resist their eagerness and the adorable sharpness of the shadows cast by their sex organs.

But which camera?!

Oh, right, this is the Fujifilm X-T30 I bought in Hong Kong in 2019 to take lots of early-spring pictures of China. It’s great. (All cameras are great.) But three years in, I’m falling out of love. It’s not that Fuji cameras take better pictures or have better autofocus or viewfinders or shake reduction; it’s just I’m totally in harmony with their ideas about what kind of controls a camera should have on the outside and how they should work. Also, they have a pretty great lens lineup.

Except for, the X-T30 is too small for my big fat farmer’s hands. I deliberately bought it small to carry around the Great Wall, and that was great, and I’ve come to a compromise with it, but my fingers fail to fall on the right place too often and I often find I’ve woken up the touch-screen and mis-adjusted something.

It doesn’t help that, what with Covid-19, we never really go anywhere and thus I take the camera off the shelf far less often.

They say Fuji’s announcing new stuff in May and I’ll take a close look.

But that’s not what matters

What matters is that the crocuses came up. And that we had a nice bright day. And that my mind and body still work well enough to get me out in the chilly moist air stalking the purple and gold. And that I can still care about it, and be pleased by it. Is that a low bar? In 2022, I’ll take it.

Happy almost-Spring, everyone.

14 Feb 04:02

Frequency trails in the snow

by Nathan Yau

This is a good tweet.

Tags: humor, snow

14 Feb 03:59

Samsung Galaxy S22 Ultra vs iPhone 13 Pro Max Comparison: Which One Should You Buy?

by Chandraveer Mathur
On February 9, Samsung unveiled the Galaxy S22 lineup to rival Apple’s iPhone 13 series. Here’s a detailed comparison between Samsung’s latest Galaxy S22 Ultra and Apple’s efficient champion, the iPhone 13 Pro Max, so you can pick the phone that suits you best. Continue reading →
14 Feb 03:59

OKRs as institutional memory

by Rick Klau

(Each week, I write a post about OKRs. You can see the series of posts here; if you have a question about OKRs you’d like to see me cover down the road, drop me a line.)

We’ve been implementing OKRs over the last couple quarters on my team. Early in our roll-out, I reiterated a point I made in my OKR video almost a decade ago: the grades don’t really matter. (Robin Kwong helpfully pulled out a few quotes from the video, including my comments about grades specifically:

I always felt, and continue to feel, grades don’t matter except as directional indicators of how you’re doing. If you’re spending more than a few minutes at the end of a quarter summarizing your grades, you’re doing something wrong. The work should go into doing – and delivering on – the OKRs, not grading them.

In a recent 1:1, one of the leaders on my team told me that they’d be editing their current OKRs, as the team had learned several things that they didn’t previously know. Since the grades didn’t matter anyway, his logic went, they’d modify their goals on the fly to hold themselves accountable to a modified goal.

His logic was sound. So why did I resist this mid-quarter adjustment? Because over time, OKRs can be the organization’s institutional memory. In the absence of OKRs, an organization’s mistakes made and lessons learned are locked in people’s heads. New team members struggle to get up to speed with what the veterans already know; “this is the way we do things” can feel mercurial and opaque. With OKRs, the lessons from past quarters jump off the page: that team tried to do X, didn’t succeed, they iterated in future quarters based on what they learned, and achieved Y.

I talked about this in an interview with Ally.io’s Marilyn Napier in 2020 shortly after I left Google Ventures:

When asked what the most valuable part of OKRs, I said this:

Let’s not distract ourselves just because someone had a good idea on a Tuesday standup meeting; let’s finish the stuff we said we were going to do. We might not succeed at all of it. In fact, we probably won’t, but we’ll have learned more and more. You can encode that. That becomes part of the institutional memory at the organization. (link and emphasis mine)

If that leader on my team edited his team’s OKRs on the fly, the value of those OKRs to future team members years from now would be nearly non-existent. Sure, we would have the impact from that revised OKR, and the compounding effects over future quarters that built on that outcome. But we’d lose the institutional knowledge that the team had started out trying to achieve X, and eventually learned that their attempt at achieving X had failed. The next time some future team member proposes to try to achieve X, would anyone remember that they’d tried that before? Or will they all be new apes?

There’s a fine line here: if it looks likely that the outcome of a team’s objectives will be a zero, there’s no real point in continuing to tilt at that particular windmill. Take the loss and move on; redeploy those resources in service of one of the remaining goals, or get a head-start on something that might otherwise be a next quarter goal. But leave the current quarter’s goals written down, so that in the future someone has a better-than-even shot at knowing that we’ve already got some data that given similar circumstances, we know how that will turn out.

In other words: once we’ve learned a lesson, let’s make sure we remember it. Think about that future new team member: when she dives in, she can spend hours browsing the team’s past OKRs, quickly absorbing past successes and failures. She’ll see how the organization thinks, how they hold themselves accountable, how they strive. She will know what the organization knows. She’ll remember, even though she wasn’t there.