What You'll Need

Note: the following links are affiliate links to the products I actually used (or an inexpensive alternative). You probably already have most of these at your home!

• J1 Phillips-head
• T9 or TR9 Torx Bit
• A jimmy tool
• Needle-nose pliers
• 90-degree or stubby Phillips-head
• Replacement rollers
• A work surface twice the size of the Cricut
• 2+ hours of time

Optionally, it will be helpful to have magnetic screw storage so during the disassembly you can stay organized. You might find some glasses (for magnification and safety), some 90%+ IPA (or another cleaning agent), and something for a headache as well.

Remove The Shell

The Cover

Open the lid and using a jimmy tool (or flat-head screwdriver), pry up the plastic strip

Use the jimmy tool to pry this up. It is held in place by tension and some plastic nubs. Go slow, don’t muscle it or you might break them off.

Once you have them off you’ll see four screws with a torx head. These are holding the lid onto the body. Remove them.

With the screws removed the lid will now lift off. It is held in place by those four screws and some alignment tabs. Just carefully lift it up - it will come out easily.

Bottom Screws

Now we need to remove the 4 bottom screws that are hidden underneath the rubber feet.

Using the jimmy tool (or a screwdriver), gently remove the four feet (they are not glued down - just a tension fit). Under each foot is a Phillips-head screw. Go ahead and remove those.

Do not try to remove the top yet! It’s about to get annoying.

The Interior Screws

There are several more screws that need to be removed - the problem is that they are not visible from the outside. You will need to experiment with whatever angles work best for you (especially if you have large hands). You will need a 90-degree screwdriver or a very small stubby one. A magnetic one will make this much easier (mine was not).

The screws are inside the cutting bay at vaguely the locations shown.

Here are some of them - they are not all easy (or even possible) to see. You might need to use your fingers to find a few and you will need to move the cutting head as it will cover at least once no matter where it is.

Remove the Lid (SLOWLY!)

When you have all three of these steps done, the white shell will lift off the base but you need to go slow. The buttons on the lid are connected via a ribbon cable to the base - if you yank too hard you might break the cables. There is enough slack that you can lay the lid to the side or behind the unit. You do not need to disconnect any wiring for any part of this repair.

Remove the Bar

With the lid removed it’s time to get the bar out.

Right Side

First, use your needle-nose pliers to remove the spring. Grasp it at the top and lift it up to unhook it from the frame. It will take some strength. Just be careful not to let it go flying.

When the spring is removed the bracket can now move up and down a little but you can’t remove it yet. There is an e-clip holding it in place (and a flange behind that - we’ll be taking that off too but it’s easy).

Removing this e-clip can be done pretty easily or it might be really hard. It kind of depends on what tools you have. If you have snap-ring pliers with the right size head maybe you can just get at it in 5 seconds. If you, like me, do not - it might take a little longer.

E-clips have a large opening (this is to get it on and off) and two small holes on the opposite side. What you want to do is get the tip of your needle-nose pliers into one of those small holes and carefully (slowly!) pry it off the bar. It will come easily - you don’t need a lot of force - but it may take several tries.

If you lose the e-clip it is a 3/16” e-clip and you can get them from your local hardware store.

With the clip and spring removed the bracket can now slide off. There is a flange in the bracket - as you take it off just leave it be. It will come out (you want that) but you don’t need to do anything with it (just don’t lose it).

Left Side

OK - now we need to do the same thing on the left side. Now don’t get mad at me - I’m just delivering the message.

The right side was the easy-mode version of what we’re about to do. But it’s OK - we’ll get there :)

First we need to get that motor out of the way.

• Remove the two silver screws
• Remove the two black screws
• Lift the motor bracket out of the way
• Lift the motor out of the way
• Try not to touch the sticky mess over and over

Now with the motor removed you can see a large white gear and the spring (there is more than one on this side - make sure you remove the right one).

You should notice that the same spring and bracket configuration are on this side - but that dang gear is in front of them.

• Remove the spring
• Notice the gear can slide in and out a little but cannot be removed because there is a part blocking it.

• Remove the e-clip. You’ll need to go slow and don’t put much pressure on the gear. It will slide out far enough to allow you to get needle-nose pliers in there. You’ll get it. Be super careful not to drop it or it might get lost in the body. But if you do … just buy a 3/16 e-clip and move on (make sure it’s not in the gear, though, it would ruin that).

That was the hardest part of the whole repair.

I’m proud of you!

Lift it Out

Now let’s get the bar out. With the e-clip removed you can slide the bar out but it doesn’t slide much.

Go back to the right side of the machine and slide the bar out about 3/4 of an inch - as far as it will go. You’ll need to give it a little push and might need to lift it slightly.

When it’s like this it is now free from the left side. So go back to the left side and gently lift the bar up and you can find an angle where it clears the body and can be fully removed.

Notice that the bar is not symmetrical. The left side has a single nub and the right side has multiple levels. Just keep that in mind when you put it back in.

Replace the Rollers

I was so excited to be at this spot that I forgot to take pictures - but this is the easiest part!

Using the needle-nose pliers, grip one of the black rollers and stretch it a little. Now slide it off the bar.

Do the same on the other side (replace both!)

Make sure you leave the white plastic rollers on the bar. They can slide around - you’ll adjust them later.

Now go to your kitchen and get a cup of water in a measuring cup or coffee mug - whatever. Put it in the microwave until it just starts bubbling. You don’t want it boiling - 170°F (77°C) is fine.

Once the water is hot put the new rollers in the water and let them sit for a minute or two to heat up.

Carefully remove one with a spoon and slide it onto the bar so it settles in the groove. Repeat for the other side. Don’t use any lubrication or stretch them out. If they are heated enough they will slide on with some force.

Now Do it All In Reverse

OK - we’re officially halfway done!

Doing it all in reverse is all pretty straightforward but a few pieces of advice.

