I recently made a printable Volvo EX90 Cheat Sheet version of these procedures for easy reference.

Reboot the Center Display (Infotainment)

If the screen is frozen, apps are misbehaving, or the system is laggy:

• Make sure the car is parked and not charging

• Press and hold the play/pause button below the center screen

• Keep holding until the screen goes black and the Volvo logo appears (this can take up to 40 seconds).

Reset the Ultra-Wideband (UWB) Module (fix digital key issues)

The UWB module is responsible for short-range communication used in digital key functionality. If you are unable to add a digital key, or if your iPhone or Android phone fails to lock/unlock the car reliably, or the car doesn’t recognize your proximity, resetting the UWB module can often help. This one is weird but seems to fix most digital key issues:

• Unlock the car and exit - don’t lock it. Stand outside near the driver’s door

• If you use your phone as a digital key, turn off bluetooth or move your phone away from the car. Also move any key tags away from the car

• Tap your finger on the indent on the driver’s door handle and hold for 1 second, then lift your finger

• Repeat this four times (total of 5 1-second taps)

• It will feel useless because there is no response from the car, but it works

• Leave the car untouched for 20 minutes. Do not interact with the vehicle during this time (no door handles, no app interactions, no key fob nearby)

This allows the UWB system to go into standby and reset its internal state. There is no visual confirmation (like a flash or chime) that the reset worked, so it seems like nothing happened, but it fixed my problems with adding a digital key. A few days later, the car stopped acknowledging my phone and required me to use the keycard to drive the car. I did the above procedure and 20 minutes later, it all started working again.

Note - this does not erase your digital key or phone pairing; it only resets the radio communication module.

Central Computer Reset (Full System Reboot)

The HPA is the EX90’s central computing cluster. It handles essential systems including drive functions, ADAS (driver assistance), infotainment communication, and vehicle coordination. If you're seeing odd warnings like “Propulsion System Failure”, “Driver assistance fault”, a blank or frozen screens, or persistent software errors, an HPA reset forces a deeper system-level reboot than a standard display restart. Note that this can only be done once per 24 hours (weird).

• Park the vehicle and keep it on (Ready mode)

• Confirm that the charger is not connected

• Press and hold the brake pedal

• At the same time, press and hold both:

  • “-” (minus button) on the left side of the steering wheel

  • Volume Up on the right side

• Keep holding until you see the message “System Communication Error” on the instrument panel (it will take 10-20 seconds)

• Now, press and hold the PARK button (near the gear selector) for 2 seconds to complete the reset. (There is no immediate feedback other than the screens dim slightly, but after about 60 seconds, things will reset)

• Release everything and wait around 60 seconds for systems to stabilize

• The car will likely show a lot of errors as things come back online. After things settle, you might still have error indicators, but don’t panic yet. Get out of the car, walk away (allows the car to power down), and come back in a few mins and things should be good to go

Note that this does not erase data or require re-pairing of devices.

Oddly, you can only do this once per 24 hour period.

Recently, I started getting an error about the driver assistant system having a fault and all of the driver’s assistance features stopped working. I did the reboot above and it fixed it. As noted above, after the reboot, the fault indicator light was still on (along with some other errors), but it corrected itself after I got out of the car for a few minutes so it could power off.

On another day, the HUD stopped working completely. This procedure fixed it.

Volvo’s docs on this provide some additional context.

Factory Reset (Erase All Data)

To wipe all personal data, settings, keys, and preferences:

• Tap the car icon at the bottom of the center screen

• Go to Settings > System > Reset options > Erase all data (factory reset)

• Only the owner profile can perform this action

This will remove user profiles, paired phones, apps you’ve installed, digital keys, and preferences. Most issues can be fixed without doing a factory reset.

Restore Google Maps and/or Google Assistant if Missing

Earlier today, as my wife and I were switching seats and profiles so she could drive, we noticed that the home screen had no map. It was just a large blank space on the screen. I went to the apps and noticed that both Google Maps and Google Assistant were missing! I did a bit of research and found a quick fix:

• Go to Settings > System > Applications > Show all apps

• Scroll down to Google Maps, tap it, and then enable it

• Repeat for the Google Assistant app

After this, you can run the apps and everything will be normal again.

I have no idea why these were suddenly disabled, but I suspect it’s something to do with Apple CarPlay being active with navigation as we switched profiles.

Fix missing speed limit indicator

If the speed limit has stopped showing on the driver’s display,, this will fix it:

• Go to Settings > System > Applications > Show all apps

• Scroll down to Google Maps, tap it, then tap Storage & cache

• Tap Clear storage and Clear cache

• You will likely have to re-login to Google Maps

Some resets (like the factory reset) require being logged in as the vehicle’s owner.

There is a good Reddit thread on resetting things in the Volvo EX90.

If you learn of any other ways to reboot/reset, please comment below so I can keep this up to date.

The Human Experience of Extreme Acceleration

I’ve always been drawn to cars, roller coasters, and airplanes that can accelerate quickly. The most intense acceleration I've ever experienced was 3.2g in a Decathlon airplane doing a loop during an aerobatic lesson, and it felt like my absolute upper limit. At that point, I could feel the blood struggling to reach my brain, my vision starting to narrow, and my chest compressed by an invisible elephant.

To put this in perspective, when a car accelerates from 0-60 mph in 2.3 seconds, you're experiencing around 1.2g of force—enough to make most passengers uncomfortable. At 2.0 seconds, you're approaching 1.4g. Professional drivers can handle this repeatedly, but for the average person, it's an intense experience that the body isn't accustomed to.

The Physical Limits: Tires, Traction, and Frames

The acceleration we're seeing in modern hypercars isn't just challenging for human bodies—it's pushing the limits of mechanical engineering in several ways:

Tire Traction

The fundamental limit for acceleration is ultimately traction. Modern performance cars produce enough power that they could easily spin their wheels without moving forward if not for advanced traction control systems. Even with the stickiest street-legal compounds, conventional tires on pavement have a coefficient of friction that maxes out around 1.5. This means that without additional downforce, the theoretical limit for acceleration would be around 1.5g or roughly 1.8 seconds from 0-60 mph.

Vehicle Structure

At extreme acceleration levels, the forces exerted on a car's frame are enormous. Every component experiences stress as the vehicle launches forward. For example, drivetrain mounts must withstand thousands of pounds of force without flexing. This is why hypercars often feature carbon fiber monocoques and intricate internal structures—they need to maintain rigidity under these extreme conditions.

The McMurtry Spéirling: Defying Conventional Limits

The most remarkable advancement in acceleration technology today comes from a small British company called McMurtry Automotive. Their Spéirling hypercar has shattered acceleration records with its innovative approach.

According to McMurtry, the Spéirling can zoom from 0-to-60 mph in just 1.4 seconds and cover a quarter-mile in 7.97 seconds. This beats previous production vehicle records by significant margins.

How is this possible? The key innovation is the car's "Downforce-on-Demand" fan system:

The McMurtry Spéirling's unique performance differentiator is its fan-powered downforce system, producing 2,000 kg (4,400 lb) of downforce at a standstill. This incredible technology means the car has massive grip before it even starts moving.

Behind the cockpit are two fans that spin up to 23,000rpm to suck air out from underneath the car, creating more than two tonnes of downforce from standstill—enough so it could theoretically stick to the ceiling with the fans at full speed.

And in fact, it recently did exactly that! In April 2025, McMurtry demonstrated this capability by having the Spéirling drive upside down. The car drove up a ramp onto a metal platform that then rotated 180 degrees, with the fans keeping the car firmly attached to the surface.

This downforce-on-demand system fundamentally changes the acceleration equation. With over two tons of downforce pushing the car into the ground, the effective traction far exceeds what would be possible with just the car's weight and conventional tires. I have to admit, when I saw this video, I immediately wondered what would happen if you made the fans blow the other way! :-)

Other Acceleration Monsters

While the McMurtry Spéirling currently holds the crown, several other production cars offer mind-bending acceleration:

1. Rimac Nevera: 0-60 mph in 1.9 seconds

2. Tesla Model S Plaid: 0-60 mph in 1.99 seconds

3. Bugatti Chiron Super Sport: 0-60 mph in 2.3 seconds

4. Pininfarina Battista: 0-60 mph in 1.79 seconds

5. Aspark Owl: 0-60 mph in 1.69 seconds

What's notable is that most of these ultra-quick cars are electric. The instant torque delivery of electric motors gives them a significant advantage for off-the-line acceleration.

Marques Brownlee got to drive the Rimac Nevera last year. It’s a must watch. He accelerates at the 3 minute mark.

A Historical Perspective: The Evolution of Acceleration

