I don’t use opioids.

I don’t intend to use opioids.

But that’s not the point.

.

.

.

In the summer of 2019 I was on the 7 heading home from Downtown to the Kitsilano apartment I shared with my wife. It was a perfectly normal day on transit. Hot. Stagnant air. Sweaty people. Stop and go from stop to stop on Granville Street. The whine of the electric bus. The clack-clack of the trolley bar on the overhead cables. People were zoning out.

One guy was different.

I had noticed him getting on earlier. Not exactly sure what it was, but something suggested there was a problem. This guy looked like a pretty normal construction worker on his way home. Work boots with leather missing over the steel toes. Dusty clothes. Dirty face. Pretty normal stuff.

But something was off.

He took a seat near the front. This was just after the bus turns on to Granville and there was still space left. By the end of Granville it’s standing room only folks. This guy immediately started to nod off.

I’m not sure if you’ve experienced this but there is a difference between people who fall asleep because they are hot, bored, and tired, and people who are passing out. People the former camp will fight it. Head bouncing up and down. Shifting in their seat. Looking around. Yawning. People in the second camp … just pass out. This guy was passed out, fast.

Okay, so the guy had a couple of drinks after work. Taking the bus home rather than driving. Not the first time I’d seen it on the bus. Commendable. Right?

By the time we got to Davie Street things had changed. The guy was not responding and had half fallen out of his chair. I had stopped watching him by this point because I was all the way in the back and there were many people standing in the isle. A lady grabbed the driver’s attention. The driver stopped the bus and tried to get the guy to respond without success. Verbal and physical queues were having no impact. The driver called the ambulance on the radio and asked everyone to get off the bus. I was one of the last people to step off.

The last thing I saw from within the bus was the lady and bus driver trying without success to wake the man. He was laid out on the floor of a bus with two strangers looking down at him watching him die. There was nothing I could do.

.

.

.

Around this time the Canadian and BC governments started handing out Naloxone kits. Naloxone is an injectable opioid antagonist. It binds to opioids that have blocked receptors in the brain and knocks them free. And it works fast - scary fast. And the side effects are minimal so it’s safe to inject even if you don’t have full confirmation that the patient is overdosing on opioid.

Given my experience I just couldn’t sit by. I took the online course. Then stopped at the London Drugs downtown. A quick couple of questions and I’m off with my kit.

.

.

.

That kit has sat unused in my backpack for years. Right beside my small first aid kit. Neither take much room. And I’d rather have it and never use it.

It’s become apparent to me that the opioid crisis is not a crisis of status or money or opportunity. It’s an equal opportunity problem. People are getting hooked for many reasons. Once hooked in, it’s a hard one to shake. So my thinking is simple. Anyone, at any time could have an issue. If I can help just by carrying the kit and being close at hand, it costs me nothing.

.

.

.

A couple of months ago I was very tired after the drive in and coming down the elevator of the Bay Parkade, decided to get some Tim’s for breakfast. This is not something I do.

As I passed the driveway past the parkade and neared the old RadioShack building, I noticed a small group of people. It quickly became clear that one person was giving another CPR.

Two Vancouver Downtown Ambassadors were giving aid to a guy who had obviously been sleeping rough. The second Ambassador was watching. This looked like a classic overdose to me. As I approached, I asked if they had administered Naloxone. His reply stunned me. They were barred from administering Naloxone. But don’t worry they had called for an ambulance. WTF! You can give CPR/Mouth-to-mouth but not Naloxone. In downtown Vancouver? Blocks away from the center of the opioid epidemic in Canada?

I dropped my bag and rummaged around for my kit. I had just gotten my gloves on when one of the quick response trucks pulled up. First responders piled out. Much better equipped than I. I slipped my kit back together into my bag and kept on with my day.

.

.

.

I carry a naloxone kit in my backpack.

I don’t use opioids.

I don’t intend to use opioids.

But that’s not the point.

Naloxone kit information.

I’m reminded of all the people that have been dying on the Crackdown podcast.

