I mentioned on Twitter recently my intention to do better 1:1 meetings with my direct reports and stakeholders in 2021 and promised to share how I was approaching it.

This is not the first time I’ve made this resolution and it often tails off into adhoc-ery all too quickly but I’m hoping that being intentional about why I am doing this will help it stick more.

To that end there are a few things that I’m changing in how I do my 1:1s this year, including:

1. Diarising time each week on Monday to prepare for my 1:1s. Here I need to admit that usually I’ve been collecting topics on post it notes throughout the week and then winging it through the 1:1 meeting, basically triaging on the fly the most important topics that I or my team member are bringing in that day. This means that we tend to deal with urgent things but not always important things.
2. Creating a template for each of us to complete in preparation for the meeting, and to help ensure that we regularly touch on important topics that might otherwise be overlooked by urgent things. More on this below.
3. Taking proper notes and actions in the meeting, and making sure the actions get acted on. Basic stuff really, the former wasn’t really happening and the latter could be a little hit and miss. Using the template as a way to build accountability for the actions.

With that in mind, here is my current iteration of the template I’m planning to use. I’ve used it only twice so far and already iterated it a little (hence the v2 in the heading) and I expect I will continue to iterate it more and more over time. So far its been pretty positively received, but it is still far, far from perfect. Feedback welcome.

The idea is that each week in preparation for the 1:1 my direct reports, who are mostly Research Managers, fill out this template and take the time to reflect on each of these items. I also have a section I need to fill in. We both contribute topics in addition to the standard items.

Template for my 1:1 Meetings

Date of the 1:1 Meeting

(My actual template is in Confluence and look lots better as it has lots of colourful emojis all over it. Annoyingly WordPress won’t play nicely for me with emojis here so I’ve prioritised making this accessible over giving a screenshot of the pretty one instead)

During the meeting I will then capture a tonne of notes as the meeting progresses (my background as a qual researcher has prepared me well for this!). These notes are shared on a Confluence page so that both of us can add more, annotate etc.

As soon as the 1:1 meeting is completed, I update the template with next weeks items, and the agreed actions captured.

I am a little bit concerned that the extensive ‘structured’ section might not leave enough time to focus on the more ‘urgent’ topics – especially given these currently tend to take up the entire time allowed right now. But, that is also somewhat deliberate, so perhaps that’s not a bad thing.

The 4Ls – an alternative approach I might use on a monthly basis.

When I was talking about this approach with my colleague Dom Price, he shared another 1:1 format that he likes to use. I’m not sure it would work quite so well for me on a weekly basis but I might experiment with using this every 4-6 weeks as I think it does provide a really different perspective on how people are doing in their work and how you might be able to help them be more successful.

Dom’s approach asks people to reflect on these four categories:

• Loved – what I loved doing this month
• Longed for – what I longed to be doing but was unable to find the time/etc
• Loathed – what I really did not enjoy doing this month
• Learned – what I learned this month

The idea is to try to support the person you are managing to increase the loved and learned, enable the longed for and remove the loathed.

I’m sure there are many more great frameworks from people who have given this a good deal more thought than I have. I’d love to hear what’s worked well for you and what you’d recommend.

It’s common when trying to build support for a community to pretend nothing bad will happen.

But this is going to hurt you and your community when it does. Worse yet, if you’ve pretended nothing bad will happen you probably don’t have an agreed plan to deal with the risks.

Instead of trying to pretend it won’t happen, it’s better to pretend it will.

But you need to explain three things here:

1) You’ve identified the risks. You have worked with various teams (marketing, PR, IT, legal, product to identify the most likely risks (legal, reputation, risk to members, risk to staff etc…). Invite stakeholders to add their concerns to the list.

2) You have a plan to respond and mitigate each of them. You’ve taken proactive steps to reduce the likelihood of something bad happening and have a plan to respond when it does. Invite anyone with concerns to help develop your plans here too.

3) The incredible benefits of a community far outweigh these risks. Much of the business world is shifting towards community. Control is in decline. You can figure out how to do community now or later, but at some point it will happen. The benefits of a community are too important to not pursue because of concerns about risks.

The more active your community becomes the bigger the risk that something bad will happen. On a long-enough time scale, it’s almost inevitable.

If you want to mitigate the concerns of colleagues, engage them in the journey of identifying and mitigating the risks (and identifying the benefits they need from the community).

brumm.af/shadows

I did not know this trick: by defining multiple box-shadow values as a comma separated list you can create much more finely tuned shadow effects. This tool by Philipp Brumm provides a very smart UI for designing shadows.

Via @joshwcomeau

One of the big influences for me when I started personal blogging, as opposed to blogging about education, was Zen Habits. It doesn’t look like it, but it’s one of the most viewed blogs on the web, with more than two million readers.

It’s written by Leo Babauta, who was recently interviewed on The Tim Ferriss Show. The podcast episode a great listen for a number of reasons, but I want to focus in on one thing that’s touched on briefly.

Babauta explains that he has six children, with four from his and his partner’s previous marriages, and the two they’ve had together. Some have gone to school, and some have been unschooled:

Unschooling is an informal learning that advocates learner-chosen activities as a primary means for learning. Unschoolers learn through their natural life experiences including play, household responsibilities, personal interests and curiosity, internships and work experience, travel, books, elective classes, family, mentors, and social interaction. Often considered a lesson- and curriculum-free implementation of homeschooling, unschooling encourages exploration of activities initiated by the children themselves, believing that the more personal learning is, the more meaningful, well-understood and therefore useful it is to the child. While courses may occasionally be taken, unschooling questions the usefulness of standard curricula, conventional grading methods in standardized tests, forced contact with children in their own age group, the compulsion to do homework, regardless of whether it helps you in your individual situation, the effectiveness of listening to and obeying the orders of one authority figure for several hours each day, and other features of traditional schooling in the education of each unique child.

Wikipedia

The point he makes is a simple one: if children are always brought up to be told what to do next, to be given a path, then how will they find a path of their own as adults?

He doesn’t make the connection explicitly, but my next thought was that this is perhaps why the default option for most people after school / college / university is to get a job in a hierarchical organisation with a boss telling you what to do.

The radical thing to do, and the thing which is much more empowering, is to reject persistent hierarchy and coercive power relations altogether. Instead, approaches such as consent-based decision making are the way forward. No-one needs someone telling them what to do all of the time — including children.

This post is Day 83 of my #100DaysToOffload challenge. Want to get involved? Find out more at 100daystooffload.com.