To appreciate how far we've come, let's look back at the acceleration kings of previous decades:

1970s

The 1970s were the tail end of the original muscle car era, but emissions regulations and the oil crisis had begun to strangle performance. The fastest accelerating cars of this era included the Ferrari 512 BB and the Lamborghini Miura P400SV, both capable of impressive speeds for their time. The quickest American muscle cars of the early 70s, like the Hemi 'Cuda and Chevelle SS 454, could manage 0-60 times in the 5.5-6.5 second range—fast for the time but pedestrian by today's standards.

1980s

During the 1980s, the Audi Sport quattro S1 E2 topped the charts with a 0-62 mph acceleration of 3.1 seconds, followed by the Ford RS200 Evolution at 3.8 seconds, and the legendary Porsche 959 at 3.9 seconds.

1990s

The 1990s saw significant improvements with the McLaren F1, Bugatti EB110 S, and Jaguar XJR-15 all achieving 0-62 mph in 3.2 seconds. This decade marked the beginning of the modern hypercar era, with cars designed specifically to push the boundaries of performance.

2000s

The 2000s introduced the first production cars capable of breaking the 3-second barrier. The Bugatti Veyron 16.4 led the pack with a 0-62 mph time of 2.5 seconds, followed by the Bugatti Veyron Grand Sport and Ultima GTR720 at 2.7 seconds.

Each decade has seen roughly a half-second improvement in the acceleration benchmark. But the 2020s have brought a quantum leap, with multiple cars now achieving sub-2-second times—a milestone that seemed physically impossible just a few years ago.

Airplane Acceleration: When Cars Just Can't Compare

While modern hypercars are impressively quick, they're still no match for aircraft when it comes to raw acceleration:

Calculations suggest a fighter jet like the F-22 Raptor with its 70,000 pounds of thrust propelling a 55,000-pound aircraft would achieve 0-60 mph in approximately 2.15 seconds—comparable to the quickest cars. But that's where the comparison ends. Aircraft continue accelerating long after cars have reached their limits.

Even more impressive is the acceleration experienced on an aircraft carrier: A carrier catapult can accelerate a 35,000 kg aircraft to 60 mph in just 0.796 seconds, subjecting pilots to forces so extreme they need special hand rests to avoid knocking themselves unconscious during launch. Yes, there are special hand rests that the pilots need to grab during a carrier launch, because there is a danger that they knock themselves out if they don't have their hands holding on to something.

The Practical Limits

So what are the practical limits of acceleration in production cars? With conventional technology (wheels on pavement), we're probably approaching them at around 1.5-1.7 seconds for 0-60 mph. The laws of physics impose hard constraints on what's possible without additional tricks like downforce-generating fans.

But the more relevant question might be: what are the practical limits for humans? Most people find acceleration beyond 1g to be uncomfortable and disorienting. The sensation of blood rushing from your head, your organs compressing, and your body being pinned to the seat is not something most of us want to experience on our daily commute.

For now, cars like the McMurtry Spéirling remain fascinating engineering exercises and demonstration platforms for technologies that might eventually filter down to more conventional vehicles. They show us what's possible when talented engineers refuse to accept conventional limitations.

Sources used:

1. McMurtry Automotive's official website about the Spéirling Pure electric fan hypercar:

   • https://mcmurtry.com/speirling-pure/

2. Robb Report article about the McMurtry Spéirling becoming the world's fastest production car:

   • https://robbreport.com/motors/cars/mcmurtry-speirling-beat-rimac-neveras-acceleration-records-1234787425/

3. McMurtry Automotive's article about the Spéirling PURE track car:

   • https://mcmurtry.com/the-mcmurtry-speirling-pure-a-record-breaking-track-only-fan-car-you-can-own/

4. McMurtry Spéirling Wikipedia page:

   • https://en.wikipedia.org/wiki/McMurtry_Sp%C3%A9irling

5. Jalopnik article about the McMurtry Spéirling driving upside down:

   • https://www.jalopnik.com/1832203/mcmurty-speirling-drives-upside-down-downforce/

6. Carwow review of the McMurtry Spéirling:

   • https://www.carwow.co.uk/news/6544/mcmurtry-speirling-review

7. Top Gear article about the McMurtry Spéirling driving upside down:

   • https://www.topgear.com/car-news/electric/mcmurtry-speirling-first-car-world-drive-upside-down

8. McMurtry Automotive's press release about the upside-down driving world first:

   • https://mcmurtry.com/upside-down-driving/

9. encyCARpedia data about fastest accelerating cars of the 1980s:

   • https://www.encycarpedia.com/top/best-accelerating-1980s-cars

10. encyCARpedia data about fastest accelerating cars of the 1990s:

    • https://www.encycarpedia.com/top/top-accelerating-1990s-cars

11. encyCARpedia data about fastest accelerating cars of the 2000s:

    • https://www.encycarpedia.com/top/best-accelerating-2000s-cars

12. Information about the fastest cars from the 1970s:

    • https://www.encycarpedia.com/us/top/fastest-1970s-cars

13. TopSpeed article about fastest accelerating reliable used cars from the 1980s:

    • https://www.topspeed.com/fastest-accelerating-reliable-used-cars-from-the-1980s/

14. Aviation Stack Exchange discussion about fastest accelerating aircraft on takeoff:

    • https://aviation.stackexchange.com/questions/35482/what-is-the-fastest-accelerating-aircraft-on-takeoff

15. Executive Flyers article about how fast planes accelerate on the runway:

    • https://executiveflyers.com/how-fast-do-planes-accelerate-on-the-runway/

16. Aviation Stack Exchange discussion about aircraft carrier catapult acceleration:

    • https://aviation.stackexchange.com/questions/45880/what-is-the-0-60mph-time-of-an-aircraft-carrier-catapult

Since our documentation and SDKs are used by nearly every AWS customer, I believe our team needs to be more transparent about what we're working on and how we're prioritizing work to better incorporate your feedback. To that end, I’m going to start blogging about it.

This first post provides an update on AWS Documentation, sharing details about recent content refactoring, website updates, new content types, and a sneak peek at how we're leveraging AI. I'll follow up soon with a similar update about the SDKs and CLI.

The post is on the AWS Insights blog and can be found here.

I also shared it on:

• Reddit

• LinkedIn

• BlueSky

As a fun experiment, I tried the following prompt:

My prompt: I live in San Francisco, CA. Create an icalendar file that creates a non-blocking all-day event for every full moon for the next 12 months. For each, indicate the type of full moon in the title of the event.

Claude responded:

Certainly! I'll create an iCalendar file for you with non-blocking all-day events for the full moons in the next 12 months, including the type of full moon in the title. This will be useful for tracking lunar cycles in San Francisco.

BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Full Moon Calendar//EN
CALSCALE:GREGORIAN
BEGIN:VEVENT
SUMMARY:Wolf Moon (Full Moon)
DTSTART;VALUE=DATE:20240825
DTEND;VALUE=DATE:20240826
DTSTAMP:20240825T000000Z
UID:20240825-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Snow Moon (Full Moon)
DTSTART;VALUE=DATE:20240924
DTEND;VALUE=DATE:20240925
DTSTAMP:20240924T000000Z
UID:20240924-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Hunter's Moon (Full Moon)
DTSTART;VALUE=DATE:20241023
DTEND;VALUE=DATE:20241024
DTSTAMP:20241023T000000Z
UID:20241023-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Beaver Moon (Full Moon)
DTSTART;VALUE=DATE:20241122
DTEND;VALUE=DATE:20241123
DTSTAMP:20241122T000000Z
UID:20241122-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Cold Moon (Full Moon)
DTSTART;VALUE=DATE:20241221
DTEND;VALUE=DATE:20241222
DTSTAMP:20241221T000000Z
UID:20241221-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Wolf Moon (Full Moon)
DTSTART;VALUE=DATE:20250120
DTEND;VALUE=DATE:20250121
DTSTAMP:20250120T000000Z
UID:20250120-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Snow Moon (Full Moon)
DTSTART;VALUE=DATE:20250218
DTEND;VALUE=DATE:20250219
DTSTAMP:20250218T000000Z
UID:20250218-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Worm Moon (Full Moon)
DTSTART;VALUE=DATE:20250320
DTEND;VALUE=DATE:20250321
DTSTAMP:20250320T000000Z
UID:20250320-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Pink Moon (Full Moon)
DTSTART;VALUE=DATE:20250418
DTEND;VALUE=DATE:20250419
DTSTAMP:20250418T000000Z
UID:20250418-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Flower Moon (Full Moon)
DTSTART;VALUE=DATE:20250518
DTEND;VALUE=DATE:20250519
DTSTAMP:20250518T000000Z
UID:20250518-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Strawberry Moon (Full Moon)
DTSTART;VALUE=DATE:20250616
DTEND;VALUE=DATE:20250617
DTSTAMP:20250616T000000Z
UID:20250616-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
BEGIN:VEVENT
SUMMARY:Buck Moon (Full Moon)
DTSTART;VALUE=DATE:20250716
DTEND;VALUE=DATE:20250717
DTSTAMP:20250716T000000Z
UID:20250716-fullmoon@fullmooncalendar.com
TRANSP:TRANSPARENT
END:VEVENT
END:VCALENDAR