If you’ve not heard it, Crackdown is a ground level opinion show about people in the drug crisis from the perspective of drug users. Listening to it puts a human spin on the reporting through other channels. I recommend giving it a go.

I hear about people dying of opioid overdose. About the toxic drug supply. About mental health crisis. I drive through Hastings and Main regularly on my way to and from work. I see the effects in Vancouver and Maple Ridge. I see the people hiding from the weather between cars in the Bay Parkade. I just couldn’t understand how this problem was self sustaining.

That one quote, “you’re really not going to be able to kill your way out of this.” summed everything up for me. We having been expecting the problem to go away, because eventually we had to run out of people who would become addicted to opioids. This one will not go away on its own. It’s been going for 25 years. Half my life. And it’s only getting worse.

Imagine a mixture between Necromancer and Tales from the Loop as a regular podcast. Yes, AI has taken over the world, but what if they only wanted to make everyone happy? And what if happy was a relative term that meant other people couldn’t operate correctly in the world at all?

The Program tells a series of tales which are interwoven, but are individual on their own. They share a common idea of post singularity, AI run are real and run everything, and have a common thread running through them, like the algorithms, but there is no agreement that they are part of the same universe. In fact in at least one case it’s confirmed that the story is being told from a simulation of reality.

One of the key elements of the franchise in recent games is the mixture of 50’s nostalgia and music. Several key product design exist in the world that are specific to the story. Nuka cola is a great example. Imagine a Coke/Pespi brand that uses the image of a rocket and impending nuclear holocaust as it’s core. These elements were central to creating a central world story.

The TV show borrows heavily from this. So much so that I felt like the first two episodes were just spot the reference games. It wasn’t until the end of the second episode and into the third that it settled down and started telling it’s own story.

In general, if you like the games. You will like the show. Otherwise, fans of SyFi style lite character based stories will find a fun introduction to the world.

Godzilla x King Kong: The New Empire was just what you would expect, a straight up monster movie. Lots of monster fights and things flying everywhere. It’s great how they have kept the feel of the rubber suits while making it modern. At no point does this movie take itself too seriously. Just sit back and enjoy the fine cheese.

I will say that this has made me interested in the reboot of Godzilla. I had been avoiding it, thinking myself a Godzilla purist. I think I need to revisit that stance and give the series a chance.

Dune 2. Wow, what a movie. It’s amazing how they took the disjointed scenes from the book and sewed them together in the movie. It still just a bunch of vignettes, stretched across time as Paul gathers his power base. It’s almost a montage sequence. But it’s shown together in such a way to make it clear what’s happening and give you a view into the mind of the characters.

I took my daughter to the Twilight Drive-in. Looks like it might be the last movies we go see there. At the end of the season they are shutting down. It’s just not profitable, and taxes for the value of the land are hurting them. Sad to see. Drive-ins are something that I grew up with, but peoples tastes have changed. The Twilight was mostly full, not the fullest I’ve seen it in the 20-years I’ve been going, but enough that there were only a few spot very near or far from the screen left. It’s hard to see things like this getting priced out of existence.

If you are in the Vancouver are, I recommend trying to get out to the Twilight one last time. I think you will enjoy it.

The story follows Paxton Arés who was injured in a surprise global attack on all militaries. Paxton has reenlisted as an Androne pilot. Androne are a portmanteau of android and drone. Think long distance battle bots, a favourite genre of mine. 😏

While you may try to guess who the enemy are in this story, I would bet it’s not you first, second, or maybe even your third guess.

If you are interested at all in future warfare, drone warfare, robot battles, I would recommend this as a book to read. I’ve already pre-ordered the sequel.

The character cast starts small with three main characters and one newly dead character. Which is good because the podcast creator, Jared Carter, does all of the voice work himself.

I recommend Desert Skies as a fun, but thought provoking romp through the hereafter. The first season is complete and the second is planned for 2024.

My template uses a three column layout. In the left hand column, I have a set of a few questions I ask myself in the morning to get myself centered. The right hand column are for details and questions that I address at the end of the day. I leave most of the center open for notes.