• When putting the e-clips back on, start on the left side. Like before, you need to work around the gear. Basically you want to slide it onto the bar after the flange - there is a slight groove in it. I found it easiest to get it seated with my finger and then push on it gently with needle-nose pliers. Go slow and don’t drop it.
• When putting the right-side clip on you might need to push the flange to get enough spacing for the e-clip.
• Remember the silver screws go on the left side and the black screws go on the right and hold the motor bracket down.
• When putting the body back on, pay attention to how everything is lining up. The back of the body has alignment grooves you need to get lined up correctly. Once you get those interior screws in you don’t want to realize there is an issue and have to remove them (ask me how I know!)
• Make sure you don’t have any leftover screws.
• Give the whole thing a wipe down with some IPA and a paper towel - you probably transferred some grease around.

You did it!

Final Check

With everything reassembled, now is a good time to do a quick sanity check.

First, feed a cutting mat with some paper on it into the machine. You should be able to load and unload without any issues. The rubber wheels should be staying in place and gripping the mat correctly.

Next, create a simple design in Design Studio and sent it to be cut. Again, watch the rollers for any sign that something is wrong. They should not be “walking” around and should be properly gripping the mat.

If everything looks good - great! If not - start debugging! I’m confident you’ll figure it out.

Why You Want This

Printing via the Anycubic Neo is a little bit of a pain. Sure, you can connect a USB cable to a nearby PC and use Cura, but this means you need to have your printer near your computer and it makes it quite a bit more difficult to monitor or send jobs remotely.

OctoPi solves these problems by having a service that can run on a USB-powered Raspberry Pi device (the size of a deck of cards) that you can install right with the printer and now manage the printer remotely with a suite of plugins that don’t just make management easier but can actually improve the quality of your prints.

How Hard is This?

This is probably 3/10 on the difficulty scale. All you need is the hardware (described below), a computer (to configure the pi and run your slicer - Cura in this document), and about an hour of time.