I've created an iCalendar file with non-blocking all-day events for the full moons over the next 12 months, starting from today (August 25, 2024). Each event includes the type of full moon in its title. Here's a breakdown of the events:

1. August 25, 2024: Wolf Moon

2. September 24, 2024: Snow Moon

3. October 23, 2024: Hunter's Moon

4. November 22, 2024: Beaver Moon

5. December 21, 2024: Cold Moon

6. January 20, 2025: Wolf Moon

7. February 18, 2025: Snow Moon

8. March 20, 2025: Worm Moon

9. April 18, 2025: Pink Moon

10. May 18, 2025: Flower Moon

11. June 16, 2025: Strawberry Moon

12. July 16, 2025: Buck Moon

You can save this content as a .ics file and import it into your calendar application. The events are set as non-blocking (TRANSP:TRANSPARENT), so they won't interfere with your other scheduled events.

I saved the file as fullmoon.ics and imported it to my Google calendar (go to settings, import/export).

This will also work with ChatGPT, but you need to explicitly ask it to display the contents of the ics file.

I just tried it with Google Gemini with no luck, but I'm sure it will in the future:

I was too lazy to go make 13 entries in Google Calendar, so I decided to see if Claude could help me out:

I first uploaded the jpg to Claude 3.5 Sonnet)...

My prompt: List the dates that are outlined in green

The dates outlined in green in the image are:

Friday, 13-Sep-24 Friday, 27-Sep-24 Friday, 11-Oct-24 Friday, 8-Nov-24 Friday, 6-Dec-24 Friday, 20-Dec-24 Friday, 17-Jan-25 Friday, 31-Jan-25 Friday, 28-Feb-25 Friday, 14-Mar-25 Friday, 11-Apr-25 Friday, 25-Apr-25 Friday, 23-May-25

These dates correspond to the Friday column for students who have their first every-other-week lesson starting the week of Tuesday Sept 10, 2024.

Cool - that was easy and accurate. Now I need to get it into my calendar, so I asked it to create an ics file...

My prompt: Create a calendar ics file that creates an appointment on each of those dates at 2pm pacific time. The appointment title will be “Jazz Piano Lesson”

Certainly. I'll create an ICS (iCalendar) file with appointments for "Jazz Piano Lesson" on each of the dates you specified, set for 2:00 PM Pacific Time.

BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Claude//Jazz Piano Lessons//EN
CALSCALE:GREGORIAN
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20240913T210000Z
DTEND:20240913T220000Z
DTSTAMP:20240824T000000Z
UID:20240913jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20240927T210000Z
DTEND:20240927T220000Z
DTSTAMP:20240824T000000Z
UID:20240927jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20241011T210000Z
DTEND:20241011T220000Z
DTSTAMP:20240824T000000Z
UID:20241011jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20241108T220000Z
DTEND:20241108T230000Z
DTSTAMP:20240824T000000Z
UID:20241108jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20241206T220000Z
DTEND:20241206T230000Z
DTSTAMP:20240824T000000Z
UID:20241206jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20241220T220000Z
DTEND:20241220T230000Z
DTSTAMP:20240824T000000Z
UID:20241220jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250117T220000Z
DTEND:20250117T230000Z
DTSTAMP:20240824T000000Z
UID:20250117jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250131T220000Z
DTEND:20250131T230000Z
DTSTAMP:20240824T000000Z
UID:20250131jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250228T220000Z
DTEND:20250228T230000Z
DTSTAMP:20240824T000000Z
UID:20250228jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250314T210000Z
DTEND:20250314T220000Z
DTSTAMP:20240824T000000Z
UID:20250314jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250411T210000Z
DTEND:20250411T220000Z
DTSTAMP:20240824T000000Z
UID:20250411jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250425T210000Z
DTEND:20250425T220000Z
DTSTAMP:20240824T000000Z
UID:20250425jazzpiano@claude.ai
END:VEVENT
BEGIN:VEVENT
SUMMARY:Jazz Piano Lesson
DTSTART:20250523T210000Z
DTEND:20250523T220000Z
DTSTAMP:20240824T000000Z
UID:20250523jazzpiano@claude.ai
END:VEVENT
END:VCALENDAR

I've created an ICS file with the following details:

1. Each event is titled "Jazz Piano Lesson"

2. The events are scheduled for 2:00 PM Pacific Time on each of the specified dates

3. Each event is set to last for one hour

4. The time zone is properly adjusted to UTC (Z) in the file

5. Unique identifiers (UIDs) are provided for each event

You can save this content as a .ics file and import it into most calendar applications. Here are a few notes about the file:

1. The times are in UTC (Coordinated Universal Time). 2:00 PM Pacific Time translates to 9:00 PM UTC (21:00) for dates not in Daylight Saving Time, and 10:00 PM UTC (22:00) for dates within Daylight Saving Time. The file accounts for these changes.

2. The DTSTAMP for all events is set to the date of this conversation (August 24, 2024) as a placeholder. Your calendar application will likely update this when you import the events.

3. The UID for each event is unique, based on the date of the lesson and a simple string.

To use this file:

1. Copy the content of the artifact

2. Paste it into a new text file

3. Save the file with a .ics extension (e.g., "jazz_piano_lessons.ics")

4. Import this file into your preferred calendar application

Most calendar applications should be able to read this file and create the appropriate recurring events. Let me know if you need any modifications or have any questions!

I went to calendar.google.com, imported the ics, and my appointments were imported perfectly!
(To import ics files into Google calendar, go to the calendar settings, then to import/export)

I'm pleasantly surprised at how easy this was!

I tried the exact same thing in ChatGPT -- it identified the dates in the images, but it said it was was unable to create an .ics file. However, it did give me some Python code to create the ics file for me. I came back to that conversation later and said, "Just show me the content of the .ics file" and it did!

I decided not to delve into the differences in requests-per-minute, tokens-per-minute, tokens-per-day, API cost, etc., as these change frequently and explaining all of this would require significantly more text. Do your research to ensure this is the right path for you. Personally, I encountered the tokens-per-day limit with Anthropic APIs when asking Claude to provide descriptions for thousands of images. Switching to Bedrock allowed me to complete this task in a single run.

1. Installing Required Libraries

First, ensure you have the necessary libraries installed:

pip install anthropic boto3

2. Importing Libraries and Setting Up Clients

Replace your Anthropic imports with AWS SDK for Python (Boto3):

# Old Anthropic import
# from anthropic import Anthropic

# New Amazon Bedrock import
import boto3
import json

Then, set up the Amazon Bedrock client:

# Old Anthropic client setup
# anthropic = Anthropic(api_key="your-api-key")

# New Amazon Bedrock client setup
bedrock_runtime = boto3.client(
    service_name='bedrock-runtime', # see sample code below for how I used Claude 3.5 Sonnet model
    region_name='your-aws-region' # check docs - not all models are available in all regions
)

3. Constructing the Request

The request structure for Amazon Bedrock differs from Anthropic's API. Here's how to adapt your code:

# Old Anthropic request
# response = anthropic.messages.create(
#     model="claude-3-sonnet-20240229",
#     max_tokens=300,
#     temperature=0.7,
#     messages=[
#         {"role": "user", "content": "Your message here"}
#     ]
# )

# New Amazon Bedrock request
request_body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 300,
    "temperature": 0.7,
    "messages": [
        {"role": "user", "content": "Your message here"}
    ]
})

4. Sending the Request and Handling the Response

Now, let's send the request and process the response:

# Send request to Amazon Bedrock
response = bedrock_runtime.invoke_model(
    modelId='anthropic.claude-3-5-sonnet-20240620-v1:0',
    body=request_body
)

# Parse the response
response_body = json.loads(response['body'].read())
generated_text = response_body['content'][0]['text']

print(generated_text)

5. Error Handling

Adapt your error handling to work with Amazon Bedrock:

from botocore.exceptions import ClientError

try:
    response = bedrock_runtime.invoke_model(
        modelId='anthropic.claude-3-5-sonnet-20240620-v1:0',
        body=request_body
    )
    # Process response as shown above
except ClientError as e:
    print(f"An error occurred: {e.response['Error']['Message']}")