To start my day I take the question I thought of the day before and put it in the top left of the page. Often I have already a kernel of an answer after sleeping on it. I then take a moment to focus on gratitude (not everyone’s cup of tea, but important for my mental well being). Next I outline what a good day would look like. I try to really look for a positive outcome, but often just settle for a non-crappy one. Then I outline the one thing I need to get done for the day. It’s too easy for me to get caught up in the moment to moment issues, this makes it easy for me to see at a glance what I’ve decided must be done.

At the end of the day I take time to capture my accomplishments, as it’s important to recognize progress. Then I take stock of my feelings. Often there is something reoccuring that can only be noticed if you write it down and see it repeated. Then I document the things I read, and I read a lot. And, as a balance to the how to make things great I have how it could have been better.

I try to document three good decisions. It’s important as a person in a leadership position to be making good decision. This doesn’t mean they have to come completely from you. Often, good decisions come from hearing what others are trying to tell you. This is a chance for me to review my actions and make sure I’m on the right track. If I identify anything here that needs to be fixed, it’s easier to address it the next day, rather than days/weeks/months later.

Finally, I set out the question that needs to be answered.

I don’t follow this religiously, but I’ve found that these sets of questions, regularly observed, help me stay on track. What do you do for taking notes? What questions do you regularly ask yourself?

A PDF template can be downloaded here.

One thing is I want to get back into drawing, specifically comics. I had started to draw comics a few years ago before my daughters were born, but dropped it in favour of being a dad. Now they are at an age where they don’t always need me around. This gives me a little more time. Expect to see more visual art as part of my work.

All over the news is the move to public domain of Steamboat Willie. I’ve grown in the time where it seemed that this was never going to happen. having this content move into public domain seemed so far away, and was always moved further still. Disney just owned everything, and they were going to ensure that keeping that locked up would go forever. When I briefly went to work for Disney on Tron: Evolution, one of the things that you are shown is an orientation video about how Disney wants to continue to make content that spans the world. At one point in the video they talk about a Planet Disney. Even showing a Fifth Element like space liner and a Mickey Mouse eared satellite (mandella effect?). I’m not 100% sure that this is an allegory. Given the chance they would terraform a planet to turn into the next Disney World.

But now, here we are. I hope to see a lot of great new works created because we finally allowing more works to pass into the public domain. Not just derivative works, but new ideas. If you’ve not seen it check out Tom the Dancing Bug for Jan 1, 2024

And, of course, I can’t let the opportunity go by.

Let’s not stop at Steamboat Willie

Sure, let's break down the "Create a Docker container for running your
application" task into a step-by-step plan, which we'll refer to as
the "Create Docker Container Plan":

1. **Prepare Your Application:**
   - Ensure your application is ready for containerization. It should
     be in a directory with all necessary files and dependencies.

2. **Install Docker:**
   - Make sure Docker is installed on your laptop. You can download
     and install Docker Desktop for Windows or macOS, or Docker Engine
     for Linux.

3. **Write a Dockerfile:**
   - Create a `Dockerfile` in the root directory of your
     application. The `Dockerfile` is a text file that contains
     instructions to build the Docker image for your application.

4. **Choose a Base Image:**
   - Decide on a suitable base image for your application. This image
     will provide the foundation for your Docker container. Common
     choices include official language-specific images (e.g., Python,
     Node.js) or lightweight Alpine Linux images.

5. **Copy Application Files:**
   - Use the `COPY` instruction in your `Dockerfile` to copy your
     application files from the local directory to the Docker image.

6. **Install Dependencies:**
   - If your application has any dependencies, use the appropriate
     package manager in your `Dockerfile` (e.g., `pip`, `npm`, `yarn`)
     to install them inside the Docker image.

7. **Expose Ports (if needed):**
   - If your application needs to listen on specific ports for
     communication, use the `EXPOSE` instruction in your `Dockerfile`
     to specify the port(s) to be exposed.

8. **Set the Startup Command:**
   - Use the `CMD` or `ENTRYPOINT` instruction in your `Dockerfile` to
     specify the command that will run when the container starts. This
     command should start your application.