What You Need to Buy (if you don't have it)

There are a lot of options but if you want a specific recomendations, this is what I am using:

• Raspberry Pi 4 Model B (2GB)
• USB-c Power Supply (5v) (you cannot power the pi off the Neo’s USB port as that is needed for the data connection)
• USB Type A to Type C cable. This cable must support data transfer and not just charging as this will connect the pi to the printer.
• 32GB microSDHC Card (DOS format)
• MicroSD Reader - USB-A adaptor, USB-C adaptor. The Neo came with one so you might not need this.
• (Optional) USB-A Web Camera. If you have a spare USB web cam, there is a good chance it will already work with Raspberry PI. I’m using a Logi 925e Business Webcam.
• (Optional) Micro-HDMI to HDMI cable. Not needed for setup, but a nice-to-have if you ever need to connect a monitor.

Installing OctoPi

The steps to install OctoPi are:

1. Insert the microSD card into the adpator and plug into your computer.
2. If the card is not already FAT32 formatted, use the Windows drive format tool to format as FAT32.
3. Download the Raspberry Pi Imager for your platform (I’m on Windows).
4. Install the imager application.
5. Run the imager application
6. Click “CHOOSE OS”
7. Scroll down to “other specific-purpose OS”
8. Choose “3D printing”
9. Choose “OctoPi”
10. Choose “OptoPi (stable)” (this should bring you back to the main screen)
11. Click “CHOOSE STORAGE”
12. Choose your USB device that has the micro SD card (make sure you get the right device - this WILL overwrite your drive)
13. Click “NEXT”
14. On the “Use OS customization” window, click “EDIT SETTINGS”
15. Set the hostname (this will be the name of the raspberry pi on your network) - you need to remember this!
16. Set the username to “pi” and set a password
17. Configure the wireless LAN with your wifi details
18. Optionally, set the locale settings
19. Switch to the “SERVICES” tab
20. Click “Enable SSH” and select “Use password authentication”
21. Click “SAVE” (this returns you to the “USe OS customization? window)
22. Click “YES”
23. On the Warning dialog, if you are 100% positive you have selected the right driver, click “YES”

At this point the micro SD is being prepared, written to, and verified. This will take a about 5 minutes.

Booting OctoPI

1. Ensure there is not an SD card in the Neo - remove it if there is.
2. Insert the 32GB microSD card into the SD card slot on the bottom of the Raspberry PI board.
3. Insert the USB-A to USB-C cable into a black USB-A port on the Pi.
4. Insert the USB-C end of that cable into the Neo
5. If you have a camera, plug it into a blue USB-A port on the Pi
6. Connect the USB-C power supply to the pi - It will take a few minutes for your pi to boot. Be patient!

Visiting OctoPi

You’ve waited a few minutes and can now visit your OctoPi service on your network. While on the same wifi network you configured the device to use, visit the machine name on your network. Since I named mine “neo” the URL I will visit is http://neo.local

Setting up OctoPi

You should now be looking at the OctoPi setup wizard.

• Click “Next”
• If you are reading this, you’ve probably never setup OctoPi before so you don’t need to restore a previous config. Click “Next”
• On the “Access Control” page you will need to setup an OctoPi admin. This is not the same account you created when creating the image. This is the account you can log into the website OctoPi with. Create a username and password and make sure to remember them!
• Click “Create Account” - when it completes you will get a popup notice letting you know the account is created and you are now logged in as it.
• Click “Next”
• Since you’re connected via wifi, things are probably working but I would suggest clicking on “Test host & port” and “Test name resolution” - both should succeed.
• Click “Enable Connectivity Check” (or don’t - but I suggest it)
• Click Next
• Configuring anonymous usage tracking is totally up to you. Click an option and then click “Next”
• On the “Configure Plugin Blacklist Processing” page, click “Enable Plugin Blacklist Processing” and then click “Next” (or don’t enable it - but I did).
• If you connected a webcam during the hardware setup, at the Webcam and Timelapse Recording page, click the two “Test” buttons to make sure you can see an image from your camera.
• Click “Next”
• On the “Set up your printer profile” page, on the General tabe give your printer a name and model. These are free-form strings. I entered “Neo” for the name and “Anycubic Kobra” for the model.
• Click “print bed & build volume”
• Make sure the following are set:
  • Form Factor: Rectangular
  • Origin: Lower Left
  • Heated Bed: Enabled
  • Heated Chamber: Disabled
  • Width (X): 220
  • Depth (Y): 220
  • Height (Z): 250
  • Custom Bounding box: Disabled
• Click “Axes”
• All the defaults should be fine (6000, 6000, 200, 300)
• Click “Hotend & extruder”
• Nozzle Diameter: 0.4 (unless you have changed your nozzle)
• Number of Extruders: 1
• Default extrusion length: 5
• Click “Next”
• On the “All Done!” page, read and agree to the three points.
• Click “Next” and if prompted, reload.

No printer connection?

If when you get to OctoPi’s main UI, you see this message:

First check that your USB-A to USB-C cable is connected from the pi to the printer and that the printer is on.

Next, try another cable. You are probably using a charge-only cable and not a data-capable one.

Installing Plugins

You can install OctoPi plugins which can not only improve usability of OctoPi, but can actually improve the quality of your prints.

I would suggest the following plugins to get started:

• Themeify
• Simple Emergency Stop
• Resource Monitor
• OctoEverywhere!
• OctoPod

Connecting Your Phone

If you have an iPhone, once you’ve installed OctoEverywhere and OctoPod you can then install the OctoPod app on your iPhone. On an Android you could use OctoEverywhere.

This will allow you to view the web camera remotely (without opening a port on your router), manage your print jobs remotely, and control your printer without having to use the front control panel for many operations.

There are a bunch of possibly tools you could use - experiment with them and see what you like!

Configuring Cura

To get Cura to see OctoPi you need to install the OctoPrint Connection plug-in in Cura. Once you have done that, visit your printer setup page and click “Connect OctoPrint” and setup an API key.

This is documented on this All3DP blog post.

Your First Print

With all of this done - you are ready to use Cura to send a print directly to OctoPrint!

The Neo was occupying too much space on the desk but I had the perfect corner I could stick it into. The only problem was that it needed to be less than 6 inches off the floor so it could tuck under some other things. This ruled out most printer stands and tables that are commonly used (like the Ikea LACK).

So instead, I bought a two-pack of the EVOOMI Back Saver Monitor Stands. These are all-metal monitor stands that are rated for 20kg each and have three adjustable heights: 3.9”, 4.7”, 5.5”. I left it at the base - 3.9”.

The Problem

The main problem was that having them just sitting side-by-side meant that over time they might drift apart and cause a problem. I wanted a simple way to connect them. The simpliest way would have been zip ties. But that would not have bvbeen fun.

Instead I threw together a quick model that press fits into the hex holes spanning the gap between the two units. This locked them tightly together (to the point you can lift one and they both lift staying parallel to each other) and the printer fits over them.

It now all stands at the right height on a stable platform.

Missing All Hardware

When I picked up this printer it was missing all the hardware (screws and washers), half of the tools (hex key and wrench), a calibration tool, the IEC power cord, all paperwork, and the SD card.

The biggest problem was the hardware.

I made my way over to the Anycubic Kobra Neo Wiki where I found the assembly instructions which, thankfully, included the entire packing list. I needed:

• M3x8 (4)
• M4x6 (2)
• M4x16 (2)
• M5x25 (2)
• M5x45 (2)
• M5 spring washer (4)

These should all be socket hex head screws - and these are all available at Home Depot (so was the IEC cable). So I stopped by and about $15 later I had what I needed. Returning home, I performed the assembly and was able to power on the printer.

Connecting via USB

Since I did not have the SD card, I wanted to connect via USB. The printer has a USB-C port but it cannot read a USB drive from it - it seems it can only be used for external control.

I went back to the wiki and found the CH341 driver which I installed on my printer control computer (I have a dedicated mini computer for printer control to keep random software off my personal computer and isolated from the rest of the network).

After installing, I was able to see that it was using COM4 (you can see this in Device Manager in windows - look at the COM ports for the one with CH341 in the name) and now I would connect via Cura and Pronterface.

With this done I sent a test print … and it was horrible.

Printhead way too high (Z offset adjustment)

I should have taken a picture of how bad this was - but you’ll just have to imagine it. The first print was just strings of glop dropped from about 1.5-2mm above the bed. I was printing a 50x50x0.20 test print and it looked like I was just running the extruder randomly while playing with the X/Y controls.

Given my other printer is a P1S, I haven’t actually had to deal with this before so I did a little reading to understand that the problem was Z axis height. This is where the missing SD card is a bit of a pain. Anycubic includes a Z-axis adjustment process in the manual but it requires some pre-loaded gcode on the card. Since I didn’t have that, and they don’t link it on the wiki, I basically tried to recreate the process by hand.

Since the default of 0 was way too high, I started by going to -0.90 and doing 10x10mm test prints at 0.9, 1.0, 1.1, and 1.2. The results were this:

After this I fiddle a bit more and finally ended on -1.14 as my height adjustment and for now it’s fine - I’ll move on to the next steps.

Filament extruding at wrong speed (E-step calibration)

While doing some test prints I noticed there was some under extrusion going on - you can see it above in the z-axis adjustment section.

I decided to do an e-step adjustment to make sure the right amount of filament is coming out. To do this, I followed the process described at all3dp.com.

The following was all done in Pronterface connected to the printer via USB.

1. Send the M503 command to get the settings - this returned (among many other things) this information:

echo:; Steps per unit:
echo: M92 X80.00 Y80.00 Z400.00 E390.00

So we have 390 e-steps per mm of filament.

1. Use a ruler and sharpie to add a line to the filament exactly 120mm above the print head.

2. Send the following:

M83;
M18 S60;
M109 T0 R200; 
G1 E100 F100; 
G4 S90; 
M104 S0; 

Now, this is where things didn’t work. The printer returned an error on the line G1 E100 F100; complaining that the values were out of range.

So I used the UI to set the extrude length to 100, the speed to 100 (this is mm per minute), and then hit the extrude button manually - and that worked fine.

1. Measure and calculate the new value

With that done I measured from the top of print head to my line (it was drawn at 120 but I only sent 100), and found there was a 30mm gap. So it only sent 90 of the 100 I asked for.

Since we saw earlier that there are 390 e-steps per mm - it did exactly 39,000 steps (390 * 100). But it acted like it only did 35100 (390 * 90). So we can now divide 39000 / 90 and we get 433.3.

1. Update the setting

To update the setting I simply send the following gcode:

M92 E433.3
M500

That set the new value to 433.3 and then saved it.

1. Verify

I re-ran the extrusion test by marking the filament at 120mm and then extruding 100mm and this time when I meausured, it was right at 20mm remaining - so I asked for 100 and I got 100.

FYI - Updating the firmware resets Z-axis and e-steps

I updated the firmware from 1.2.8 to 1.3.3 and noticed immediately that z axis was reset to 0 but it took a little more poking to realize that e-steps were also reset from 433 to 390 causing significant under extrusion.

Just something to keep in mind when you update.

Error Message: HMS_WARN_07ff_2000_0002_0004

I have an AMS unit but wanted to print some TPU. While there are situations where TPU can be loaded into the AMS, it was easier (I thought) to just use the rear feeder. So I unhooked the AMS and loaded the TPU. No problem. After the print I went through the unload process, removing the TPU, and then I got this message.

For some people it seems benign - they just reboot the printer and update Bambu Studio to reset the external filament and then everything is great. But for me there was something else going on.

I tried a bunch of stuff (power cycling, hitting “Retry”, even factory resetting the printer) but nothing would convince the printer that it was OK to print with the AMS. It would not even load filament if I did it manually.

To solve this, I loaded PLA in the rear and went through the complete load cycle, extruding until the new filament came out (there was still quite a bit of TPU in there). Then I went through the unload process again and finally I reset the rear filament in Bambu studio.

Once that was done, I was then able to load filament via the AMS and am back to printing.

Why Doesn't it Work?

Over the holidays we made an effort to clean up our family movie collection. Cutting multi-hour videos into smaller chunks, catagorizing by people, renaming from MAH1982983.MPG to something sensible like “Evelyn is Sally Ride.MPG”.

Along the way we noticed there were playback issues that seemed inconsistent across devices. For example some files worked great everywhere

But other videos were less consistent - they partially rendered or only rendered on some platforms

This is obviously some issue where the video or audio codec is incompatible with the player but I didn’t really want to spend any time thinking about it. So decided to bulk convert everything to H.264 MP4’s with a 128bit AAC audio stream.

To do this I used ffmpeg.

Converting a Single File

Here is an example of an ffprobe output for one of the videos that would play audio, but not video, over the FireTV Plex client:

Input #0, mpeg, from 'Evelyn is Sally Ride.MPG':
  Duration: 00:00:33.80, start: 0.110000, bitrate: 2914 kb/s
  Stream #0:0[0x1c0]: Audio: mp2, 32000 Hz, mono, s16p, 64 kb/s
  Stream #0:1[0x1e0]: Video: mpeg1video, yuv420p(tv), 640x480 [SAR 1:1 DAR 4:3], 104857 kb/s, 25 fps, 25 tbr, 90k tbn

To convert this file to something that would play both video and audio, I ran the following command:

ffmpeg -i "Evelyn is Sally Ride.MPG" -c:v libx264 -preset slow -crf 20 -c:a aac -b:a 128k -vf format=yuv420p -movflags +faststart "converted\Evelyn is Sally Ride.mp4"

Which created an file whose ffprobe output is:

Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'Evelyn is Sally Ride.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Lavf59.16.100
  Duration: 00:00:33.84, start: 0.000000, bitrate: 1645 kb/s
  Stream #0:0[0x1](und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(progressive), 640x480 [SAR 1:1 DAR 4:3], 1509 kb/s, 25 fps, 25 tbr, 12800 tbn (default)
    Metadata:
      handler_name    : VideoHandler
      vendor_id       : [0][0][0][0]
  Stream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 32000 Hz, mono, fltp, 129 kb/s (default)
    Metadata:
      handler_name    : SoundHandler
      vendor_id       : [0][0][0][0]

And now when added back to the NAS and synced to Plex, everything works exactly as desired with no noticable change in audio or video quality.

Bulk Converting using ffmpeg

to do this in bulk, I wrote the following batch file:

if not exist converted mkdir converted
if exist converted\temp.mp4 del converted\temp.mp4

for %%I in (*) do (
  if exist "converted\%%~nI.mp4" del "converted\%%~nI.mp4"

  ffmpeg -i "%%I" -c:v libx264 -preset slow -crf 20 -c:a aac -b:a 128k -vf format=yuv420p -movflags +faststart converted\temp.mp4

  move converted\temp.mp4 "converted\%%~nI.mp4"
)

This is pretty straight-forward.

Basically conversion is done for every file in a source folder and a temporary output file is created. Using a temp output file means I can kill the process mid-way through a conversation and I won’t leave a partially rendered artifact in place. Should I have needed to cancel the operation, or if it failed, it would be easier to be able to restart the process and skip things that had already successfully converted.

When it comes to recording training content, I used to just wing it. I’d make the slides from the ideas in my head and when recording I would just say what I thought to say. This ended in a lot of editing, re-recording, more editing, and some disappointments. Over the last decade I’ve learned from others and refined my approach. This is a brief description of what I do today.

Outline and Slides

I start by defining the course outline down to the clip level. This include the clips intention, lesson(s) taught, and estimated length in the course outline. I don’t do any scripting here but I do add notes that I think might be helpful later.

Next, I create the slides for each module using the clip descriptions in the course outline as the guide. By this time I usually have a pretty good idea of the what so it is more a matter of how. This is often the hardest part as I will come up with a pattern to convey an idea that I will reuse throughout the module/course. When I inevitably want to change that pattern, I need to apply the change across a lot of slides. Because of this I try to focus on a single module at first. When I am done with it and the patterns are defined, I can now work on the rest of the modules more easily.

Scripting and Audio

Once I have the slides complete, I begin to write the script for the module going clip by clip. This usually means I am iterating between the script and slides to improve both until I’m happy. It is usually here that I discover how I need to change patterns in the slides (described above).

I watch my word count and think about how many words per minute I speak so that I can confirm my clip lengths are aligned with my estimates in the outline. If they aren’t, I need to decide what to do. Maybe this needs to be two clips, or maybe two clips should be one. Maybe I need to remove details or perhaps I have a little room to go deeper. The most common outcome is that one clip will be a little short and I’ll steal that time for a clip that went a little long.

Next, I record and edit the audio. I record clip-by-clip, snapping my fingers near the mic anytime I make a mistake or want to try something two ways. This makes my waveform really easy to navigate since snaps are visually obvious which allows me to jump between edit points very quickly.

.

I also make sure that anytime I need to make an edit, I don’t try and do it mid-sentence. I repeat at least the whole sentence, and often the whole paragraph. A lot of my mistakes are not the wrong words but the wrong tone or inflection. If I don’t re-record the whole paragraph it can often be obvious a new ending was punched in as inflection isn’t just on a single phrase or word - there is a lead-in to it that I can hear.

At this point I have my audio completely edited.

Recording Slides

I record the slides by playing the audio for the clip and moving through the slides in sync (as close as possible) to the audio. My Camtasia recording will capture both the screen showing the slides and also the audio via the system audio input. You can’t play the audio in Camtasia while recording so you will need to play it in an external tool.

When this is done I have 2 tracks - the slides+system audio and the production audio.

Now I split the slides+system audio into two tracks. Then I slide the production audio to align with the recorded system audio. This will never be perfect but I get it to the point that it sounds like only a single voice is speaking but there’s a weird stereo effect. I will then trim the video recording to align with the start of the audio (there is always a few seconds of me clicking things, starting the slides, etc - but I don’t have the system audio playing until the slides are running correctly).

With those align I will delete the recorded system audio and can now edit the slide recording and production audio together. Since I recorded the slides against this audio, there is usually only minor editing to do and it’s almost always a timing issue.

When I’m happy, I group all the edits into a single group and then render that group.

Recording Demos

I record demos on a virtual machine (Hyper-V). This is really important to me because (a) I want to lock the version of Windows and Visual Studio that I am using and (b) I want to be able to use that virtual machine, in that exact state, if I ever need to make updates to the course. Having to do an edit a year later requires getting everything setup exactly as before - this makes it so much easier. I don’t worry about the VM for the slides.

For demos, I invert the order that I record the audio and video. I get my demo code prepared and think about the major momoents in the demo (changing files, scrolling, editing text, running the program, etc).

When recording the demos I don’t worry about the audio timing at all - what will be a 4 minute demo clip might only be 30 seconds of recorded time. I do focus on:

• Cursor and mouse location. This is critical - you don’t want a cursor just hanging out in the middle of our editor.
• Scrolling. I use the arrow keys and try to click 2 lines per second - during editing I will adjust clip speed to be 5x when scrolling.
• Getting the relevant code centered
• Inputting new text
• Pausing between major moments (scrolling, typing, etc) so that I can use that as an edit point

For text input I use AutoHotKey macros. For example, here is a macro that enters some content with a key delay that feels like a fast, but natural, typing speed.

SetKeyDelay,22,,,

!1::
SendRaw, txt_Contents.Text = txt_Contents.Text.Replace(before, after);
return

With the video recorded, I now use the outline and video to create the script. Sometimes this means I need to go back and re-record something but this usually works. I’ve found it’s easier to record the video than the audio so I bias towards that. When the script is ready I record it using the process I described above.

Next I go through the demo and I cut the video at the major points (see bullet above). I then align those major moments to the appropriate audio and apply the 5x clip speed to any scrolling moments. This leaves me with the audio-aligned-moments and a bunch of gaps that need to be filled. I fill them by extending a single frame over that time (Camtasia and Premiere can do this). It takes some tweaking to make things seem natural. You don’t want a mouse cursor appearing out of nowhere (at least obviously), and transitions (changing source file, etc) need to be considered. But eventually you end up with a demo that feels like you were talking while typing and you are just somehow really good at scrolling.

As before, I now group all the fragments into a clip and I render the clip.

Other Random Advice

My other advice is:

• Create and submit your easiest module first regardless of module order. Get a quick win under your belt.
• Avoid applying any updates (especially major versions) to your tooling during the recording process.
• If you are using Camtasia, save early and save often. It crashes a lot. The latest version really has trouble with rendering between markers. And if you’re using Camtasia on a Mac, it is missing some features Windows has (like batch rendering).
• Don’t forget that the Overview/Summary slide has both words - Overview and Summary - on it. You need to delete the appropriate word depending on the context. I forget every time.

This began yesterday morning when I started reading Understanding the 4 Rules of Simple Design by Corey Haines. On page 9 there is the suggestion to stop and write out your own implementation of Conway’s Game of Life so I paused and did that.

My Objective

I have done very little UI-focused work. My only experience with Javascript is working on Node (and that was limited). I have never worked with jQuery. I know next to nothing about CSS. So I thought I’d start working in that realm.

My goals were:

• Implement a solution that renders in a web browser
• Retain minimimal state
• Use HTML, Javascript and jQuery - nothing else
• Under 200 lines of code (it’s exactly 200 including comments)
• Have something working in under 2 hours

I ultimately met each but backed away from retaining minimal state as part of improving performance.

My Thought Process

I believed the following were true:

1. I could draw a grid dynamically using javascript and CSS
2. I could use some state of the cell to track if it was alive or not
3. I could access the grid in a (row,column) fashion to check neighbor state
4. There must be some mechanism to run events (steps) on a timer
5. I could improve performance as needed (it was needed)

I didn’t know how to do those things so let’s get to it.

The Globals

Heck yeah I used globals. I didn’t know I’d use these all upfront but it’s easier to show them up front since they are sprinkled through the remainder of the code samples.

var initialFillPercent = 0.25;
var fps = 10;
var size = 100

var running = false;   // toggled by the start/pause button
var intervalId = null; // set and cleared by start/pause
var stepCount = 0;     // just used to display the step

// the cells will be in an array where the cell at (row = r, column = c)
// can be found at items[r * size + c]
var items = [];
var toKill = [];
var toBirth = [];

They will be explained below.

Drawing the Grid

My goal here was to figure out how to draw a grid that would fit into the viewable portion of the browser window and resize dynamically.

Where I started was just making a 3x3 of divs like:

<div id="board">
  <div class="row">
      <div class="cell"></div>
      <div class="cell"></div>
      <div class="cell"></div>
  </div>
  <div class="row">
      <div class="cell"></div>
      <div class="cell"></div>
      <div class="cell"></div>
  </div>
  <div class="row">
      <div class="cell"></div>
      <div class="cell"></div>
      <div class="cell"></div>
  </div>
</div>

Then I played around with it.

I’m going to skip over a lot of steps and show you where I ended up. There are three pieces to it.

Grid HTML

I added a wrapper so that I could use it to constrain the overall size of the grid to ensure it stayed within the visible space of the browser window. The animation isn’t fun to look at if you can only see half of it.

I also added a button that can be clicked to start/pause/continue the game and a span that simple displays the step count. These aren’t part of the grid but they are part of the overall UI.

  <div id="wrapper">
    <div>
      <button id="toggle">Start</button>
      <span id="step"></span>
    </div>

    <div id="board">

    </div>
  </div>

Grid CSS

The wrapper uses a width and height of 95vmin (95% of viewport minimum) to ensure that the entire grid will be visible (leaving room for button/step prompt). I learned this technique from a StackOverflow post.

There is one bit of styling (grid-template-columns) which will be set dynamically but I’ve shown it here so that it makes sense. The 100 is because there will be 100 columns per row and each cell will be 1fr (fractional unit) in width. It is the size (100) that is set dynamically based on the size of the grid.

The board’s display mode is grid.

The cells are 1fr in size (see the note about grid-template-columns) and have some coloring applied and the cell:after is used to ensure they are squares. I learned this trick from Bobby Kilpatrick’s post How to Create a Responsive Square with CSS. And I decided that when cells are “live” they would have the .live class and be dark red. Overall, pretty straight forward

#wrapper {
  width: 95vmin;
  height: 95vim;
  margin: auto;
}

  #board {
    display: grid;
    grid-template-columns: repeat(100, 1fr); /* added dynamically */
}