Your personal site is your playground. Overhearing some recent chatter about putting the personality back in personal websites, I thought it might be helpful to share how I’ve been approaching art direction on my blog. I have a bit of experience here, in fact years ago during the heyday of “blogazines”, I forked and maintained an art direction plug-in for WordPress. It adds a text field for either global and page level styles and scripts enqueues those in the appropriate places. It wasn’t pretty but did the job and is in use on big sites like CSS-Tricks.

Switching to static sites some years ago, I still wanted that ability to add some flavor to posts when I feel inspired. I wanted to replicate that CodePen-like feeling in my blog post authoring. I think I came across something even easier than a WordPress plugin. To achieve a “minimum art-directable” effect, I’ve settled on three-ish features that get me most of the way there and allow me to add some spice to my bland, beige-colored blog.

1. Set a CSS Custom Properties baseline

If you’re going to do art direction in 2021 or beyond I think the biggest bang for your buck is: Use CSS Custom Properties. I wrote about variable layers for wiring up a dark theme, but having a handful of CSS variables as an underlying framework allows you to override and tweak your theme anytime you see fit. You can see this in action on a post I wrote about the economics of Twitch, to convert it to Twitch-brand purple, I just needed a few lines of CSS:

:root.theme-dark {
  --bg: #19171c;
  --link: #b19dd8;
  --link-active: #6441a4;
  --heading: #fff;
 }

I also have a body_class field in my post metadata that allows me to hardcode a dark theme, but I have only used it a handful of times. The resulting effect looks something like this, some simple theming applied to an otherwise normal post.

This isn’t going to win any Awwwards, but because it’s CSS, the sky’s the limit on how much you want to blow this out. Barring any dramatic site changes, you should have something that is easily re-skinnable and scales pretty well over time.

2. Add head and foot metadata fields

In order to get the styles into the post template, I more or less recreate what I was doing in Better Art Direction. I support two metadata fields in my primary layout. One called head and one called foot. The top of an art directed post looks something like this:

---
title: My kewl post
head: |
  <style>
    .post { font-family: fantasy; }
  </style>
foot: |
  <script type="module">
    import twoUpElement from 'https://cdn.skypack.dev/two-up-element';
  </script>
---

The heavy lifting is then passed to layouts/default.html, my default Liquid layout template. It’s more complex but looks something like this:

<!doctype html>
<html lang="en-us" class="{{ page.body_class }}">
<head>
  <title>{{ page.title }}</title>
  <style><!-- Critical CSS goes here --></style>
  {{ page.head }}
</head>
<body>
  <header><!-- Main navigation goes here --></header>
  <main>{{ content }}</main>
  <footer><!-- Footer links go here --></footer>
  <script src="/js/scripts.js"></scripts>
  {{ page.foot }}
</body>
</html>

The head metadata field does what you might expect and injects whatever I want in the <head> of the page. I mostly use this for styles, but I decided not to limit myself to only styles. It could be used for Google Font imports or some custom preload/prefetch work. The most important thing is that you build yourself a CSS playground that you can use or don’t use depending on how the mood fits.

The foot content renders at the end of the <body> tag after all of my site scripts (~787 bytes) have run. The “after all my scripts” part was more important back when I was using jQuery, but it still seems like a smart idea to run after my vanilla FitVids. Occasionally, if I have a post with a lot of Twitter or CodePen embeds, I’ll yoink out their repeating embed scripts and just put a single script call in the foot. In theory, this may adversely impact RSS readers, but I haven’t triple checked that. The beauty of Progressive Enhancement is that I don’t care, readers will get some version of the content and someway to access it.

Now that you have a playground established, you can really mess up your page. Have fun! Go wild! I’ve used these fields on over 50 posts over the past 10 years and while most people have never noticed, I sure have and that’s what counts.

3. Add support for SVG titles

The low-effort solution of having optional head and foot metadata satisfied my art direction needs for many years, but around 2016 I started getting bored with the web and felt like I needed a new way to punch up the jam. I started playing with SVG animations and realized that SVG post titles might be a great way to inject a lot of spice with as much effort as I want to put into it.

SVG has a lot of advantages for art directed blog posts:

• SVG is vector-based, so it won’t look old in 10 years when we all have 22K retina displays.
• You can theme SVGs with CSS, specifically CSS custom properties, so illustrations can effortlessly transition between light and dark modes.
• You can animate SVGs with CSS opening the door for lots of subtle surprise and delight.
• SVG is scriptable which means you can programmatically generate, alter, morph, or destroy your art work.

The process here can be as simple as typing out some text in Illustrator, outlining it, and copy-pasting that into my post metadata. Or the process can be as complex as breaking out the GreenSock Animation Plugin (GSAP) to create some wild morphing animations. I can do as much with that core concept as my time and ambition will allow.

I sneak the simple SVGs in from time to time. Like on this post about “endless content”, I used the Endless Summer typeface because I enjoy a good pun. Or on my review of the graphic novel March, I outlined the book’s title typeface, which is based on typefaces found on civil rights posters of the time. I’ve started a tradition of doing custom titles on my year end review posts because it gives me an opportunity to express a bit more of the feeling of the year.

But sometimes you need to dial it up a notch. For my 2020 year end review, being such a chaotic year, I felt something bigger was needed so I manipulated a giant coronavirus map of US counties that when you move your mouse over the image, the virus spreads more. That’s where scripting comes into play. I wrote a little bit of science fiction called The Mammoth and because it’s about a large lumbering robot in the future, I wanted the title to look sci-fi but without importing a whole new font, so I outlined Marvin Visions, but I also wanted the title to have some weight so I came up with a way to use CSS variables to create a cheap-ass parallax effect. My biggest effect to date however was my post about Cognitive Overload, where my brain literally explodes into the title when you begin to scroll. Prolific CodePen artists like Sarah Drasner, Mandy Michael, Lynn Fisher, Stéphanie Walter, Stephen Shaw, David Khourshid, Pete Barr, Adam Kuhn, and more have been a major inspiration for me in regards to the possibilities of vector art.

From a technical standpoint, it functions similar to the head and foot technique but with a new svg_title metadata field that is supported in the layouts/post.html template. The metadata looks like this and can get pretty long and make your editor angry so I recommend chucking it through SVGOMG.

---
title: Rectangles!
svg_title: |
  <svg viewBox="0 0 200 100">
    <rect width="200" height="100" fill="pink">
  </svg>
---

And your post template looks like this:

{% if page.svg_title %}
<h1 class="svg-title" aria-label="{{ page.title }}">{{ page.svg_title }}</h1>
{% else %}
<h1>{{ page.title }}</h1>
{% endif %}