9. **Build the Docker Image:**
   - Open a terminal or command prompt, navigate to your application's
	 directory, and run the command to build the Docker image using
	 the `Dockerfile`. For example:
     
     docker build -t your-image-name .
     
10. **Verify the Docker Image:**
    - After the image is built, verify that it includes all the
      necessary files and dependencies by running a new container
      based on this image locally.

11. **Test Your Application:**
    - Launch a container from the built image and verify that your
      application runs as expected within the container.

12. **Push the Docker Image (Optional):**
    - If you have a Docker Hub account (or any other container
      registry), you can push your Docker image to the registry so
      that it can be accessed and deployed on other systems.

With the "Create Docker Container Plan," you can containerize your
application, making it easier to run consistently on different
environments, including your Digital Ocean instance. Each step
provides incremental progress towards successfully building and
deploying your Docker container.

This makes sense, however I don’t have an application. These steps only tell me how to package it together into a Docker container. I think I need to ask ChatGPT to build this application for me now. I need more details for the first step of the Create Docker Container Plan. Please provide me with a simple Python based application using Flask that will respond to a deep health check request. It will respond with JSON if the application is healthy.

Sure! Here's a simple Python-based application using Flask that will
respond to a deep health check request with JSON if the application is
healthy:

1. **Prepare Your Application:**

First, create a new directory for your Flask application and navigate
to it in your terminal.

2. **Create a Python File:**

Create a new Python file (e.g., `app.py`) in the directory you just
created.

3. **Install Flask:**

Make sure you have Flask installed in your Python environment. If you
don't have it installed, you can install it using `pip`:

pip install Flask

4. **Write the Flask Application:**

In the `app.py` file, add the following code to create a Flask
application:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

@app.route('/health')
def health_check():
    # Perform health check logic here (e.g., check database connection, dependencies, etc.)
    # If the application is healthy, respond with a JSON indicating its health status.
    health_status = {
        "status": "healthy",
        "message": "Application is running smoothly."
    }
    return jsonify(health_status)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

5. **Run the Flask Application:**

To test the Flask application locally, run the following command in
your terminal:

python app.py

This will start the Flask development server, and you can access your
application at `http://localhost:5000/`.

6. **Deep Health Check Request:**

To perform a deep health check on your Flask application, you can make
an HTTP GET request to the `/health` endpoint:

curl http://localhost:5000/health

You should receive a JSON response indicating that the application is
healthy, like this:

{
    "status": "healthy",
    "message": "Application is running smoothly."
}

This simple Flask application responds to the `/health` endpoint with
a JSON message when the application is healthy. You can modify the
`health_check` function to add more complex health checks based on
your application's requirements, such as checking database
connections, external service dependencies, or other critical
components.

This looks reasonable except for the fact that I think that using a virtual env would be best. Modify this task list to add the use of a virtual env to make working with Python easier.

Absolutely! Using a virtual environment is a good practice in Python
development to manage dependencies and keep your project
isolated. Here's the updated "Create Docker Container Plan" with the
addition of setting up a virtual environment:

1. **Prepare Your Application:**
   - Create a new directory for your Flask application and navigate to
     it in your terminal.

2. **Set Up a Virtual Environment:**
   - Create a virtual environment within your application directory to
     manage Python dependencies.

   On macOS/Linux:

   python3 -m venv venv
   source venv/bin/activate

   On Windows:

   python -m venv venv
   venv\Scripts\activate

3. **Install Flask and Dependencies:**
   - With the virtual environment activated, install Flask and any
     other required dependencies using `pip`.

   pip install Flask

4. **Create a Python File:**
   - Create a new Python file (e.g., `app.py`) in the application
     directory.

5. **Write the Flask Application:**
   - In the `app.py` file, add the Python code to create a Flask
     application.

6. **Run the Flask Application:**
   - Test the Flask application locally with the virtual environment
     activated.

   python app.py

7. **Deep Health Check Request:**
   - Perform a deep health check on your Flask application by making
     an HTTP GET request to the `/health` endpoint.

   curl http://localhost:5000/health

   You should receive a JSON response indicating that the application
   is healthy.