.cell {
    background-color: rgba(255, 255, 255, 0.8);
    border: 1px solid;
    width: 1fr;
}

.cell:after {
  content:  "";
  display:  block;
  padding-bottom: 100%;
}

.cell.live {
  background-color: darkred;
}

Generating the Table (Javascript)

This is my fourth iteration of this approach.

First I had a structure like this.

<div id="board">
  <div class="row" id='r-1'>
      <div class="cell" id='c-1'></div>
      <div class="cell" id='c-2'></div>
      <div class="cell" id='c-3'></div>
  </div>
  <div class="row" id='r-2'>
      <div class="cell" id='c-1'></div>
      <div class="cell" id='c-2'></div>
      <div class="cell" id='c-3'></div>
  </div>
  ...
</div>

I would use multiple jQuery selectors to first find the row div and then I would find it’s child.

Then I simplified to this:

<div id="board">
  <div class="row" id='r-1'>
      <div class="cell" id='r-1c-1'></div>
      <div class="cell" id='r-1c-2'></div>
      <div class="cell" id='r-1c-3'></div>
  </div>
  <div class="row" id='r-2'>
      <div class="cell" id='r-2c-1'></div>
      <div class="cell" id='r-2c-2'></div>
      <div class="cell" id='r-2c-3'></div>
  </div>
  ...