6. Key Differences to Note

1. Authentication: Amazon Bedrock uses AWS credentials instead of an API key.

2. Request Structure: Amazon Bedrock requires a JSON string for the request body.

3. Model Specification: The model is specified as a modelId parameter in the invoke_model() call.

4. Response Parsing: The response from Amazon Bedrock needs to be parsed from a JSON structure.

5. Error Handling: Use boto3's ClientError for catching AWS-specific exceptions.

7. Important Considerations for Amazon Bedrock Setup

• Ensure your AWS credentials have the necessary permissions to access Bedrock services.

• Check that the Claude 3.5 Sonnet model (anthropic.claude-3-5-sonnet-20240620-v1:0) is available in your chosen AWS region (it's only in a few as of this writing).

• Verify that your AWS account has been granted access to the Claude 3.5 Sonnet model. If not, you can simply request access through the console and have access in a few minutes.

• The anthropic_version parameter in the request body may need updating based on the latest Bedrock API version.

8. Making it all work

A simple Anthropic API example:

from anthropic import Anthropic
import os

# Set up the Anthropic client
anthropic = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# Define the message
message = "What's the difference between Amazon Aurora and RDS?"

# Send the request to Claude 3.5 Sonnet using the Messages API
response = anthropic.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=300,
    temperature=0.7,
    messages=[
        {"role": "user", "content": message}
    ]
)

# Print the response
print(response.content[0].text)

Converted to run using Amazon Bedrock

import boto3
import json
import os
from botocore.exceptions import ClientError

# Set up the Amazon Bedrock client
bedrock_runtime = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-1',  # Replace with your AWS region
    aws_access_key_id=os.environ.get("AWS_ACCESS_KEY_ID"),
    aws_secret_access_key=os.environ.get("AWS_SECRET_ACCESS_KEY")
)

# Define the message
message = "What's the difference between Amazon Aurora and RDS?"

# Prepare the request body
request_body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 300,
    "temperature": 0.7,
    "messages": [
        {"role": "user", "content": message}
    ]
})

# Specify the Claude 3.5 Sonnet model ID
model_id = 'anthropic.claude-3-5-sonnet-20240620-v1:0'

try:
    print(f"Invoking model: {model_id}")
    response = bedrock_runtime.invoke_model(
        modelId=model_id,
        body=request_body
    )

    # Parse and print the response
    response_body = json.loads(response['body'].read())
    print("Response:", response_body['content'][0]['text'])
except ClientError as e:
    error_code = e.response['Error']['Code']
    error_message = e.response['Error']['Message']
    print(f"Error: {error_code} - {error_message}")
except Exception as e:
    print(f"Unexpected error: {str(e)}")

# Print debugging information
print("\nDebugging Information:")
print(f"AWS Region: {bedrock_runtime.meta.region_name}")
print(f"Model used: {model_id}")
print("Please ensure you have the correct permissions and that this model is available in your region.")

Alternative: Leveraging Claude for Code Conversion

While manually converting your code from the Anthropic API to Amazon Bedrock is a valuable exercise in understanding the differences between the two services, there's an alternative approach that can save time and potentially catch nuances you might miss: using Claude 3.5 Sonnet itself to assist with the conversion process. I was able to make this work, but I did have to do a bit of 'back and forth' with Claude 3.5 Sonnet to get working code. Even with the minor challenges, it still saved me time!

Here's how you can leverage Claude's capabilities:

1. Prepare Your Existing Code: Gather the Anthropic API code you want to convert. Ensure it's well-commented and includes any relevant context.

2. Craft a Clear Request: Ask Claude to convert your code, providing specific instructions. For example: "Please convert the following Python code that uses the Anthropic API with Claude 3.5 Sonnet to use Amazon Bedrock instead. Maintain the same functionality and include error handling. Here's the code: [paste your code here]"

3. Review and Refine: Examine the converted code provided by Claude. It may catch subtleties in the API differences that aren't immediately obvious. If needed, ask for clarifications or modifications.

4. Iterate if Necessary: If the converted code isn't quite right, provide feedback to Claude and ask for adjustments. For instance: "The conversion looks good, but could you add more robust error handling for AWS-specific exceptions?".

5. Test Thoroughly: Once satisfied with the conversion, test the new Amazon Bedrock code thoroughly to ensure it maintains the functionality of your original implementation.

This approach can be particularly beneficial when:

• You're converting a large amount of code

• You're unfamiliar with the intricacies of the Amazon Bedrock API

• You want to ensure you're following best practices for Amazon Bedrock integration

If there is one thing I've learned from using Claude 3.5 and other LLMs to write code -- Always review and test the converted code in your own environment.

UPDATE on August 19th, 2024 - A reader pointed out to me that the Anthropic API offers a path to Bedrock as well! This might be a simpler path depending on your needs. Check it out - https://docs.anthropic.com/en/api/claude-on-amazon-bedrock

I started simple to make sure I could even extract location data from my test images and asked Claude (3.5 Sonnet) to write some code for me:

My Prompt:

Write a Python script that takes a list of image files as parameters. For each image file, list the filename, date created, and location information. Image formats will include jpg, nef, and heic (Apple iphone images).

As requested, Claude created some Python code for me and asked me to install the following Pillow and piexif libraries:

pip install Pillow piexif

I tried the generated code, got an error, and told Claude about it:

I get the following error when testing with a jpg:
Traceback (most recent call last): File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 87, in <module> main(sys.argv[1:]) File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 74, in main info = process_image(image_file) ^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 63, in process_image location = get_gps_info(exif_data) ^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 44, in get_gps_info return f"{lat:.6f}, {lon:.6f}" ^^^^^^^^^^^^^^^^^^^^^^^ TypeError: unsupported format string passed to Fraction.format

Claude responded:

I apologize for the oversight. The error you're encountering is due to the GPS coordinates being stored as Fraction objects in some EXIF data, which can't be formatted directly with the f-string. Let's modify the get_gps_info function to handle this case.

These changes should resolve the error you were seeing. The script now handles GPS coordinates stored as tuples (degrees, minutes, seconds) or as Fraction objects, which are common formats for GPS data in EXIF.

This updated version should work with JPG files that store GPS coordinates in various formats. It still maintains compatibility with NEF and HEIC files as well.

Everything worked with jpg files, but my heic files didn't, so I told Claude about it:

Date created and location are unknown with all heic files

Claude responded:

I apologize for the oversight with HEIC files. You're right that the current implementation isn't correctly extracting the date and location information from HEIC files. Let's modify the script to properly handle HEIC metadata. We'll use the pyheif library in addition to piexif to better process HEIC files.

Claude asked me to install pyheif - pip install pyheif - but I got errors trying to install it, so I told Claude about it:

pyheif won't install

Claude responded:

I apologize for the difficulty you're experiencing with installing pyheif. You're right that it can sometimes be challenging to install due to its dependencies. Let's try an alternative approach using pillow-heif, which is generally easier to install and use. Here's an updated version of the script that uses pillow-heif instead of pyheif:

I installed pillow-heif as instructed and tried the newly generated code, but got another error, so I told Claude about it:

I'm getting the following error:
Traceback (most recent call last): File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 82, in <module> main(sys.argv[1:]) File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 69, in main info = process_image(image_file) ^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 58, in process_image location = get_gps_info(exif_data) ^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/gregwilson/Downloads/imageplay/image-metadata-script.py", line 38, in get_gps_info lat = gps_info.get(2) ^^^^^^^^^^^^ AttributeError: 'int' object has no attribute 'get'

Claude responded:

I apologize for the oversight. The error you're encountering suggests that the GPS information is not being stored as expected in the EXIF data. Let's modify the get_gps_info function to handle different possible structures of GPS data.

This worked for jpg files, so now we're getting somewhere! However, for heic files, it didn't work, so I told Claude about it:

Location is unknown in all heic files

Claude responded:

I apologize for the continued difficulty with HEIC files. It seems that the GPS data in HEIC files might be stored differently or not easily accessible through the current method. Let's try a different approach using the exif library, which is specifically designed to handle EXIF data and should work better with HEIC files.

I tried the new code, got a new error, and told Claude about it:

Getting following error on heic files:
Error reading EXIF data for IMG_1837.heic:

+--------+------------+-------+-------+------------------------+ | Offset | Access | Value | Bytes | Format | +--------+------------+-------+-------+------------------------+ | | | | | TiffHeader (Structure) | | 0 | byte_order | 11565 | 2d 2d | tiff_byte_order | +--------+------------+-------+-------+------------------------+

Claude responded:

I apologize for the continued issues. It seems that the exif library is having trouble reading the HEIC files directly. Let's try a different approach using pillow_heif to open the HEIC files and then extract the EXIF data.