An accessibility note: One commitment I’m making is that my art directed title must be a representation of the post title text, otherwise I’d have to come up with a bit more complex solution here.

I’m not a professional illustrator. I’d probably go so far to say I’m a poor illustrator. Most of my ideas revolve around sourcing some SVGs and manipulating them or outlining a neat typeface. But if you… if you can actually illustrate… then, wow! I can’t wait to see what you do.

The tradeoffs of supporting art direction

It wouldn’t be fair to talk about art directing blog posts without talking about the maintenance tradeoffs. Costs exist going this route, but since I’ve been doing this for over 11 years (according to Github), I think I’ve come up with some strategies to minimize some of the trauma.

The biggest challenge is that if I redesign or change my layout dramatically, I’ll occasionally have to tidy up old posts. The amount of pain in this process correlates to the amount of art direction and media-queries I’ve used in the post. For example, one of my oldest art directed posts on interaction consistently causes me frustration. Even now it’s in a state of disrepair. The <aside> should float out more and the page title is actually supposed to be much larger and controlled by your device’s gyroscope. Something broke along the way and my desire to fix it (yet again) is very low.

On the note of fixing up old pages, a nice thing about static sites over their database-backed competitors is that I don’t have to click through some web-based UI to find my art directed posts that I need to fix up. I can quickly grep or search for posts with a head: or foot: metadata field. If I was a more astute developer, I’d make a hidden page of only art directed posts so I could QA faster any time I do some heavy-handed changes.

Another nice thing about static sites is that you’re not as limited in your options. If you want to go all out and create the weirdest page on the Internet, you don’t have to hijack the system. You can eject from your layout entirely by choosing not to specify a layout. That alone gets you most of the way there! A page can be a hand coded page that atrophies at its own pace away from the parent styles is a great way to limit your technical debt.

That’s all the tips and tricks I have. Hope this helps. If you head down this route, please let me know, I’d love to see what you come up with. And welcome to the small but enjoyable group of folks still having fun with their personal websites.

On the modern web, everything must be encrypted. Unencrypted websites are treated as relics of the past with browsers declaring them toxic waste not to be touched (or even looked at) and search engines de-prioritizing their content.

While this push for security is good for protecting modern communication, there is a whole web full of information and services that don’t need to be secured and those trying to access them from older vintage computers or even through modern embedded devices are increasingly being left behind.

Note: This article is mostly directed at those serving personal websites, like this one, with no expectation of privacy or security by most readers of the content. If you are running a commercial website, collecting personal information from users, or transmitting sensitive data that users would expect to be done privately, disregard everything here and don’t bother offering your website over plaintext.

Table of Contents

1. HTTP Upgrading
2. Avoid Forced Upgrading by Default
3. Continue Upgrading Modern Browsers
4. Content Concessions
5. A Rant About Gemini

HTTP Upgrading

Though it’s less common these days, users may still type in your website URL manually as opposed to clicking on a link that already includes the https scheme. (Imagine a user hearing your website mentioned on a podcast and they have to type it into their browser.)

For a URL entered with an http scheme or, more commonly, no scheme specified, unless your domain is listed in the STS preload list of the user’s browser or they are using a plugin like HTTPS Everywhere, the browser will default to loading your website over plaintext HTTP. For this reason, even if your website is only served over HTTPS, it’s still necessary to configure your server to respond to plaintext HTTP requests with a 301 or 302 redirect to the HTTPS version of the URL.

If your server is properly configured to send a Strict-Transport-Security header, once the user’s browser loads your website’s HTTPS version, the browser will cache that information for days or months and future attempts to load your site will default to the HTTPS scheme instead of HTTP even if the user manually types in an http:// URL.

Avoid Forced Upgrading by Default

This forced redirection is a major cause of websites becoming inaccessible on vintage computers. Your server responds to the HTTP request with a 301 or 302 status and no content, and either a) the browser follows the redirection and tries to negotiate an SSL connection, but your server doesn’t offer legacy SSL versions or old ciphers so the negotiation fails, or b) the browser just doesn’t support SSL/TLS at all and fails to follow the redirection.

A real-life example of this is that I recently purchased a Powerbook G4 and updated it to MacOS X 10.5.8 from 2009. It has a 1.5Ghz processor and 1.25Gb of RAM, and can connect to my modern WiFi network and use most of my USB peripherals. It includes a Mail client that can talk to my IMAP and SMTP servers, and a Safari web browser which can render fairly modern CSS layouts. However, it’s unable to view any content at all on Wikipedia simply because it can’t negotiate TLS 1.2 with the ciphers Wikipedia requires. Why is a decade-old computer too old to view encyclopedia articles? I am not the first to complain about this.

A solution to this problem is for websites to continue offering their full content over plaintext HTTP in addition to HTTPS. If you’re using Nginx, instead of creating two server blocks with the listen *:80 version redirecting to the listen *:443 ssl version, use a single server block with multiple listen lines, like so:

server {
    server_name jcs.org;
    listen *:80;
    listen *:443 ssl http2;

    ssl_certificate ...;
    ssl_certificate_key ...;
    ...
    ssl_protocols TLSv1.2;
}

While it may seem counter to the point of this article, I recommend not serving legacy SSL/TLS ciphers like SSLv3 to try to help older browsers. These old protocols and ciphers are insecure and broken, and I feel it’s better to make it clear to the user they’re connecting to a website in cleartext than to offer a false sense of security by having the browser indicate a “secure connection” when it’s being done over an old, broken protocol. Also, while it may not be practical anymore, modern browsers might be tricked into negotiating an old, broken cipher if your server still offers it.

Even if you do offer legacy protocols and ciphers to older browsers, your TLS certificate might be signed by a certificate authority whose root certificate is not trusted by older browsers.

Continue Upgrading Modern Browsers

Now that your entire website is being offered to legacy browsers over HTTP, modern browsers can still be directed to connect over HTTPS for added privacy by responding to the Upgrade-Insecure-Requests header. This header is only sent by modern browsers that support CSP when making an HTTP request, so it’s a reasonable indicator that the client is sufficiently modern and robust that it will be able to negotiate a TLS 1.2 connection if redirected to your site’s HTTPS version.

For Nginx, this can be done inside a server block by defining a variable per-request that includes whether it was made over plaintext HTTP and whether it included an Upgrade-Insecure-Requests: 1 header:

server {
    ...
    set $need_http_upgrade "$https$http_upgrade_insecure_requests";
    location / {
        if ($need_http_upgrade = "1") {
            add_header Vary Upgrade-Insecure-Requests;
            return 301 https://$host$request_uri;
        }

        ...
    }
}

This location block will respond for any request and, for those made over plaintext HTTP where $https will be blank and which included an Upgrade-Insecure-Requests: 1 header, they will be offered a 301 redirection to the HTTPS version. The Vary header is sent so that any caching proxies in the middle won’t cache the redirect.

Content Concessions

With legacy browsers now able to access your site, you may want to make some changes to your HTML and CSS to allow your site to render with some degree of readability. I don’t recommend giving it the full IE6 treatment catering to the lowest common denominator, but at least make the main text of your site readable.

Obviously avoid JavaScript unless it is used progressively, though many older browsers raise error dialogs at the mere presence of modern JavaScript that can’t be parsed even if it’s never executed.

Modern CSS and complex layouts can also be a problem even for browsers just a few years old, so it’s probably best to use them sparingly. For any <a> or <img> tags that are local to your site, use relative links to avoid specifying a particular scheme.

<a href="/posts/blah">
<img src="/images/...">
</a>

If you have to specify an absolute URL to another site that is also available over both HTTP and HTTPS, you can specify it without a scheme or colon and the browser will use the same http: or https: that the document is being viewed over:

<a href="//other.example.com/">My other site</a>

A Rant About Gemini

Tangentially related, Gemini is a modern document transfer protocol that aims to fit between the ancient Gopher protocol and the too-modern HTTP web. Its document markup language is based on Markdown so it’s very lightweight and simple to parse without complex HTML/CSS parsers.

It sounds like the perfect thing to bring modern content to vintage computers, except that its protocol requires all content to be transferred over TLS 1.2 or higher which makes it nearly impossible to access from a vintage computer or even a modern embedded system with limited CPU power.

This requirement seems poorly thought out, especially considering the Gemini protocol doesn’t even support forms (other than a single text box on a search form) so there’s no chance of users submitting private data, and, short of using clunky TLS client certificates, there’s no mechanism for client-server sessions like cookies so clients can’t be authenticated, meaning everything served pretty much has to be public anyway.

Its protocol author argues that TLS is just a simple dependency no different than a TCP server module, so it should be trivial to implement in any client or server. But if your computer’s CPU is so slow that a modern TLS negotiation would take so long as to be unusable, or its platform doesn’t have a TLS 1.2 library available, that makes it difficult to write a client without depending on an external system [2].

In my opinion, the protocol should recommend that servers offer both plaintext and TLS encrypted versions and recommend that clients prefer TLS, but may use plaintext if needed. Clients for modern operating systems can continue enforcing a TLS requirement so their users aren’t feeling any less secure.

Perhaps just sending actual Markdown text over plaintext HTTP to clients that ask for it can be the new, old web.