</div>

With this approach I could jump straight to the specific cell I needed by ID.

Then I went to this:

<div id="board">
    <div class="cell" id='r-1c-1'></div>
    <div class="cell" id='r-1c-2'></div>
    <div class="cell" id='r-1c-3'></div>
    <div class="cell" id='r-2c-1'></div>
    <div class="cell" id='r-2c-2'></div>
    <div class="cell" id='r-2c-3'></div>
  ...
</div>

And this was good but still relied on using jQuery selectors. This was part of me trying to retain minimal state but it came at the cost of performance. When I profiled it running for a few seconds it spent almost all of it’s time in hasClass - so I figured it was worth replacing that with something a little more primitive.

Ultimately I created an array of cells named items (see below) which I populated when I created the cells. The first cell (row 0, column 0) was in index 0, the last (e.g., row 100, column 100) was the last index. And any cell could be found like:

var cell = items[row * size + column];

A few notes:

1. the variable size is the number of rows/columns (it’s a square so 100 would be 100x100).
2. markDead (shown below) marks each new cell as dead. Since I need to show markDead, I also have markAlive, and isAlive shown below. The live class is still used for formatting.

$(document).ready(function () {
  createEmptyGrid();
});

function createEmptyGrid() {
  for(var i = 0; i < size * size; i++) {
    var $cell = $("<div />", { class: 'cell'});
    items.push($cell);
    markDead($cell);
    $("#board").append($cell);
  }

    // sets the css to ensure make our grid a square
    $("#board").css("grid-template-columns", "repeat(" + size + ", 1fr)");
}