8. **Dockerize the Application:**
   - Write a `Dockerfile` in the root directory of your application to
     containerize the Flask application.

9. **Build the Docker Image:**
   - Open a terminal or command prompt, navigate to your application's
     directory, and build the Docker image using the `Dockerfile`.

   docker build -t your-image-name .

10. **Verify the Docker Image:**
    - After the image is built, verify that it includes all the
      necessary files and dependencies by running a new container
      based on this image locally.

11. **Test Your Application in the Docker Container:**
    - Launch a container from the built image and verify that your
      application runs as expected within the container.

12. **Push the Docker Image (Optional):**
    - If you have a Docker Hub account (or any other container
      registry), you can push your Docker image to the registry so
      that it can be accessed and deployed on other systems.

By using a virtual environment, you can manage Python dependencies
separately for each project, ensuring that the required packages are
isolated and don't interfere with other projects on your laptop. This
approach enhances the reproducibility and maintainability of your
Python applications.

This is a step better but still misses the critical piece of information – what is the application code. What are the contents of the app.py file in step 5?

Apologies for the oversight in my previous responses. In Step 5, the
`app.py` file should contain the code for your Flask application,
including the routes for the root (`/`) and health (`/health`)
endpoints. Here's the correct content of the `app.py` file:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

@app.route('/health')
def health_check():
    # Perform health check logic here (e.g., check database connection, dependencies, etc.)
    # If the application is healthy, respond with a JSON indicating its health status.
    health_status = {
        "status": "healthy",
        "message": "Application is running smoothly."
    }
    return jsonify(health_status)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

This code sets up a basic Flask application with two routes:

1. The `'/'` route responds with the string `'Hello, World!'` when
   accessed. You can customize this route to handle other requests or
   render HTML templates for more complex applications.

2. The `'/health'` route handles the deep health check request. In
   this example, it responds with a JSON message indicating that the
   application is healthy. You can add more complex health check logic
   to this route, depending on your application's needs.

Please use this updated content for your `app.py` file when working on
Step 5 of the "Create Docker Container Plan."

This is working. The application works as you would expect. Now, what are the contents of the Dockerfile in Step 8?

Sure! In Step 8, the `Dockerfile` is used to define the instructions
for building the Docker image for your Flask application. Here's the
content of the `Dockerfile`:

# Use a base image with Python installed
FROM python:3.9-slim

# Set the working directory inside the container
WORKDIR /app

# Copy the application files to the container's working directory
COPY app.py /app/app.py

# Install Flask and any other required dependencies
RUN pip install Flask

# Expose port 5000 (the same port we specified in app.py)
EXPOSE 5000

# Set the startup command to run the Flask application
CMD ["python", "app.py"]

Explanation of the Dockerfile contents:

- `FROM python:3.9-slim`: This line specifies the base image to use
  for building your Docker image. We're using the official Python 3.9
  slim image as our base, which includes only essential packages to
  minimize the image size.

- `WORKDIR /app`: This sets the working directory inside the container
  to `/app`. This is where our application code will be copied.

- `COPY app.py /app/app.py`: This line copies the `app.py` file from
  the current directory (where the Dockerfile resides) to the `/app`
  directory inside the container.

- `RUN pip install Flask`: This command installs Flask and any other
  required dependencies inside the container. It's good practice to
  separate the installation of dependencies from copying the
  application code to leverage Docker's layer caching for faster
  builds.

- `EXPOSE 5000`: This line exposes port 5000, which is the port our
  Flask application will be running on. This is necessary so that
  external services can communicate with the application running in
  the container.

- `CMD ["python", "app.py"]`: This specifies the command that will be
  executed when the container starts. In this case, it runs the
  `app.py` file using the Python interpreter, which will start the
  Flask application.

With this Dockerfile, you can now build a Docker image containing your
Flask application using the `docker build` command as mentioned in
Step 9 of the "Create Docker Container Plan."

Continuing I build the Docker image. But I don’t want to have to remember the magic sauce so I write a quick build script.

#!/bin/sh
set -ex
docker build -t manager-blind-spot-application-server .