Accept: text/markdown,text/plain;q=0.9,*/*;q=0.1

Please don’t contact me to “well ackchyually” me and explain MITM attacks and how your terrible ISP inserts ads into your unencrypted web pages and how you were able to make a Gemini client out of a whistle and some shoelaces. If you don’t want to make your website content available to stupid old computers, then don’t.

While I was working with Skylar Watson and some others at a client in Michigan, we were discussing metrics with their uses and abuses (see What Should We Measure).

Skylar had suggested that there was a metric used in manufacturing that has strong applicability to software development in a CI/CD world.

The concept is First Time Through (FTT).

Origin of the Concept

A factory (and, yes, we know that software is not very like a factory… hold on to that objection) seeks to make a perfect instance of their product every time. The aspirational goal of Lean manufacturing is to have perfect value while producing no waste at all.

Sometimes, though, there is a problem.

Perhaps a part is out of tolerance, or something was damaged in handling. The problem must be remedied before the product can be released to customers. The product cannot be allowed to go through to delivery in a defective state.

Since remediation involves a loss of material and time, having and fixing problems are operations that involve waste rather than operations that add value.

So every time a product is assembled perfectly without remediation, the factory has done a splendid job.

The factory work is managed by considering the First Time Through rate.

If a factory had some problem to remediate once for every dozen widgets produced, you would consider it a very poor factory indeed. One would expect that a factory would not see one failure for several hundred or several thousand units produced.

Software “Construction”?

Software is unlike factories. Factories create replica instances of a product but in software, perfect replicas are created by downloading or file-copy commands.

Likewise, the original product isn’t being created by programmers either. The compiler is the analog of fabrication, taking a specification (source code) and building a product according to the specification given by the programmer. Our compilers are bit-perfect, repeatable, and have few imperfections.

Compilers and file-copy are to software as factories are to tangible products.

Certainly, if one measured FTT of a set of compilation and file copying tools, one would find that metric consistently at 100%. Every time one compiles the same code and copies the executable, one gets an essentially perfect copy of the product.

Of course, a metric that never changes is not very helpful in managing an effort, so we don’t bother to measure the FTT rate of our nigh-perfect machinery.

But imagine that you were producing the compiler or the copying command. You would want to have a measurement of how often the machinery correctly produced the intended code and successfully deployed it, right?

If a copy command ran very quickly but the result was not byte-for-byte identical to the original file, you would consider it to be faulty and would set about uncovering and solving its problems.

Likewise, if a compiler produced different and flawed results for the same input, you would set about finding and correcting the causes of error in the compiler. You would certainly leave no stone unturned in fixing or rearchitecting the compiler to produce consistently good results.

FTT In Normal Software Development

Your development teams are continually beginning with whatever version of code currently exists, then extending the design to incorporate additional functions and features. When they are done, they have produced a new revision of code that has never existed before.

This new product is expected to solve problems for some members of the product community. Maybe it is to make the product easier to install and operate. Perhaps it makes it easier to administer various configurations for varied users. Perhaps it provides new operations for users or a better user experience. Maybe all of the above.

This is a design operation, rather than manufacturing.

It’s rather harder to tell if a design will meet its user expectations in the abstract, and the deliverable code is the first complete working model that has been created.

But we deliver our designs (source code) to the machinery that builds and copies the product as we’ve specified (the pipeline).

If the design cannot pass through the pipeline, it is because there is a defect that stops the compiler or the code does not pass the quality checks (often levels of static scanning and tests) in the pipeline, or perhaps there is a failure to install and start the software at the deployment end of the pipeline. Either way, there is some defect that must be returned to the development team for remediation.

Ah, here we see a parallel.

We want the code to pass effectively through the pipeline every time, but sometimes it doesn’t. We want to know how often we can successfully pass through the pipeline and how often we are able to actually solve user problems with the code we produce.

Every time we fail to pass through the pipeline, we have been saved from a public failure, but we also have remediation work to perform.

This remediation costs time and money. Remediation is a waste since no user would pay extra for software where developers spent a lot of time fixing rejected builds.

The remediation waste may (or may not) be a lower cost than releasing defects to the end users in production. Our intention is to make it inexpensive to build software with no defects, or to catch all defects so quickly that they effectively never happened.

I spent a few years in which I polled developers at conferences and user groups, and corporate programmers in various companies I visited. I found that roughly 70% of all developer efforts were going to fixing defects found either in testing or in production code.

I know that sounds obscene, but between 60 and 80 percent of all development effort was waste. It’s not really surprising that their work frequently falls behind schedule.

The “solution” (really a coping mechanism) in many companies is just to fix the errors and move on – pretend after-the-fact that they never happened and don’t think about it anymore.

What if we measured how often we could successfully deploy software, as a ratio of perfect releases to total attempts to release?

Say we created version 2.4 yesterday. If it can go to production, that gives us one try with one success: 100% First Time Through (FTT)!

Today we create version 2.5. It has problems. It takes us 3 tries to get it to pass through the production pipeline. Now we’re 50%. We tried twice, and the second try had issues. This gives us 50% FTT (one troubled attempt with retries, one successful attempt).

That dip suggests that something different happened in 2.5. What was it? Was there a flaw in our process or our understanding that let the issues slip past our awareness until it failed in the pipeline? What does the difficulty have to teach us?

Tomorrow we create version 2.6, and it goes out without an issue. We’re now at 66% FTT.

Armed with this information, and an intention to improve FTT, we start to change our procedures to create more safety and confidence.

We may add security and quality scans to our IDEs so we can find problems and correct them sooner.

We test better and earlier, increasing our supply of automated tests so we have reason to believe that our code will pass in testing (and to support refactoring).

We review each other’s work, perhaps continuously.

We remove code smells like primitive obsession, to make it harder to make common mistakes.

We eliminate duplication in the code base, so we reduce our maintenance effort.

We may take a little longer to get code into the pipeline, but now we aren’t spending 70% of our time on fixing failures and so we are delivering more often.

If you spend 20% of your time on new code, and 80% on fixing broken code then if you could reduce your defects to consume only 40% of your time, you could spend 60% of your time on new code. That is a threefold increase in development time. Even if you spent twice as much time developing each feature you would deliver code to production more often and more predictably.

So measuring FTT and acting to improve it can result in better code sooner.

As with any metric, measurement without focused improvement efforts is useless.

Unanswered Question

“Tim, this is helping our process of making code, but it doesn’t answer whether the products are any good – whether they satisfy user needs or not! What about validating the code with users?”

Guilty. FTT focuses on the process of making software, but doesn’t directly influence whether we are making the right software.

At least, using FTT doesn’t do anything to damage or impair your ability to produce the right solutions. It is entirely synergistic with attempts to build better products.

But consider this, if you can’t get your software to production quickly then your ability to experiment with new solutions is stymied by your inability to release experimental code.

If your process is not very good at getting your software delivered, it doesn’t much matter if it’s pretty good or pretty awful - if it’s not perfect in every way, you are going to struggle to improve it.

Additional External References

• First Time Through Yield at Lean Manufacture
• First Time Yield (FTY) at Lean Strategies
• ROI on improving FTT at Sciemetric (pdf)

This story initiall appeared on TNL.net. Accept no substitute for the original.

The post <span class='p-name'>An American Tragedy</span> appeared first on TNL.net.

There’s an exercise where you take an abstract scribble and transform it into a fully formed drawing. It’s hard not to think of that exercise when watching the Apple TV+ dramedy Ted Lasso.

The show, or at least its characters, started life as a series of NBC Sports promos starring Jason Sudekis, but those were mere abstract shapes compared to the fleshed out thing that they’ve evolved into.

Among the digerati, I’ve read more than once comments like these from Jason Kottke:

It’s ok if you don’t care for sports. It’s not about sports.

Assuming it was about sports kept me from watching it initially; when I finally succumbed I realized that, indeed, it’s not about sports, at least not in the sense that you have to be sporty to enjoy it. Which I do.

In this vein it’s not unlike Sports Night, the venerable Aaron Sorkin/Thomas Schlamme creation, from which the absence of a laugh track earned a New Yorker profile before it even debuted. Author Tad Friend wrote there:

The subject of sports isn’t particularly suited to a TV series, but likeable characters who like sports are.

The characters of Ted Lasso are exceedingly likeable, especially Sudekis, who, with his costar Brendan Hunt and two others, created the show. The original Ted Lasso, from the NBC Sports days, was all thinly drawn goofy parody; the Ted Lasso in the series is that, plus backstory, plus heart, plus metaphysics. He is the coach we all wished we once had.

This success of transforming a sketch into a work of art makes me think I should option the series rights for those old Peter Pan commercials.

At the bottom of most areas where you type your question for a community, you have an option to add a ‘tag’.

This seemingly benign option has such a huge impact over a community it’s bewildering how little discussion it receives.

When tagging is done well, it achieves three things:

1) Ensures the right posts appear in front of the right people. Experts in particular topics can browse a page of properly tagged discussions and answer questions. This increases both the quantity and quality of answers. Sometimes people can even follow particular tags.

2) Enables you to create topic pages. You can use tags to create unique topic pages filled solely with discussions, articles, and other material relevant to that particular tag. This gives you far more flexibility than category pages.

3) Lets members follow tags. Members can follow and receive questions related to particular tags they’re interested in. You can even find the top experts by each particular ‘tag’ in the community.

However, tagging is rarely done well in the community. Most communities fall victim to one of three mistakes.

Mistake 1: Forcing members to come up with tags. This is the worst option. If members have an open text box to create a ‘tag’, you’re going to get dozens of variations of similar tags ranging from (‘iphones’, ‘brokeniphone’, to ‘dfgdfg’).

Mistake 2: Forcing members to start typing for tags to appear. This is slightly better, at least relevant tags will appear as members type them. However, members still have to know what a tag is and can still misclassify their answers.

Mistake 3: Presenting too many tags. This at least lets people select tags, but often there are so many tags to choose from members just select anything to make the boxes go away.

The Right Approach to Tagging

The right approach to tagging is to use your existing member data to suggest relevant tags.

The Apple community is the best example of this. To ask a question, you first need to log-in. Once you log-in, you can start typing your question in the search box (this helps reduce duplicate questions).

Once you click the link to ask a question, the platform uses your data to suggest the most likely tags.

This is about as good as it gets.

You can select what you’re asking about and what topic your question is relevant to. You can still change it if it’s not a good fit, but thus far I’ve found these options to be spot on.

If you’re looking for a project to massively improve your community in the new year, I’d start here.

I read Fall or Dodge in Hell in the past two weeks, reading the Dutch book Suikerbastaard in between.
Fall is about 900 pages, so it took a bit more time than average to read.

(spoilers below the image)

Neal Stephenson discussing The Fall, image by Christopher Michel, license CC-BY

The book consists of multiple distinct large parts on a timeline. Normal beginnings where a billionaire wants his body preserved until his brain can be properly scanned, a part where the internet is becoming obsolete due to too many fakes, hoaxes and trolling, a post truth US where religious cults are rampant in Ameristan i.e. the spaces between the urban areas that are still tied to reality, the part where the rebooted brain of the billionaire creates his own world, to be unseated as main deity by newcomers, and a quest to right that wrong.

Enoch Root makes an appearance again, entering quite dramatically, and seems to indicate he comes from a plane of existence that created our world as a simulation. Towards the end Zula says ‘I understand light speed now’ as an externally applied constraint, the limit posed by the processing power available to our virtual environment. The speed at which changes propagating from an event can be calculated determines the speed of causality in the piece of spacetime we’re in. That’s the moment Enoch Root says to her his task here is complete and he vanishes into the fog, suggesting he’s leaving our sim, to return to another plane of existence. Not so much turtles all the way down, as sims all the way up?

This graphic about where we feel emotion made me look.

Background

Two years ago, we announced experimental support for the privacy-protecting Encrypted Server Name Indication (ESNI) extension in Firefox Nightly. The Server Name Indication (SNI) TLS extension enables server and certificate selection by transmitting a cleartext copy of the server hostname in the TLS Client Hello message. This represents a privacy leak similar to that of DNS, and just as DNS-over-HTTPS prevents DNS queries from exposing the hostname to on-path observers, ESNI attempts to prevent hostname leaks from the TLS handshake itself.

Since publication of the ESNI draft specification at the IETF, analysis has shown that encrypting only the SNI extension provides incomplete protection. As just one example: during session resumption, the Pre-Shared Key extension could, legally, contain a cleartext copy of exactly the same server name that is encrypted by ESNI. The ESNI approach would require an encrypted variant of every extension with potential privacy implications, and even that exposes the set of extensions advertised. Lastly, real-world use of ESNI has exposed interoperability and deployment challenges that prevented it from being enabled at a wider scale.

Enter Encrypted Client Hello (ECH)

To address the shortcomings of ESNI, recent versions of the specification no longer encrypt only the SNI extension and instead encrypt an entire Client Hello message (thus the name change from “ESNI” to “ECH”). Any extensions with privacy implications can now be relegated to an encrypted “ClientHelloInner”, which is itself advertised as an extension to an unencrypted “ClientHelloOuter”. Should a server support ECH and successfully decrypt, the “Inner” Client Hello is then used as the basis for the TLS connection. This is explained in more detail in Cloudflare’s excellent blog post on ECH.

ECH also changes the key distribution and encryption stories: A TLS server supporting ECH now advertises its public key via an HTTPSSVC DNS record, whereas ESNI used TXT records for this purpose. Key derivation and encryption are made more robust, as ECH employs the Hybrid Public Key Encryption specification rather than defining its own scheme. Importantly, ECH also adds a retry mechanism to increase reliability with respect to server key rotation and DNS caching. Where ESNI may currently fail after receiving stale keys from DNS, ECH can securely recover, as the client receives updated keys directly from the server.

ECH in Firefox 85

In keeping with our mission of protecting your privacy online, Mozilla is actively working with Cloudflare and others on standardizing the Encrypted Client Hello specification at the IETF. Firefox 85 replaces ESNI with ECH draft-08, and another update to draft-09 (which is targeted for wider interoperability testing and deployment) is forthcoming.

Users that have previously enabled ESNI in Firefox may notice that the about:config option for ESNI is no longer present. Though we recommend that users wait for ECH to be enabled by default, some may want to enable this functionality earlier. This can be done in about:config by setting network.dns.echconfig.enabled and network.dns.use_https_rr_as_altsvc to true, which will allow Firefox to use ECH with servers that support it. While ECH is under active development, its availability may be intermittent as it requires both the client and server to support the same version. As always, settings exposed only under about:config are considered experimental and subject to change. For now, Firefox ESR will continue to support the previous ESNI functionality.

In conclusion, ECH is an exciting and robust evolution of ESNI, and support for the protocol is coming to Firefox. We’re working hard to make sure that it is interoperable and deployable at scale, and we’re eager for users to realize the privacy benefits of this feature.

The post Encrypted Client Hello: the future of ESNI in Firefox appeared first on Mozilla Security Blog.

I built a new Datasette plugin called datasette-css-properties. It's very, very weird - it adds a .css output extension to Datasette which outputs the result of a SQL query using CSS custom property format. This means you can display the results of database queries using pure CSS and HTML, no JavaScript required!

I was inspired by Custom Properties as State, published by by Chris Coyier earlier this week. Chris points out that since CSS custom properties can be defined by an external stylesheet, a crafty API could generate a stylesheet with dynamic properties that could then be displayed on an otherwise static page.

This is a weird idea. Datasette's plugins system is pretty much designed for weird ideas - my favourite thing about having plugins is that I can try out things like this without any risk of damaging the integrity of the core project.

So I built it! Here are some examples:

roadside_attractions is a table that ships as part of Datasette's "fixtures" test database, which I write unit tests against and use for quick demos.

The URL of that table within Datasette is /fixtures/roadside_attractions. To get the first row in the table back as CSS properties, simply add a .css extension:

/fixtures/roadside_attractions.css returns this:

:root {
  --pk: '1';
  --name: 'The Mystery Spot';
  --address: '465 Mystery Spot Road, Santa Cruz, CA 95065';
  --latitude: '37.0167';
  --longitude: '-122.0024';
}

You can make use of these properties in an HTML document like so:

<link rel="stylesheet" href="https://latest-with-plugins.datasette.io/fixtures/roadside_attractions.css">
<style>
.attraction-name:after { content: var(--name); }
.attraction-address:after { content: var(--address); }
</style>
<p class="attraction-name">Attraction name: </p>
<p class="attraction-address">Address: </p>

Here that is on CodePen. It outputs this:

Attraction name: The Mystery Spot

Address: 465 Mystery Spot Road, Santa Cruz, CA 95065

Apparently modern screen readers will read these values, so they're at least somewhat accessible. Sadly users won't be able to copy and paste their values.

Let's try something more fun: a stylesheet that changes colour based on the time of the day.

I'm in San Francisco, which is currentl 8 hours off UTC. So this SQL query gives me the current hour of the day in my timezone:

SELECT strftime('%H', 'now') - 8

I'm going to define the following sequence of colours:

• Midnight to 4am: black
• 4am to 8am: grey
• 8am to 4pm: yellow
• 4pm to 6pm: orange
• 6pm to midnight: black again

Here's a SQL query for that, using the CASE expression:

SELECT
  CASE
    WHEN strftime('%H', 'now') - 8 BETWEEN 4
    AND 7 THEN 'grey'
    WHEN strftime('%H', 'now') - 8 BETWEEN 8
    AND 15 THEN 'yellow'
    WHEN strftime('%H', 'now') - 8 BETWEEN 16
    AND 18 THEN 'orange'
    ELSE 'black'
  END as [time-of-day-color]

Execute that here, then add the .css extension and you get this:

:root {
  --time-of-day-color: 'yellow';
}

This isn't quite right. The yellow value is wrapped in single quotes - but that means it won't work as a colour if used like this:

<style>
nav {
  background-color: var(--time-of-day-color);
}
</style>
<nav>This is the navigation</nav>

To fix this, datasette-css-properties supports a ?_raw= querystring argument for specifying that a specific named column should not be quoted, but should be returned as the exact value that came out of the database.

So we add ?_raw=time-of-day-color to the URL to get this:

:root {
  --time-of-day-color: yellow;
}

(I'm a little nervous about the _raw= feature. It feels like it could be a security hole, potentially as an XSS vector. I have an open issue about that and I'd love to get some feedback - I'm serving the page with the X-Content-Type-Options: nosniff HTTP header which I think should keep things secure but I'm worried there may be attack patterns that I don't know about.)

Let's take a moment to admire the full HTML document for this demo:

<link rel="stylesheet" href="https://latest-with-plugins.datasette.io/fixtures.css?sql=SELECT%0D%0A++CASE%0D%0A++++WHEN+strftime(%27%25H%27,+%27now%27)+-+8+BETWEEN+4%0D%0A++++AND+7+THEN+%27grey%27%0D%0A++++WHEN+strftime(%27%25H%27,+%27now%27)+-+8+BETWEEN+8%0D%0A++++AND+15+THEN+%27yellow%27%0D%0A++++WHEN+strftime(%27%25H%27,+%27now%27)+-+8+BETWEEN+16%0D%0A++++AND+18+THEN+%27orange%27%0D%0A++++ELSE+%27black%27%0D%0A++END+as+%5Btime-of-day-color%5D&_raw=time-of-day-color">
<style>
nav {
  background-color: var(--time-of-day-color);
}
</style>
<nav>This is the navigation</nav>

That's a SQL query URL-encoded into the querystring for a stylesheet, loaded in a <link> element and used to style an element on a page. It's calling and reacting to an API with not a line of JavaScript required!

Is this plugin useful for anyone? Probably not, but it's a really fun idea, and it's a great illustration of how having plugins dramatically reduces the friction against trying things like this out.

“I’ve already reached out to a few platform vendors”

….is a sentence message I’ve learned to dread.

It’s usually a sign they’re trying to select a platform before determining the best approach to a community. Once people reach out to vendors, they fall in love with a particular vision for the community which is hard to shift.

A friend of mine recently reached out for advice on which platform to pick.

He had narrowed the list down to four options.

What surprised me was how different the four platforms were. One was a major enterprise platform, one was a forum-based platform, one was an instant messaging platform, and one was a hybrid of all three.

Each platform was suited to an entirely different approach to building a community.

One would’ve been great as a customer support channel and enabling members to share content with one another. Another would’ve been great for creating a tighter, more intimate, sense of community.

One platform might’ve been ideal for an organisation that needed to tightly integrate the community with existing systems, another was perfect for a separate, undercover, experience that could be launched quickly and cheaply.

You should decide the approach your community is taking before you shortlist (and contact) potential communities.

If you’re trying to decide between different platforms in different categories, you have a strategy problem.

This is a terrible way to build community!

For starters, you’ll end up picking the platform with the most persuasive pitch (often the one that promises success in the most hyperbolic terms) instead of looking for the platform which best suits your needs (you don’t know your needs yet).

Second, you’re beginning with the needs of the vendor rather than the needs of your audience and your organisation.
For sure, you might get lucky. The platform you pick might wind up being the perfect platform for your community’s needs. But if you haven’t undertaken your audience research, gathered detailed requirements from your stakeholders, prioritised a list of items you need, you have no way of knowing that.

Sound Recorder is simple to install and a powerful way to record in the studio or on the go:

The app itself is deceptively simple, it offloads all of the audio device setup and selection to the OS layer, which can be managed in settings:

With the brunt of the setup automatically handled by PureOS, you can set up the basics from within the app menu.

Actually using the interface could not be more intuitive. Simply hit record to record, and click a past entry if you want to listen to it.

A Quiet Solution:

Silence is ideal for any recording studio or sound room. The fans in a standard x86 computer can impact the end result if kept too close to the mic. When I first built my sound closet room I cabled long runs of USB and power to prevent having to use a computer near my mic. This sucked as I had to print out my script and I couldn’t check the recording status during the session.

Being able to read the script off a screen and having access to the audio controls drove me and my roommate to build this fanless monstrosity:

This did the trick for years but did suffer from major stability issues which were endlessly frustrating to deal with mid recording. Now with USB-C dock support getting better and better, using the Librem 5 has solved all my recording issues and has now permanently replaced my sound room computer.

Discover the Librem 5

Purism believes building the Librem 5 is just one step on the road to launching a digital rights movement, where we—the-people stand up for our digital rights, where we place the control of your data and your family’s data back where it belongs: in your own hands.

Order now

The post App Spotlight: Sound Recorder appeared first on Purism.

Today’s outside time was a rainy walk & stop in at @timbertrain depot. I’m loving the super cute skull-with-toque design on the t-shirt.

“The goal is a creative, detail-oriented [software] team that finds the best solution using the full weight of their diverse skills and creativity, and has fun doing it.”

— Ben Werdmüller, Engineering vs writing code

Somewhere in here is a longer discussion about building products vs solutions, understanding who you’re building for, and even on to things like learning by doing, prototyping, and more.

Building a business built on software vs writing code to solve a problem for yourself is maybe the two aspects to contrast?

I don’t think the distinction between engineering and programming / hacking that Ben makes is the most useful one.

And perhaps this is my Canadian perspective where “engineer” is a protected, professional term like doctor or lawyer.

So much of software still appears to be based on fashion.

But I do take Ben’s point. This concept of rigor is interesting to me as I think “beyond open source”. I use to think that the license of a software was one of its most important aspects. Now I feel that way more about open data structures, standards, and protocols.

If we agree on the protocol, we can always build the code again, and it can be built by hackers or by engineers as long as the protocol still works.

Do protocols need to be rigorously designed? And we’re back to square one ;)

Today’s #eastvan coffee shop is Pallet. No rain and a touch of blue sky!

Plus: view from the corner of Meditation Park. East Van’s waterfront is mostly blocked off because it’s the commercial Port of Vancouver space. Wall Street has several small view parks like this.

I had sourdough bread success today. I’ll take it.

Here's the headline: "We’ve trained a neural network called DALL·E that creates images from text captions for a wide range of concepts expressible in natural language." Oh, but do look at the article; it is chock-full of examples of images created for different types of phrases and expressions. "It has a diverse set of capabilities, including creating anthropomorphized versions of animals and objects, combining unrelated concepts in plausible ways, rendering text, and applying transformations to existing images." The MIT Technology Review article loved the example of the avocado-shaped chair (and frankly, so do I, but I also like the snail with the texture of a harp and the baby daikon radish in a tutu walking a dog). The name is a portmanteau of the artist Salvador Dalí and Pixar’s WALL·E. Personally, I'm waiting for BALL-E, an AI that creates and sends vacation pictures to your social media accounts.

This is a really good reading list devoted to distributed systems. If you're just learning about them, start here. You'll find accessible accounts of some of the key considerations (with odd-sounding names like Paxos consensus, Byzantime Generals, consistency models, and gossip protocols. None of this is easy sledding, and there's a lot to learn about actual implementation after, but this list frames the target people are working toward. See more on Dan Creswell's GitHub page. If you don't like this reading list, here's another. Image: Stanislav Kozlovski, who offers a nice introduction to all of it.

The problem, of course, is that in many cases test results (ie., "A levels") are not available to UK universities due to pandemic restrictions. So how to preserve the fairness of admissions (or at least, the appearance of fairness)? If it were me, I would do away with the admissions process - after all, we're in the age of digital learning and can, in theory at least, support much larger student numbers, and can also lower the stakes for students. Offer first-year courses as open-admission MOOCs. Offer preparatory MOOCs for those who might lack the skills or abilities. As people make their way through the MOOCs, scale online learning to meet the resulting demand. Focus on offering learning to anyone who has the determination and ability to master the discipline. Though I admit - 'education for all' is probably too radical a concept for the guardians of the higher education system.

Facebook is extending its ban on U.S. President Donald Trump’s account “indefinitely and for at least the next two weeks.”

Following the violent siege of the U.S. Capitol on January 6th, the social media giant banned Trump from its platforms for 24 hours but has now decided to extend the measure until the “peaceful transition of power is complete.”

“We believe the risks of allowing President Trump to continue to use our service during this period are simply too great,” Facebook CEO Mark Zuckerberg said in a statement.

Zuckerberg states that over the last several years, the company has allowed Trump to use its platform in accordance with its rules and at times removed some of the content when it breached its policies. However, he says the current context is now fundamentally different as the platform is being used to incite violent insurrection.

“The priority for the whole country must now be to ensure that the remaining 13 days and the days after [Joe Biden’s] inauguration pass peacefully and in accordance with established democratic norms,” the statement reads.

Facebook is the first social media platform to extend its temporary ban on Trump’s account. He was temporarily banned from Twitter and Snapchat, and it’s unclear if these platforms will follow Facebook and extend their measures.

Social media giants are attempting to contain the spread of Trump’s messaging amid the ongoing unrest and are imposing restrictions. YouTube, Twitter and Facebook removed a video posted by Trump in which he spread misinformation about election results and told the rioters: “we love you. You’re very special.”

These actions follow increased criticism of social media giants for their role in the spread of propaganda, hate speech and misinformation.

As Facebook has taken this unprecedented step, it’ll be interesting to see if other companies will follow and if it will take such action again, perhaps in other countries around the world as well.

Source: Mark Zuckerberg 

The post U.S. President Donald Trump banned from Facebook ‘indefinitely’ appeared first on MobileSyrup.

GM is rebranding to focus on electric vehicles with a new marketing campaign targeted at what it’s calling ‘Generation E.’

The company’s global chief of marketing, Deborah Wahl, says that “Unlike ever before, we have the solutions, capability, technology and scale to put everyone in an EV. Our new brand identity and campaign are designed to reflect this.”

It should be noted that GM sees ‘Generation E’ not as exclusively young people, but rather people of all ages that want to make a change and help be part of the electric vehicle revolution. The automaker is trying to use an ad campaign to legitimize this section of the market and draw more people into it. For now, I think that Generation E is more commonly know as early adopters. It will be interesting to see if GM’s marketing works and draws more people into the EV fold.

As part of the marketing campaign, General Motor is using Canadian Malcolm Gladwell since his theory from the book The Tipping Point can be applied to mass EV adoption. Beyond Gladwell, viewers may also see “professional surfer and shark attack survivor Bethany Hamilton, fitness instructor Cody Rigsby and gamer Erin A. Simon.”

The last time the company revamped its logo this drastically was in 1964, and this is only the fifth redesign in the automaker’s history.

Beyond the new logo and ad campaign, GM is also pledging $27 million in EV and autonomous vehicle production. It also plans to release 30 electric vehicles globally by 2025.

These new ads focus on the GM Ultium Battery pack, which will be used in the upcoming GMC Hummer and the Cadillac LYRIQ. The company says that this battery will ensure that GM’s EVs have a range of around 450 miles (724km) and that super-fast acceleration EVs are known for.

To make this brand change over concrete, the company is also revamping its website with a modern look on January 11th. The relaunch will happen in the U.S. first but will come to the Canadian site later.

To learn a little more about GM Canada’s stance on EVs read our exclusive interview with GM Canada president Scott Bell.

The post GM rebrands to welcome its all-electric future appeared first on MobileSyrup.

I can't remember who linked me to blocks, but it's pretty fun. The sound effects are... something else. Unfortunately it seems to sometimes lose your progress.