The 2nd book C.S. Lewis' little-known (to me) Space Trilogy. Great experience reading this. Lewis is amazing with language and allegory. Inspiring, heroic performance by the returned-hero, Ransom.  Another beautiful, unexpected world painted with words. Some high-stakes conflict that engaged my personal investment. Where does the trilogy go from here?

Perelandra

Was screening this for my children to read. It's been a long time since I read Road Dahl, back with James and the Giant Peach. This was odd, like all of Dahl that I've read. I didn't like the fact that the kid was telling the story of how cool his dad was because he was addicted to poaching.

Danny the Champion of the World

Great moments in this book to ponder the great love of God in the gift of His Son. Great stories from people who have felt the sadness and weight at their own betrayal of their duty to God and have yet recovered through the grace of Jesus Christ, helping them change.

I'm grateful for the merciful forgivness of our Heavenly Father.

The Divine Gift of Forgiveness

Svelte Basics

Styling React Components

Electron Fundamentals Course

Here's a method for getting that new foreign key column to be non-nullable and without a default.



## Django migrations are awesome

Django has a solid ORM and some nice database migrations to go with it. First, make a change to your model in python code, then run:

```bash
python manage.py makemigrations
```

The the migrations will be generated based on your model changes since the last migration. To apply the migrations in the database, run:

```bash
python manage.py migrate
```

But what if you want to make a migration for a new non-nullable field?

## Protective parent

Well, Django wants to help you do the right thing. And if you add a new non-nullable field to the model and run `makemigrations`, it'll balk and warn you that you can't make a new non-null field because you might already have rows without that new column, and those rows can't violate the non-null constraint on the column.

It'll report something like:

```
~/myapp ❯ python manage.py makemigrations
You are trying to add a non-nullable field 'created_by' to mymodel without a default; we can't do that (the database needs something to populate existing rows).
Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Quit, and let me add a default in models.py
```

## Give in and add the default

To get the migrations to run, add the default one way or the other.

That might look like:

```python
from django.contrib.auth.models import User
from django.db import models

class MyModel(models.Model):
    # ...
    created_by = models.ForeignKey(User, default="")
```

Now you'll be able to `makemigrations`.

## Then turn around and remove it

But now you're sneaking out the bedroom window...

Adjust your model again, removing the default: 

```python
from django.contrib.auth.models import User
from django.db import models

class MyModel(models.Model):
    # ...
    created_by = models.ForeignKey(User)
```

You run `makemigrations` again, and you're set: new column, no default, non-nullable.

A bit of a run-around? Yes. Do you have a better way to do this?

A method for getting that new foreign key column to be non-nullable and without a default.

Add a Migration for a Non-null ForeignKey Field in Django

We are different than the Tech Giants. We can and should develop software differently from them. Generally, we have simpler needs.



## A Part of the Tech Giant Discussion

Lately, there is a wider discussion in the public sphere about some of the ills that come from the emergences of very large tech giants (companies) that control or influence large aspects of our lives and society. Those are interesting, and I believe worthwhile, discussions. This article is but a sliver of that larger discussion.

How does the existence of these tech giants affect our software development practices? In one way, they encourage the creation of complex software solutions.

## A Different Class of Problems

These exist: super-large companies that serve super-large swaths of the population with super-expansive products. They employ some of the smartest and brightest and most innovative among us (to optimize an ad, a Like or a Buy button, among other things). 

But these are not you or me (statistically-speaking).

This is a different class of problem. 

I am a super small company, serving a minimally-viable audience with products that yesterday were toys.

## Different Problems, Different Answers

Do I need 99.999% up-time? Do I need to auto-scale? Do I need redundancy?

Do I need to A/B test? Do I need to optimize my mobile experience?

Do I need to be AAA accessible? Do I need a CDN? 

Do I need to follow that convention? Do I need the lint rules?

Do I need CI? Do I need to upgrade? Do I need a certain architecture?

Do I need to use that protocol? Do I need to follow that framework pattern?

Do I need that project layout? Do I need to split up this code?

Do I need monitoring? Do I need persistent logs? Do I need backup?

Do I need to depend on that library? Do I need to cover that case?

## Solutions Mis-matched

The answers to those questions aren't definite. It's a giant "it depends". We say this and joke about it. Then why do we sometimes fail to act like it?

The gravity of the Tech Giants are large and difficult to escape from within software development. They have great talent. They write great think-pieces. They prove their need in great white papers. They (and their influence) are prolific on the speaking circuit. They invent and push the state of the art for their class of problem. It's all very exciting. 