This quickly builds the Docker image for me. Then I can run the Docker image. I’m trying to think like someone who’s never done this before and so I ask ChatGPT. How do I run the docker image your-image-name?

To run the Docker image you built with the tag `your-image-name`, you can use the `docker run` command. Here's the command to run the Docker image:

docker run -p 5000:5000 your-image-name

Let's break down the options used in the `docker run` command:

- `-p 5000:5000`: This option maps port 5000 from the container to
  port 5000 on your host machine. This is necessary to access your
  Flask application running inside the container.

- `your-image-name`: Replace this with the actual name you gave to
  your Docker image when you built it. For example, if you used
  `docker build -t my-flask-app .`, then the image name would be
  `my-flask-app`.

After running the `docker run` command, your Flask application will be
running inside the Docker container. You can access it from your host
machine by visiting `http://localhost:5000/` in your web browser.

Keep in mind that if your Flask application needs to access any
external resources, such as a database or other services, you might
need to set up additional networking options or environment variables
to connect to those resources from within the container. But for a
basic Flask application, the above command should work fine to run it
in the Docker container.

One thing to notice is that ChatGPT is very verbose. This would be helpful for people that have little experience. Not sure I like it but that’s not the point of this exercise. Again, I want to write all of this down so that tired me six months from now doesn’t need to remember anything. So I write a run script. One thing to note is I’ve named my application manager-blind-spot-application-server.

There is a problem with ChatGPT’s response, I want the image to run disconnected. I didn’t ask for that but I would have liked ChatGPT to catch the context. I add the -d option.

#!/bin/sh
set -ex
docker run -d -p 5000:5000 manager-blind-spot-application-server

The next step is to push the image to a repository. It will be a little expensive once I get past a single image but for now I’ll use Digital Ocean.

docker login registry.digitalocean.com
docker tag manager-blind-spot-application-server:latest registry.digitalocean.com/manager-blind-spot/application-server:latest
docker push registry.digitalocean.com/manager-blind-spot/application-server:latest

And then I need to change how I create the image. I need to login to my container repository, pull the image, and launch it. The new script looks like this.

import digitalocean
import os
from time import sleep

# Set up your Digital Ocean API token
api_token = os.environ.get('DIGITALOCEAN_APIKEY')

# Create a Droplet instance
manager = digitalocean.Manager(token=api_token)

# Get the SSH keys
sshKeys = manager.get_all_sshkeys()

# Define the Cloud-Init script
cloudConfig = f'''
#cloud-config

packages:
  - docker.io

# create the docker group
groups:
  - docker

# Add default auto created user to docker group
system_info:
  default_user:
    groups: [docker]

runcmd:
  - 'docker login --username "{api_token}" --password "{api_token}" registry.digitalocean.com'
  - 'docker pull registry.digitalocean.com/manager-blind-spot/application-server:latest'
  - 'docker run -d -p 80:5000 registry.digitalocean.com/manager-blind-spot/application-server:latest'
'''

# Define the parameters for creating the droplet
droplet_params = {
    'name': 'ubuntu-s-1vcpu-1gb-tor1-01',  # Set your desired droplet name
    'region': 'tor1',  # Set your desired region
    'size': 's-1vcpu-1gb',  # Set the droplet size
    'image': 'ubuntu-22-04-x64',  # Set the droplet image
    'ssh_keys': sshKeys,  # Set the droplet SSH keys
    'backups': False,
    'ipv6': False,
    'user_data': None,
    'private_networking': None,
    'volumes': None,
    'user_data': cloudConfig
}

# Create the droplet
droplet = digitalocean.Droplet(token=api_token, **droplet_params)
droplet.create()

print(f"Waiting for droplet to become active...")
while True:
    droplet.load()
    print(droplet.status)
    if droplet.status == "active":
        break
    sleep(10)

print(f"Created droplet with ID: {droplet.id}")
print(f"Droplet IP: {droplet.networks['v4'][0]['ip_address']}")

Launching the instance is the same, and the result is that I can now check the health of the service.

 curl 137.184.172.82/health
{"message":"Application is running smoothly.","status":"healthy"}