I downloaded the new code, and it worked! Below is the output:

python3 image-metadata-script.py *heic *jpg      
Filename: IMG_1837.heic
Date Created: 2023-12-26 21:27:59
Location: 37.659542, -122.294072
----------------------------------------
Filename: IMG_3724.heic
Date Created: 2023-08-08 19:59:54
Location: 37.659483, -122.294006
----------------------------------------
Filename: IMG_3725.heic
Date Created: 2023-08-08 20:01:46
Location: 37.659525, -122.293936
----------------------------------------
Filename: DSC_7148.jpg
Date Created: 2015-08-27 09:36:46
Location: 48.862175, 2.323205
----------------------------------------
Filename: PANO0001 Panorama-106.jpg
Date Created: 2023-09-07 18:17:21
Location: 37.659570, -122.293875
----------------------------------------
Filename: PANO0001 Panorama.jpg
Date Created: 2023-09-07 18:15:53
Location: 37.6759570, -122.293872
----------------------------------------

I obviously had to wrestle Claude a bit to get this working, but it's impressive nonetheless.

I decided to take it to the next level and have Claude add some code to convert the lat/long to city, state, country. I asked Claude:

That works. Now add the city, state, country of each image location

Claude responded:

Great to hear that the script is now working for your HEIC files! Let's enhance the script to add city, state, and country information for each image location. We'll use the geopy library to perform reverse geocoding based on the GPS coordinates.

I installed the require libraries, downloaded the new code, tried it, got an error, and told Claude about it:

Getting error:
Error getting location details: HTTPSConnectionPool(host='nominatim.openstreetmap.org', port=443): Max retries exceeded with url: /reverse?lat=37.759541666666664&lon=-122.39407222222223&format=json&addressdetails=1 (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1006)')))

Claude responded:

I apologize for the SSL certificate verification error you're encountering. This issue is likely related to your Python installation not having the proper SSL certificates. Let's modify our script to work around this issue while still maintaining security. We'll add an option to disable SSL verification, but we'll make sure to warn the user about the potential security implications.

Claude also provided instructions for how to get my SSL cert installed and working, but I didn't want to do that for this little exercise, so I downloaded the new code, tried it, and it worked! Below is the new output:

----------------------------------------
Filename: DSC_7148.jpg
Date Created: 2015-08-27 09:36:46
Location: 48.862175, 2.323205
Location Details: Paris, Île-de-France, France
----------------------------------------

I decided to try one more thing... I asked Claude:

Works perfectly. Now determine the distance between all images and determine the two images with the most distance between them.

Claude responded:

Great to hear it's working perfectly! Let's enhance the script to calculate the distances between all images and find the two images that are farthest apart. We'll use the geopy.distance module to calculate the distances between coordinates.

I downloaded the new code and it worked perfectly. I gave it a handful of images and it output:

The two images farthest apart are:
1. DSC_7148.jpg (Paris, Île-de-France, France)
2. IMG_3724.heic (San Francisco, California, United States)
Distance between them: 8974.51 km

The final code:

import os
import sys
from datetime import datetime
from PIL import Image
from pillow_heif import register_heif_opener, HeifImagePlugin
from exif import Image as ExifImage
import io
from geopy.geocoders import Nominatim
from geopy.distance import geodesic
from geopy.exc import GeocoderTimedOut, GeocoderUnavailable
import time
import ssl
import certifi
import argparse
from itertools import combinations

# Register HEIF opener with Pillow
register_heif_opener()

def create_ssl_context(verify_ssl):
    if verify_ssl:
        return ssl.create_default_context(cafile=certifi.where())
    else:
        ctx = ssl.create_default_context()
        ctx.check_hostname = False
        ctx.verify_mode = ssl.CERT_NONE
        return ctx

def initialize_geolocator(verify_ssl):
    ssl_context = create_ssl_context(verify_ssl)
    return Nominatim(user_agent="image_metadata_script", scheme='https', ssl_context=ssl_context)

def get_exif_data(image_path):
    try:
        if image_path.lower().endswith('.heic'):
            with Image.open(image_path) as img:
                exif_data = img.getexif()
                exif_bytes = io.BytesIO()
                img.save(exif_bytes, format='JPEG', exif=exif_data)
                exif_bytes.seek(0)
                return ExifImage(exif_bytes)
        else:
            with open(image_path, 'rb') as image_file:
                return ExifImage(image_file)
    except Exception as e:
        print(f"Error reading EXIF data for {image_path}: {str(e)}")
    return None

def get_creation_date(exif_data):
    try:
        if hasattr(exif_data, 'datetime_original'):
            return datetime.strptime(str(exif_data.datetime_original), '%Y:%m:%d %H:%M:%S')
        elif hasattr(exif_data, 'datetime'):
            return datetime.strptime(str(exif_data.datetime), '%Y:%m:%d %H:%M:%S')
    except Exception as e:
        print(f"Error parsing creation date: {str(e)}")
    return None

def convert_to_degrees(dms, ref):
    degrees = dms[0]
    minutes = dms[1] / 60.0
    seconds = dms[2] / 3600.0

    if ref in ['S', 'W']:
        return -(degrees + minutes + seconds)
    else:
        return degrees + minutes + seconds

def get_gps_info(exif_data):
    try:
        if hasattr(exif_data, 'gps_latitude') and hasattr(exif_data, 'gps_longitude'):
            lat = convert_to_degrees(exif_data.gps_latitude, exif_data.gps_latitude_ref)
            lon = convert_to_degrees(exif_data.gps_longitude, exif_data.gps_longitude_ref)
            return lat, lon
    except Exception as e:
        print(f"Error processing GPS info: {str(e)}")
    return None

def get_location_details(geolocator, lat, lon):
    max_retries = 3
    for attempt in range(max_retries):
        try:
            location = geolocator.reverse(f"{lat}, {lon}")
            if location:
                address = location.raw['address']
                city = address.get('city') or address.get('town') or address.get('village') or 'Unknown'
                state = address.get('state') or 'Unknown'
                country = address.get('country') or 'Unknown'
                return f"{city}, {state}, {country}"
            return "Unknown location"
        except (GeocoderTimedOut, GeocoderUnavailable) as e:
            if attempt < max_retries - 1:
                time.sleep(1)
            else:
                print(f"Error getting location details: {str(e)}")
                return "Unknown location"

def process_image(image_path, geolocator):
    filename = os.path.basename(image_path)
    exif_data = get_exif_data(image_path)

    creation_date = get_creation_date(exif_data) if exif_data else None
    gps_info = get_gps_info(exif_data) if exif_data else None

    location = "Unknown"
    location_details = "Unknown location"
    if gps_info:
        lat, lon = gps_info
        location = f"{lat:.6f}, {lon:.6f}"
        location_details = get_location_details(geolocator, lat, lon)

    return {
        "filename": filename,
        "creation_date": creation_date.strftime('%Y-%m-%d %H:%M:%S') if creation_date else "Unknown",
        "location": location,
        "location_details": location_details,
        "gps_coords": gps_info
    }

def calculate_distances(image_infos):
    distances = []
    for (img1, info1), (img2, info2) in combinations(image_infos.items(), 2):
        if info1['gps_coords'] and info2['gps_coords']:
            distance = geodesic(info1['gps_coords'], info2['gps_coords']).miles
            distances.append((img1, img2, distance))
    return distances

def find_farthest_images(distances):
    if not distances:
        return None, None, 0
    return max(distances, key=lambda x: x[2])

def main(image_files, verify_ssl):
    geolocator = initialize_geolocator(verify_ssl)
    image_infos = {}

    for image_file in image_files:
        if os.path.exists(image_file):
            info = process_image(image_file, geolocator)
            image_infos[image_file] = info
            print(f"Filename: {info['filename']}")
            print(f"Date Created: {info['creation_date']}")
            print(f"Location: {info['location']}")
            print(f"Location Details: {info['location_details']}")
            print("-" * 40)
        else:
            print(f"File not found: {image_file}")
            print("-" * 40)

    distances = calculate_distances(image_infos)
    farthest_img1, farthest_img2, max_distance = find_farthest_images(distances)

    if farthest_img1 and farthest_img2:
        print(f"\nThe two images farthest apart are:")
        print(f"1. {image_infos[farthest_img1]['filename']} ({image_infos[farthest_img1]['location_details']})")
        print(f"2. {image_infos[farthest_img2]['filename']} ({image_infos[farthest_img2]['location_details']})")
        print(f"Distance between them: {max_distance:.2f} miles")
    else:
        print("\nUnable to calculate distances. Ensure at least two images have valid GPS coordinates.")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Process image metadata, location information, and calculate distances in miles.")
    parser.add_argument("image_files", nargs="+", help="Image files to process")
    parser.add_argument("--no-verify-ssl", action="store_true", help="Disable SSL certificate verification (use with caution)")
    args = parser.parse_args()

    if args.no_verify_ssl:
        print("WARNING: SSL certificate verification is disabled. This is not recommended for production use.")
        print("To fix SSL issues properly, try updating your SSL certificates:")
        print("pip install --upgrade certifi")
        print("If issues persist, consult your system administrator or Python installation documentation.")
        print()

    main(args.image_files, not args.no_verify_ssl)