function isAlive($cell) {
  return $cell.alive == 1;
}

function markAlive($cell) {
  $cell.addClass('live');
  $cell.alive = 1;
}

function markDead($cell) {
  $cell.removeClass('live');
  $cell.alive = 0;  
}

With that done - we know have a 100x100 grid (the size can be changed via the size variable) which looks like this:

The Game Loop

With the board working it was time to build the game.

Step 1: Initial Population

To populate the board I determine the initial fill percentage (e.g., 25% of the cells should be marked alive) and then for each cell that should be alive I pick a random cell and mark it as alive (set the ‘live’ class and set the alive property to 1).

function populateRandom() {
  for(var i = 0; i < (size * size) * initialFillPercent; i++) {
    markAlive(randomCell());
  }
}

function randomInt(max) {
  return Math.floor(Math.random() * max);
}

function cellAt(row, column) {
  return items[row * size + column];
}

function randomCell() {
  return cellAt(randomInt(size), randomInt(size));
}

This method is called from the document.ready callback and gives us an initial board like this:

Step 2: Starting the Game (Clicking Start)

To get this finally going I needed to add a button handler to the document.ready method so that when the Start button is clicked the game starts. It now looks like:

$(document).ready(function () {

  createEmptyGrid();

  populateRandom();

  $("#toggle").click(function() {
    if(!running) {
      start();
    } else {
      pause();
    }
  });
});