In some ways they've surpassed us. (In so many things!) Why not in software development as well?

We software developers and architects and operations engineers try to keep up. We use the latest, greatest. We want to be on the cutting edge. We don't want to look inferior or be inferior. We want to be marketable. We want to attract some of the best and brightest.

But we *will be* more bright if we see these as often different classes of problems. We will stop resume-driven development. We will learn best-in-class tools and apply them to our best-in-class problems. 

## Avoid the Cost

It's fun to punch above your weight, but it takes a lot of effort. Yes, you might be prepping your team and product to be the next rocket ship. Good luck to you.

But if you're happy to play within a certain scale and class of problem, you might want to avoid some of the costs of those more expansive problems.

Save money. Save time. Save the need to get more help. Save the need for some of those conferences tempting you to a new tech. Save your breath trying to keep up.

What do you think? Are there different classes of problems? Do we attempt to develop software in the mode of the tech giants when we could otherwise happily avoid it?

## Example

Edit: I've added this example because it really speaks to the same idea.

[A company not using Docker](https://launchyourapp.meezeeworkouts.com/2021/03/why-we-dont-use-docker-we-dont-need-it.html?m=1) - They feel some pressure to use it. They don't see the need. They see it as meta work getting in the way of the real work they need to do.

Allow keyboard users to horizontally scroll code blocks

We Want to Develop Software Like the Tech Giants

This is how we can allow keyboard users to horizontally scroll code blocks.



## The Need to Scroll

Why would a code block need to be accessible by keyboard?  It's just text after all. Yes, most of the time there's no additional keyboard accessibility required by text. Most visual designs preclude this.  But in the case, of code blocks, we sometimes have the problem of visibility. 

Some text in the block might not be visible because it's offscreen. It's sometimes offscreen because code blocks usually do not wrap lines, and so a horizontal scroll will be needed.

## WCAG 2.1.1

WCAG, the Web Content Accessibility Guidelines, version 2.1, gives an instruction that all content should be accessible through a keyboard as an alternate interface to a mouse. This is found in [WCAG 2.1.1](https://www.w3.org/WAI/WCAG21/Understanding/keyboard.html).

Thus, our users should be able to horizontally scroll the code block to see the entire text using only the keyboard.

## Focusable Blocks

This is accomplished by allowing the code blocks to be focused. Once focused, the left and right arrow keys on the keyboard can be used to scroll left and right to show the offscreen text.

Code blocks are usually rendered in a `pre > code` HTML hierarchy, such as:

```html
<pre>
  <code>
    printf("My extremely long line of code that you can not see to the end of.")
  </code>
</pre>
```

A `code` element is not natively focusable. But we can make it so by [adding a tabindex](/post/accessibility-potential-tab-index-values). To make this code accessible, we'd adjust it to be:

```html
<pre>
  <code tabindex="0">
    printf("My extremely long line of code that you can not see to the end of.")
  </code>
</pre>
```

Now we're ready we're ready to view all code contents in the block with our keyboard. W00t! You might want to also add a `:focus` CSS style to your `code` blocks to improve the visual navigation.

Do you agree with this interpretation of WCAG 2.1.1? Is there anything you do to make code blocks more accessible?

Make Code Blocks Keyboard Accessible

<div class="video-container">
<script async class="speakerdeck-embed" data-id="eb226aa6a2a449299036d225fc2d34ab" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
</div>

This was an experience report given to a Pluralsight audience, meant to increase understanding and appreciation of the Design System we made for ourselves by sharing a history of where it all started and how we came to the place we have. A similar talk meant for an external audience could be interesting, but would likely differ in content for sake of interest.

An experience report to an internal audience on how we made the Pluralsight Design System

How We Make the Design System

<div class="video-container">
<script async class="speakerdeck-embed" data-id="2bcda367b51843789b8f0301128a246d" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
</div>

A presentation for Global Accessibility Awareness Day, where we were to demonstrate how our design system for the web builds with accessibility as a goal and can help product teams support these needs from the outset.

Some tidbits on how we've approached building accessibility into the design system

Accessibility in the Pluralsight Design System

<div class="video-container">
<script async class="speakerdeck-embed" data-id="9a8ad50208b8462794055b48035405d2" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
</div>

Since the inception of our design system, React has been a core technology. Being in a polyglot tech organization however, React wasn't always a given. We never thought that the design system would be able to serve all teams equally. But we wondered if we might do more to support the non-React teams and products. This is a recounting of that journey.

Our explorations in supporting tech beyond React in our design system.

Courses

Posts

Talks

Reading