Going through this exercise gave me a much better sense of the kind of coding the Claude and other LLMs is capable of and how debugging can work.

For my next project, I might take all of the images from a specific year, extract the location, and create a KML file so I can visualize all of the images in Google Earth. I have no doubt that I could get this done quickly.

My Photography Workflow

Before diving into the upgrades, let me explain my setup. I use my DS723+ primarily as a centralized storage solution for my extensive photo library. Adobe Lightroom is my go-to software for accessing and editing these photos. Working with high-resolution RAW files demands maximum performance from both my storage and network.

Two upgrades I installed:

• Synology M.2 2280 NVMe SSD SNV3410 400GB (SNV3410-400G)

• Synology Network Upgrade Module adds 1x 10GbE RJ-45 (E10G22-T1-Mini)

(Both of these were available on Amazon)

Upgrade 1: Adding NVMe SSDs

The Installation Process

Installing the NVMe SSDs was straightforward:

1. I powered down the DS723+ and unplugged it.

2. Removed the cover (following the user manual).

3. Located the two M.2 NVMe slots on the bottom of the motherboard.

4. Inserted the SSDs and secured them.

5. Replaced the cover and powered on the NAS.

6. Used DSM (DiskStation Manager) to initialize and configure the new SSDs.

Upgrade 2: Adding a 10GbE Network Card

The Installation Process

Adding the 10GbE network card was also straightforward:

1. Powered down and unplugged the NAS.

2. Removed the cover.

3. Inserted the 10GbE card into the PCIe slot and secured it.

4. Replaced the cover and powered on the NAS.

5. Configured the new network interface in DSM and connect it to my 10Gb port on my router (Ubiquity Dream Machine SE)

The Overall Impact on My Workflow

These upgrades have truly transformed my Lightroom workflow. Tasks that used to take minutes now complete in seconds. Importing photos, generating previews, scrolling through my library, and exporting edited images - all these processes are now significantly faster.

More importantly, these performance improvements have made my editing process more enjoyable and creative. I'm no longer waiting for everything to catch up with my workflow. Instead, I can focus on my images.

The immediate caching of new uploads is particularly game-changing. After a long shoot, I can start working on my photos almost instantly after uploading them.

Other Synology NAS devices support these upgrades - see their website for details.

Below is my chat with Claude. Although I'm not an expert at this type of prompting yet, I was able to hack my way through it. After most prompts, Claude created new code for me that was replaced after the subsequent prompts, so I omitted the early Claude responses to make this easier to read. I started by testing if I could get it to describe local images of varying formats (JPG, HEIC, PNG). Once this was successful, I expanded the scope to include parsing the images from HTML, injecting new ALT attributes, and more. This entire project took me only 20 minutes which I found super exciting. Even if I wrote in a programming language I'm intimately familiar with, I could have never completed this as fast because I'd have to figure out to handle PNGs, JPGs, HEIC, the Anthropic APIs, and more.

Greg: Are you familiar with the Claude API?

Claude 3.5 Sonnet: Yes, I am familiar with the Claude API. It allows developers to integrate Anthropic's language models, including versions of me, into their applications and services. The API provides access to capabilities like natural language understanding, text generation, and task completion. However, I don't have detailed knowledge about its exact specifications, pricing, or implementation details. For the most up-to-date and accurate information about the Claude API, I'd recommend checking Anthropic's official documentation and resources.

Greg: I have a list of image URLs. I need a 125 char description of each. Write python code to do this with Claude 3.5 Sonnet.
(Claude output omitted for brevity)

Greg: I will provide the list of image URLs in a file named images.csv
(Claude output omitted for brevity)

Greg: print each url as you read the file
(Claude output omitted for brevity)

Greg: Getting an error - 'url' found using 'type' does not match any of the expected tags: 'base64'"

Claude 3.5 Sonnet: I apologize for the confusion. It seems the error is related to how we're passing the image URL to the Claude API. The API is expecting a base64-encoded image rather than a URL. Let's modify the script to handle this correctly. We'll need to download the image and convert it to base64 before sending it to the API. Here's an updated version of the script that should resolve this issue:

Greg: This only handles jpg. I need it to also handle png
(Claude output omitted for brevity)

Greg: Output the results to a new csv file. The columns of the csv file should be (1) image url and (2) image description.
(Claude output omitted for brevity)

Greg: add gif support including animated gif
(Claude output omitted for brevity)

(I had to install PIL)

Greg: Can you add webp support?
(Claude output omitted for brevity)

Greg: I want the option to pass a parameter to the program. The parameter will be a URL of a webpage. Read the web page and use all of the image URLs in the page instead of the input file currently used
(Claude output omitted for brevity)

(I had to install BeautifulSoup)

Greg: Modify the program to output the same HTML that it reads but insert each of the image descriptions as the "alt" of the image tag.
(Claude output omitted for brevity)

Greg: write the output to stdout in addition to the file
(Claude output omitted for brevity)

Greg: Don't process img tags that already have the alt attribute
(Claude output omitted for brevity)

Greg: Change the program to take a single parameter that is an HTML file. The output will continue to be stdout.

Resulting program (untouched by me):

import anthropic
import base64
import argparse
import sys
from io import BytesIO
from urllib.parse import urljoin
from PIL import Image
from bs4 import BeautifulSoup
import os
import requests

# Initialize the Anthropic client
client = anthropic.Anthropic(api_key="your_api_key_here")

def download_image(url):
    response = requests.get(url)
    return BytesIO(response.content)

def image_to_base64(image):
    buffered = BytesIO()
    image.save(buffered, format="PNG")
    return base64.b64encode(buffered.getvalue()).decode('utf-8')

def get_image_type(path):
    ext = os.path.splitext(path)[1].lower()
    if ext == '.png':
        return 'image/png'
    elif ext in ['.jpg', '.jpeg']:
        return 'image/jpeg'
    elif ext == '.gif':
        return 'image/gif'
    elif ext == '.webp':
        return 'image/webp'
    else:
        return 'image/jpeg'  # Default to JPEG if unable to determine

def process_gif(gif_image):
    if gif_image.is_animated:
        gif_image.seek(0)
    return gif_image.convert('RGB')

def get_image_description(image_path):
    try:
        media_type = get_image_type(image_path)

        with Image.open(image_path) as img:
            if media_type == 'image/gif':
                img = process_gif(img)
            elif media_type == 'image/webp' and hasattr(img, 'is_animated') and img.is_animated:
                img.seek(0)

            if img.mode != 'RGB':
                img = img.convert('RGB')

            base64_image = image_to_base64(img)

        message = client.messages.create(
            model="claude-3-sonnet-20240229",
            max_tokens=125,
            temperature=0.7,
            system="You are a helpful assistant that provides concise image descriptions.",
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": base64_image
                            }
                        },
                        {
                            "type": "text",
                            "text": "Describe this image in exactly 125 characters. If it's an animated image, describe the first frame."
                        }
                    ]
                }
            ]
        )

        return message.content[0].text
    except Exception as e:
        return f"Error processing image: {str(e)}"

def process_html(html_file):
    try:
        with open(html_file, 'r', encoding='utf-8') as file:
            soup = BeautifulSoup(file, 'html.parser')

        base_dir = os.path.dirname(os.path.abspath(html_file))
        img_tags = soup.find_all('img')

        for img in img_tags:
            if img.get('alt'):
                print(f"Skipping image with existing alt text: {img.get('src')}", file=sys.stderr)
                continue

            img_src = img.get('src')
            if img_src:
                img_path = os.path.join(base_dir, img_src)
                if os.path.exists(img_path):
                    print(f"Processing image: {img_path}", file=sys.stderr)
                    description = get_image_description(img_path)
                    img['alt'] = description
                    print(f"Added description: {description}", file=sys.stderr)
                else:
                    print(f"Image file not found: {img_path}", file=sys.stderr)

        return soup.prettify()
    except Exception as e:
        print(f"Error processing HTML: {str(e)}", file=sys.stderr)
        return None