The button toggles between “Start”, “Pause”, and “Continue” depending on the running state. The start and pause functions are:

function start() {
  intervalId = setInterval(function() { step(); }, 1000 / fps);
  running = true;
  $("#toggle").html("Pause");
}

function pause() {
  clearInterval(intervalId);
  running = false;
  $("#toggle").html("Continue");  
}

Start creates an interval that runs on a timer (1000 ms / fps = how often to run), sets running to true, and changes the prompt on the button from “Start” to “Pause”.

Pause clears the interval, sets running to false, and changes the button text to “Continue”.

Step 3: Running a Step

The step function is called everytime the interval fires - so let’s look there next:

function step() {
  applyRules();

  processChanges();

  $("#step").html(stepCount++);
}

Step is a two-step process and it needs to be this way to function correctly.

The rules of Conway’s Game of Life require the current cell to live, die, or birth based on the state of neighboring cells so to run you first need to look at each cell and decide if it’s state will change and only once those decisions are made do you apply the changes. If you applied them while looking a the cell, then that change would affect any future cell you checked.

Step 4: Applying the Rules

The rules are pretty simple - look at every cell, figure out how many living neighbors it has, and then decide what to do. The cell is alive 2 or 3 living neighbors, it lives (otherwise it dies). If a cell is dead and has exactly 3 neighbors, it will come to life.

This loop does that. For every row (rows are just a logical concept that make cellAt easier to implement), and for every column in that row:

1. Get the current cell
2. Count it’s living neighbors
3. Apply Conway’s rules
4. If the cell will be kill, push it onto the kill queue
5. If the cell should be birthed, push it onto the birth queue

In a previous iteration of this I used CSS classes to track whether to kill or birth. I have class=toggle-kill and class=toggle-live. Then I’d do:

$('.toggle-kill').removeClass('live');
$('.toggle-kill').removeClass('toggle-kill');
$('.toggle-live').addClass('live');
$('.toggle-live').removeClass('toggle-live');

And this worked but it was pretty slow. It was limited to about 6FPS at 128x128. I moved instead to kill and birth queues (cell arrays).

function applyRules() {
  // We need to figure out what cells live, die, or are born
  // but we don't want to change their state during this loop
  // as that will impact their neighbors
  // Add the cell to an array of items to birth and kill
  // and process them after this (processChanges)
  for(var r = 0; r < size; r++) {
    for(var c = 0; c < size; c++) {
      var $cell = cellAt(r, c);
      var neighbors = livingNeighbors(r, c);

      if(isAlive($cell)) {
        if(neighbors < 2 || neighbors > 3) {
          toKill.push($cell);
        } 
      } else {
        if(neighbors == 3) {
          toBirth.push($cell);
        }
      }
    }
  } 
}

cellAt does the calculation into the items array to find the cell by row and column, and livingNeighbors simply looks at each adjacent cell and checks if it is alive or not and returns the sum of living cells.

function cellAt(row, column) {
  return items[row * size + column];
}

function livingNeighbors(row, column) {
  var count = 0;

  for(var r = row-1; r <= row+1; r++) {
    for(var c = column - 1; c <= column+1; c++) {

      // skip self
      if(r == row && c == column) continue;

      // stay inbounds
      if(r < 0 || c < 0 || r >= size || c >= size) continue;

      var $cell = cellAt(r, c);

      if(isAlive($cell)) count++;
    }
  }

  return count;
}

Step 5: Process Changes

Now that we’ve queued up the kill and birth queues, we just need to process them.

function processChanges() {

  toBirth.forEach(function($cell) { markAlive($cell); });
  toKill.forEach(function($cell) { markDead($cell); });

  toKill = [];
  toBirth = [];
}

Mark them all appropriately and empty the arrays.

Now you just need to load the page, click start, and watch the show.

The Show

And you can try it for yourself here.

I frequently find myself needing to create videos from a series of rendered frames. I have been using ffmpeg to generated mp4’s but it would be nice to be able to create GIF’s - or in this case animated WebP files. The biggest benefits of this are that I don’t need to rely on an external hosting service for the video and that they can be used anywhere an image is used.

To do this I’ll be using img2webp from the Google WebP image format tools.

Creating the Animated WebP File