def main():
    parser = argparse.ArgumentParser(description="Generate image descriptions and modify HTML.")
    parser.add_argument("html_file", help="Path to the HTML file to process")
    args = parser.parse_args()

    print(f"Processing HTML file: {args.html_file}", file=sys.stderr)
    modified_html = process_html(args.html_file)

    if modified_html:
        # Print to stdout
        print(modified_html)
    else:
        print("Failed to process the HTML file.", file=sys.stderr)

if __name__ == "__main__":
    main()

I've been an active photographer most of my life, including a few years of doing it professionally (aerial , commercial, wedding, etc.). I recently sold my Nikon F-mount bodies and lenses and upgraded the new Nikon Z-series mirrorless platform. I acquired the new Nikon Z8 and several amazing Nikon Z lenses. The Z8 is an amazing camera for still photography, but it's also stunningly good at video – supporting 8K/60fps, 4K/120fps, in both 8-bit and 10-bit (full specs). I knew the basics of video and could stumble through simple edits, but I had no idea how to do color grading on log footage, how to export and publish HDR, etc.. As I started to dig in, I quickly learned that it is WAY more complicated than I thought! The more I learned, the further away I felt from being competent!

I decided to dive deep and found many great YouTube channels that cover these topics (see below), but it was ChatGPT that helped me fill in the gaps of my knowledge. This is the first time I used an AI chatbot to learn anything significant.

Below is my full conversation with ChatGPT (v4) that spanned several days. I was surprised at how efficient this type of learning is. I would watch a couple of YouTube videos then go to ChatGPT to clarify whatever was confusing me. I thought y'all might like to see how it looks to have this type of exchange with an AI bot:

My conversation with ChatGPT about video file formats, HDR, publishing, etc.

I also went to Google Bard when I had a specific question about YouTube:

‎Does youtube support dolby vision?

I even played around with Anthropic Claude (doesn't have a sharing feature, so including a screenshot below):

Below are some great YouTube channels on video editing that I follow - mostly about Apple Final Cut Pro. I chose Final Cut Pro to take the maximum advantage of my Macbook Pro M2 and because it's HDR workflow is nice. Adobe Premier and DaVinci Resolve are fantastic options as well.

I still have a lot to learn, but I'm at least able to create something cool. For example:

Lastly, I'll point out that through this entire learning exercise, I never once looked at the docs for Final Cut Pro, which is telling. Obviously those docs were part of the training content for ChatGPT, Bard, Claude, etc., but I never felt the need to go to the source.

:)

I shot the videos below using the new 3x 70mm camera shot in 4k/60fps HDR (HLG) with some very minor color correction and contrast boost in Final Cut Pro.

Make sure it is showing in 4k.

Tons of features to explore!

I tend to like keyboard shortcuts because I’ve spent decades using the vi text editor to write code. Vi was originally created in the mid-1970s for the Unix operating system before anyone used a mouse or trackpad, so all of the functionality was implemented as keyboard shortcuts. Because your hands never leave the keyboard, programmers using vi tend to be very fast, especially if they master all of the features. As a result, it’s still a popular editor with programmers.

Turning on Gmail keyboard shortcuts

The first thing you need to do is make sure you have keyboard shortcuts turned on. Go to settings , See all settings, then scroll down to keyboard shortcuts and turn them on.

Press "?" when in Gmail and you'll get this:

Shortcuts I use when viewing my inbox

• You’ve probably never noticed it before, but there is a thin blue bar on the left of the first email in your inbox.

• Press the j and k keys a few times to make the blue bar go up and down the list.

• To open the email, press o or enter.

• To select the currently highlighted email, press the x key. You’ll see the checkbox beside the email become selected. Once you select one of more emails, you can take action on it to archive, forward, reply, etc. using the shortcuts below.

• To search your emails, hit the forward slash /

Shortcuts to use when viewing an individual email conversation

If your current workflow is to open an email, take an action, then go back to the inbox to open the next email, using the following shortcuts will save you a lot of time! While looking at an individual email, you can press:

• j and k to go to the older/newer email conversation.

• { and } is similar to j and k but the current email conversation will be archived before moving to the older/newer one.

I tend to use { and } more frequently because I try to handle each email as I get to it rather than postponing action.

Taking action on the currently opened email

• r to start a reply or a to start a reply-all and put your cursor in the body so you can immediately start typing.

• f to forward the email.

• s to star the email. If you have multiple stars set up — press s multiple times to toggle between different stars.

• ; will expand all emails in the current conversation. When viewing an email conversation with multiple emails, Gmail collapses the emails that you have seen before, which is mostly awesome, but sometimes I want to re-read the entire conversation from the top. This shortcut eliminates the need to expand each email in the conversation one by one.

• ! to mark as spam

• # to delete

• u will go back to the inbox

• m will mute the current conversation — When you mute a conversation, new messages added to the conversation bypass your inbox so that the conversation stays archived. Muted conversations will only pop back into your inbox ready for your attention if a new message in the conversation is addressed to you and no one else, or if you’re added to the “To” or “Cc” line in a new message.

• And don’t forget z to undo the last action!

A real-world scenario

It’s Tuesday and I’m late to work due to my dog’s vet appointment. When I finally arrive and open up Gmail, I have 53 unread emails. Here’s how I attack it:

I open the first email in my main inbox and then start using keyboard shortcuts to work the list. My keystrokes look something like this:

{{{ss{{s{{a(send reply){{a(send reply){;{f(forward email){{{sss{;m{{{r(send reply)s{s{{s{{f(forward email){{{{a(send reply){u

Yes, it looks cryptic, but once you get used to these shortcuts, you’ll be amazed at how fast you can work an inbox.

Here’s a breakdown of the first few keystrokes:

• { archive the email and move to the next one in my inbox

• { archive the email and move to the next one in my inbox

• { archive the email and move to the next one in my inbox

• s star the email

• { archive the email and move to the next one in my inbox

• { archive the email and move to the next one in my inbox

• s star the email

• { archive the email and move to the next one in my inbox

• { archive the email and move to the next one in my inbox

• a reply-all to the current email

• { archive the email and move to the next one in my inbox

• { archive the email and move to the next one in my inbox

• a reply-all to the current email

• { archive the email and move to the next one in my inbox

• ; expand all emails in the current conversation

• { archive the email and moved to the next one in my inbox

• f forward the email

• …and so on

In this example, I started with the newest email and worked my way back in time (newest to oldest).

There are many other shortcuts that I’m not covering in this post, but you can see the full list by pressing “?” in Gmail.

Later in the day, I had the idea to create a simple service that enables my use case. Instead of designing yet another chess site (I built one with a friend in 2009 that is long since gone), I decided to create a chess board logger and visualizer to make it practical to play via Twitter or any other messaging/social platform. I didn't have a lot of time, so I was optimizing for simplicity.

Instead of tweeting moves back and forth, players tweet links back and forth, and those links go to a site that renders the current chessboard, allows a new move, and creates a new link to paste back to the opponent. I wanted this to be 100% serverless, meaning that it will scale to zero and have zero maintenance requirements. Excited about this idea, I put together a shopping list:

My MVP requirements:

• Represent the board position—ideally completely in the URL to keep it stateless from a server-side perspective

• Display a chessboard and let the player make their next move.

Stretch goals:

• Enforce chess rules (allow only legal moves).

• Dynamically create a png/jpg of the chessboard that I can use as an Open Graph and Twitter card image so that when a player sends the link, the image of the board will automatically display.

Putting it all together

Representing the board position

There is a standard notation for describing a particular board position of a chess game called Forsyth–Edwards Notation (FEN) that was exactly what I needed. A FEN is a sequence of ASCII characters. For example, the starting position for any chess game can be represented by the following string:

rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1

Each letter is a piece: pawn = "P", knight = "N", bishop = "B", rook = "R", queen = "Q" and king = "K". Uppercase letters represent white pieces and lowercase letters represent black. The last part of the string is specific to certain rules in chess (read more about FEN).

I knew I could use this in the URL, so my first requirement was complete and I was able to represent the board state in the URL eliminating the need for a backend data store.

Displaying the chessboard and allowing drag-and-drop moves

Numerous chess libraries are available. One in particular that caught my eye was chessboard.js—described as “a JavaScript chessboard component with a flexible ‘just a board’ API”. I quickly discovered that this library can display chess boards from a FEN, allow pieces to be moved, and update the FEN. Perfect!

In only two hours, I had the basic functionality implemented.

Enforcing chess rules

I originally thought that making this service aware of chess rules would be difficult, but then I saw the example in the chessboard.js docs showing how to integrate it with another library called chess.js—“a JavaScript chess library that is used for chess move generation/validation, piece placement/movement, and check/checkmate/stalemate detection—basically everything but the AI”. A short time later, I had it working! Stretch goal #1 completed.

Here's what a couple of game moves look like:

Moving the pawn from D2 to D4 in a new game—https://chessmsgs.com/?fen=rnbqkbnr%2Fpppppppp%2F8%2F8%2F3P4%2F8%2FPPP1PPPP%2FRNBQKBNR+b+KQkq+d3+0+1&to=d4&from=d2&gid=mOhlhRlMboYsHLqBF1f7I

Black countering with a similar move of pawn from D7 to D5—https://chessmsgs.com/?fen=rnbqkbnr%2Fppp1pppp%2F8%2F3p4%2F3P4%2F8%2FPPP1PPPP%2FRNBQKBNR+w+KQkq+d6+0+2&to=d5&from=d7&gid=mOhlhRlMboYsHLqBF1f7I

The URL has the following data:

• fen—the new board position

• from and to—indicating what move occurred (I use this to highlight the squares)

• gid—a unique game ID (I used nanoid)—I’ll use this to connect moves to a single game in the future. For example, I could add a feature that lets the user request the entire game transcript).

Done! Except...

At this point, there were no server requirements other than simple HTML static hosting. But after playing it with some friends and family, I decided that I really wanted to accomplish the other stretch goal—dynamically create a png/jpg of the chessboard that I can use as an Open Graph and Twitter card image. With this capability, an image of the board will automatically display when a player sends the link. Without it, the game is a series of ugly URLs.

Dynamically creating the Open Graph image

This requirement introduced some server-side requirements. I needed two things to happen on the server.

First, I needed to dynamically generate a board image from a FEN. Once again, open source to the rescue (almost). I found chess-image-generator, a JavaScript library that creates a png from a FEN. I wrapped this in a bit of Node.js/Express code so that I could access the image as if it were static. For example, here’s a demo of the real endpoint: https://chessmsgs.com/fenimg/v1/rnbqkb1r/ppp1pppp/5n2/3p4/3P4/2N5/PPP1PPPP/R1BQKBNR w KQkq - 2 3.png. This link results in this image:

Second, I needed to dynamically inject this FEN-embedded URL into the content attribute of the meta tag in the main HTML. Like me, you might be thinking that you could just do some DOM manipulation in JavaScript and avoid having to dynamically change HTML on the server. But, the Open Graph image is retrieved by a bot from whatever service you use for messaging. These bots don’t execute any client-side JavaScript and expect all values to be static. So, that led to additional server-side work.

I needed to dynamically convert this:

<meta property="og:url" content="{{url}}" />

Into something like this:

<meta property="og:url" content="https://chessmsgs.com/?fen=rnbqkb1r/ppp1pppp/5n2/3p4/3P4/2N5/PPP1PPPP/R1BQKBNR+w+KQkq+-+2+3&to=f6&from=g8&gid=ziL3VfMEoIT9iNwp6csBh" />

I could have used one of many Node templating engines to do this, but they all seemed like overkill for this simple substitution requirement, so I just wrote a few lines of code for some string.replace() calls in my Node server.

With this functionality added, a game on Twitter (and other services) now looks much better:

Check out the code

The source for chessmsgs.com is available on GitHub at https://github.com/gregsramblings/chessmsgs.

Deciding where to host it

The hosting requirements are simple. I needed support for Node.js/Express, domain mapping, and SSL. I was working at Google Cloud at the time and wanted to go completely serverless, which quickly led me to Cloud Run. Cloud Run is a managed platform that enables you to run stateless containers that are invocable via web requests or Pub/Sub events.

What’s next?

If I really wanted to engineer this for extreme loads, I could easily deploy it to multiple regions throughout the globe and set up a load balancer and possibly a CDN.

When I first started thinking about the image generation, I naturally thought about caching many common images in Google Cloud Storage. This would be easy to do and storage is crazy cheap. But, then I did a bit of research and learned the following fun facts. After two moves (one move for each player), there are 400 different distinct board positions. After each player moves again (two moves each), this number is now 71,782 distinct positions. After each player moves again (three moves each), the number is now 9,132,484 distinct positions! I could gain a bit of performance by caching the most popular openings, but each game would quickly go beyond the cached images so it didn’t seem worth it. By the way, to cache every possible board position would be about 1046 positions, which is a massive number that doesn’t even have a name.

Conclusion

This was a fun project – almost therapeutic for me since my “day job” doesn’t allow much time for writing code.

Now that I work at AWS (managing technical content, documentation, SDKs, CLI), I might use this as an excuse to play with Lambda. I just need more time!

I found that 5 seconds is a bit fast. I usually don’t realize I’ve accidentally done a reply-all (or worse mistakes) until a few seconds later. Thankfully, Gmail allows you to configure the delay.

Go to Settings -> See all settings ->

If content starts playing, you will see a small icon in the tab indicating that it’s muted.

The recent Curiosity program got me thinking back about the old Mars Viking program. In 1976, NASA landed two probes on Mars that sent back the first pictures from the surface of the planet in history. This was the first time a human-created device had landed on the planet, so there were a ton of unknowns. I was very young, but I remember waiting for those first pictures from Mars, anxious to find out if the little green men would be friendly.

Here’s the first panorama ever sent from Mars (shot by Viking 1 lander – click it to go to the source and high-res versions):

I was reading about the Viking missions and stumbled on a little known, yet fascinating fact about the Viking 1 lander. On November 11, 1982, an over-the-air software update was broadcast to the Viking 1 lander to correct a battery charging issue. The update had an error in it and accidentally overwrote the wrong bits resulting in a bricked lander. Basically, they accidentally overwrote the memory reserved for the antenna pointing code which immediately terminated all communications. The mission had already been a huge success, so it wasn’t a huge deal in the grand scheme of things, but I bet those responsible for the error had a big “oh crap!, we just killed the probe!” moment. I’d love to meet these folks. I bet it’s a great story. I imagine a few NASA engineers in a conference room going through a list of memory addresses that were part of the update, trying to figure out why they didn’t get any acknowledgement from the probe, and then finding the mistake and looking at each other in shocked disbelief and fear.

I can remember working from home on a production system and accidentally typing in the wrong iptables command resulting in the instant inability to connect to the server. At least I was able to drive 30 minutes to the data center and connect a console to the server and undo my mistake!

Russian oops – Phobos 1

I also learned that a similar mistake happened with the Russian Phobos 1 orbital mars mission. From http://en.wikipedia.org/wiki/Phobos_program —

“Phobos 1 operated nominally until an expected communications session on September 2, 1988 failed to occur. The failure of controllers to regain contact with the spacecraft was traced to an error in the software uploaded on August 29/August 30, which had deactivated the attitude thrusters. By losing its lock on the Sun, the spacecraft could no longer properly orient its solar arrays, thus depleting its batteries.

Software instructions to turn off the probe’s attitude control, normally a fatal operation, were part of a routine used when testing the spacecraft on the ground. Normally this routine would be removed before launch. However, the software was coded in PROMs, and so removing the test code would have required removing and replacing the entire computer. Because of time pressure from the impending launch, engineers decided to leave the command sequence in, though it should never be used. However, a single-character error in constructing an upload sequence resulted in the command executing, with subsequent loss of the spacecraft.”

Oops!

Software Heroes -– Galileo

I also stumbled on a fascinating story about the NASA Galileo Jupiter probe launched in 1989. During it’s long trip to Jupiter, the high-gain antenna failed to open, even after many genius attempts at spinning the probe to free it (among other wild tactics). This meant that NASA was stuck using the low-gain antenna. The difference in bandwidth was dramatic — 10bps vs 134kbps (10,000 times slower)! While the crippled probe was hurtling on the way to Jupiter, software engineers had to do some serious software rewriting to try and salvage as much of the mission as possible. They rewrote the encoding/decoding software to get better compression and optimized the image compression algorithms among many other improvements. Then they had to push these updates to the probe. Can you imagine the stress? Amazing stuff. More details at https://www.nasa.gov/pdf/546504main_42s_galilieo_rocky_road_jupiter.pdf and at http://www.lpi.usra.edu/publications/newsletters/lpib/lpib76/gal76.html.

Software developers that write code for spacecraft are my heroes. They work under incredible stress and have to cope with extremely low bandwidth, very limited resources, a non-touchable, non-upgradable hardware platform and they typically are writing very low-level code. There are engineers still occasionally sending updates to the Voyager probes launched in the ’70s! They communicate at 160bps and it takes 16 hours for any instructions to be received. I get impatient when a git pull takes more than 5 seconds!

Lastly, I was reminded by a friend of yet another mission where engineers saved the day, and this one was fairly recent (2004) — The Huygens Titan probe. Read all about it at http://www.thespacereview.com/article/306/1