Say I have a collection of images named in a sortable manner - for example:

frame-001.png    frame-002.png   frame-003.png   ...
...
frame-075.png    frame-076.png   frame-077.png   ...
...
frame-298.png    frame-299.png   frame-300.png

In this case I want to create a 10 second video (30 FPS) with the 300 frames listed above.

The arguments I’ll use are:

img2webp -d 33 -loop 0 frame-* -o gen100.webp

And the output is an animated WebP image file shown here:

Warning: Performance on iOS is Terrible

The following video shows the above animated webp playing on an iPhone XR (iOS 15.4) in Brave with the same experience in Safari. Notice that the performance isn’t just linearly bad - it seems to actually get worse as the image plays.

When I’m creating blog posts that describe a process I like to use headers to seperate the main steps. I use <h2> for my groups and <h3> for sub-topics. So when I recently began using Bryan Braun’s AnchorJS to automatically create linkable anchors, it did not take long for me to want to also add a table of contents based on those anchors.

Using AnchorJS

After looking at a few options I landed on AnchorJS because I wanted something simple that “just worked” and did not require any Jekyll plugins.

I wanted to add the AnchorJS reference right at the end of the body section so I opened _layouts/default.html and added the following before </body>

<script src="https://cdn.jsdelivr.net/npm/anchor-js/anchor.min.js"></script>

Next I added a file named js/anchorjs-toc.js and I added the following content to is:

anchors.options.visible = 'always';
anchors.add('h2, h3');

And in _layouts/default.html I added the following immediately after the anchor.min.js included a moment ago.

<script src="/js/anchorjs-toc.js"></script>

I choose these options because I like the look of always-on link icons and I only wanted these on the h2 and h3 headers. The post/page title in the hero area is the h1 header and h4+ are too granular.

Optional: Disabling Dynamic Content Rendering

Sometimes the header links would render and sometimes they wouldn’t. I set a breakpoint and found that sometimes the content was rendered already (allowing anchorjs to find the headers) and sometimes it wasn’t (so it couldn’t). Assuming it was some lazy rendering thing, I found the _data/settings.yml ajax_loading setting was true so I changed it to false and now it was reliably rendering anchor links correctly.

This is likely only relevant to Jekyll and possibly only to the theme I’m using. Just keep it in mind, though, if your links are not rendering consistently.

Creating the Table of Contents

Using JavaScript to Generate the Content

Now that AnchorJS is installed and working correctly, I followed the jsfiddle template that Bryan created as an example. I copied the functions generatedTableofContents and addNavItem into the js/anchor-toc.js file I created in the previous steps (I did change them slightly - see the note below the code).

I also added a call to generateTableOfContents.

The contents of the file are:

anchors.options.visible = 'always';
anchors.add('h2, h3');
generateTableOfContents(anchors.elements);

// External code for generating a simple dynamic Table of Contents
function generateTableOfContents(els) {
  var anchoredElText,
      anchoredElHref,
      ul = document.createElement('UL');

  document.getElementById('table-of-contents').appendChild(ul);

  for (var i = 0; i < els.length; i++) {
    anchoredElText = els[i].textContent;
    anchoredElHref = els[i].querySelector('.anchorjs-link').getAttribute('href');
    addNavItem(ul, anchoredElHref, anchoredElText, 'toc-li-'.concat(els[i].tagName));
  }
}

function addNavItem(ul, href, text, listClass) {
  var listItem = document.createElement('LI'),
      anchorItem = document.createElement('A'),
      textNode = document.createTextNode(text);
      listItem.className = listClass;
  
  anchorItem.href = href;
  ul.appendChild(listItem);
  listItem.appendChild(anchorItem);
  anchorItem.appendChild(textNode);
}

Please note that I have made two changes to this file.

1. I changed line 16 to pass 'toc-li-'.concat(els[i].tagName) as a fourth parameter to addNavItem. This string will be toc-li-h2 or toc-li-h3 depending on whether we are at an h2 or h3 tag.
2. I added line 24 listItem.className = listClass; to addNavItem

These two changes ensure that the list items for the table of content include different classes for h2 and h3 tags. I’ll be using this information to format them differently.

Creating the Table of Contents Include

Knowing I would want a repeatable ToC, I next added _includes/toc.html which contains the following:

<noscript>
  <style type="text/css">
    #table-of-contents { display:none; }
  </style>
</noscript>

<div id="table-of-contents">
  <div id="toc-header">On this page:</div>
</div>

And this can be included on any page like so:

{% include toc.html %}

Now when page is rendered, the table of contents display - but they are kind of ugly.

Formatting the Table of Contents

To format the table of contents I started with the example here and created the file _scss/_includes/_toc.sccs which included the following:

#table-of-contents {
    float: right;
    background: #f9f9f9 none repeat scroll 0 0;
    border: 1px solid #aaa;
    display: table;
    margin: 20px 1em 1em 1em;
    padding: 10px;
    width: auto;
    max-width: 35%;
}

#toc-header {
    font-weight: 900;
    font-size: 125%;
}

#table-of-contents li, #table-of-contents ul, #table-of-contents ul li{
    list-style: outside none none !important;
}

li.toc-li-H2 {
    margin-left: 1em;    
}

li.toc-li-H3 {
    margin-left: 2em;
    font-size: 85%;
    filter: brightness(2.50);
}

Basically, this creates a box in which the table of contents will exist. It floats that box to the right and applies some margin and padding. Next, I apply some formatting to the “On this page” header. Finally, I use the li’s class (toc-li-h2 or toc-li-h3) to conditionally format the entries to approximate the look of a hierarchy. The h2’s are slightly larger than the h3’s, the h3’s are slightly more indented, and the h3’s are slightly lighter in color.

I also needed to make sure this file was included when the site was built so I added:

@import "_includes/toc"

To css/style.scss.

And this pulled it all together into a table of contents that renders the way I preferred.