Gemini wouldn't remove the bird...

"Thanks and onward!" was how our first lead investor at Iron.io in 2011 signed the seed round closing docs email.

It then became the title of my blog post announcing the close of the acquisition in 2017 when we joined Oracle.

And now, almost 10 years after the acquisition, the same title is announcing the close of my time at Oracle.

Joining Oracle

We first joined Oracle to fork IronFunctions into the Fn Project and build Oracle Functions. Iron.io started as a Ruby company, and ended as a Golang shop, but ironically we launched the Fn Project at JavaOne 2017. Little did I know that two years later I would join that same Java team as an "outsider".

Former founders, particularly CEOs, rarely last at big companies. We spend our days storming the hill with a vision and few rules, few restraints, and even fewer people telling us no.

Big companies, by contrast, are intentionally designed to slow you down with rules, restraints, and armies of "no" people. This works. They survive both because of this, and in spite of it. Which is why my 9 years here were so unexpected. How did that happen?

The Java team

First, I had all 3 of my kids there, and we built our home up in Marin (north of San Francisco). So the season was right.

Also, getting stuff done in a corporate environment can be a satisfying accomplishment in and of itself. Startups may be unencumbered, but nobody is listening. With a big company machine behind you, everybody is listening.

Another reason was the challenge and scope. Maybe you've heard me say "half the global GDP runs on Java". The size of the market is remarkable, and watching the sentiment shift across the industry and ecosystem as we made steady progress was a lot of fun.

Finally, the enduring reason was the culture of the Java team. Humble, driven, long-term oriented, stewardship-minded. Part of this comes from the Sun Microsystems days, and part from the great leadership of my boss Georges Saab. The downstream effect was a set of amazing peers and the latitude to hire and build incredible teams.

A few things we accomplished:

• Hired and led a world-class devrel and education group with zero attrition
• Turned Java's YouTube into a powerhouse of engaging content resulting in rapid compound growth across all metrics
• Launched Dev.java, Inside.java, Learn.java, the Java Playground, and grew OpenJDK.org
• Partnered with the College Board to modernize the AP CS A exams and teaching infrastructure taken by nearly 100k students every year
• Shifted the market perception through 17 new releases of Java and continual briefings with the media, press, analysts, customers, educators, publishers, and more.
• Brought JavaOne back to California with a parallel educators summit
• Launched successful podcasts, one of which my daughter starred in when she was 3
• Assisted the sales and renewals of the business to grow to thousands of customers
• Ramped up an AI program aligning Java, OpenJDK, Helidon, and the ecosystem, to prepare for Java's role in the future of software development

Ultimately my work spanned developer relations, education, product, engineering, marketing, and the broader ecosystem, to "turn the ship around". This was challenging, rewarding, fulfilling, and fun!

There are too many people to thank, but thank you to all in my group who trusted and joined me on the journey.

What's Next?

After my first startup AllDorm.com, I spent a few months (in the "Saratoga House pool") deciding what I wanted to do with my life. That was in 2005. Now for the first time since then, I'm in that pool again, but this time without the sun beer, and an amazing family by my side.

There is so much going on at companies of all sizes especially with the explosion of AI platforms and tools. My plan is to start building again and just go have conversations. We'll see where that leads.

And then there are wild ideas like buying some land out of California and building the farm we've talked about. Who knows! I trust in God's plan.

Keep in Touch

If you'd like to connect, hit me up on LinkedIn, X, or hello@chad.cm.

tldr;

I run Claude Code on a schedule (on a Raspberry PI) that reads some prompts in a yaml file. My first use case is to download some YouTube videos and publish them as a private podcast feed. Eh I guess when I write it like that, this post isn't as interesting....

The Uninteresting Post

I listen to a fair amount of podcasts. In the car, on a run, mowing the lawn, etc. I use Overcast.fm. It's simple, downloads the last few episodes of each pod, keeps them there until I listen or overwrites with new episodes once a configurable limit is met. Each pod has a configurable speed, it "just works", and it doesn't have any AI features.

The problem is when pods I listen to are super delayed in publishing for whatever reason, or even stop altogether and only publish to YouTube. And there do exist some YouTube shows that never publish to audio podcasts. The horror! I don't "use" YouTube like that! Enter Claude Code.

Given that my last company was all about workers as a service, I sometimes wonder if Claude Code could do something similar by running on a schedule in the background directed by just prompts with access to all the tools it needs. That seemed to be one of the barriers of IronWorker -- getting access to the right tools easily.

Claude Code on a Schedule

My "Claude Butler" is just the following command run every hour:

claude --permission-mode bypassPermissions -p "Read tasks.yaml and execute all tasks"

Claude Butler's Tasks.yaml

❯ cat tasks.yaml
# Claude Butler - Task Instructions
# Claude reads this file and executes the tasks listed below.
#
# Required environment variables:
#   BUTLER_HOME=/path/to/claude-butler
#   NAS_ADDRESS=/path/to/nas/mount (e.g., /Volumes/farmnas2 on Mac)
#   CHANNEL_ID=my_channel_id (could be list in future)

tasks:
  - name: channel-new-audio
    description: Check channel for new videos and download audio
    channel_id: $CHANNEL_ID
    action: |
      Run this command to download audio from any videos uploaded in the last 24 hours:
      yt-dlp --dateafter now-1day --playlist-end 10 --break-on-reject --match-filter "!is_live" -x --audio-format mp3 --no-overwrites --restrict-filenames -o "$BUTLER_HOME/downloads/%(upload_date)s_%(channel)s_%(title)s.%(ext)s" "https://www.youtube.com/channel/$CHANNEL_ID/videos"

  - name: sync-downloads-to-nas
    description: Copy downloaded files to NAS
    action: |
      Run this command to sync downloads to the NAS:
      rsync -av --ignore-existing $BUTLER_HOME/downloads/ $NAS_ADDRESS/public/

  - name: generate-podcast-rss
    description: Generate podcast RSS feed from MP3 files
    action: |
      Generate a podcast RSS feed at $NAS_ADDRESS/public/feed.xml based on the MP3 files in $NAS_ADDRESS/public/.

      Requirements:
      - Follow the Apple Podcasts RSS spec: https://help.apple.com/itc/podcasts_connect/en.lproj/itcbaf351599.html
      - Podcast title: ChadCast
      - Base URL for files is http://my-local-podcast-feed/
      - Parse episode titles from filenames (format: YYYYMMDD_Channel_Title.mp3)
      - Include only required/minimum tags
      - Sort episodes by date descending (newest first)

Profit

I now have a private feed that publishes YouTube videos as audio-only all done locally. It's useful to me at least.

Workers without the code?

I guess this is a little bit like IronWorker but instead of a worker file executing code, the worker is just headless claude. That said it's obviously not "codeless" because yt-dlp (and rsync) are actually a lot of code that I'm leaning on, but you get the concept.

I'm sure I'll find some other interesting use cases for my AI Butler.

AI is Weird

One thing of note: when I first "deployed" this to my Pi, I forgot to set the environment variables. That's always the first thing that fails background tasks, forgetting stuff like that. Did AI fail? Nope. It just figured out what they "should be" from the context. I feel like I've typed this exact line multiple times before.....

New Language Features

Improved Readability with Text Blocks

private static final String SYSTEM_PROMPT = """
    You are Gus, a friendly and helpful AI assistant.
    You provide clear, concise, and accurate responses.
    You're conversational but professional.
""";

Clean, readable, and with ASCII art:

IO.println("""
    -------------------------------------------------------------------
                ,
                |`-.__
                / ' _/
               ----\s
              /    }
             /  \\ /
         \\ /`   \\\\\\
          `\\    /_\\\\
           `~~~~~``~`

    [Using provider %s with model %s]

    (type /exit or Ctrl+D to quit, /help for help, /clear to clear memory)
    -------------------------------------------------------------------

    Hi, I'm Gus, your friendly neighborhood AI CLI! How can I help today?\s
    """.formatted(provider, model));

Type Safety with Sealed Classes and Switch

Sealed classes let you define a closed hierarchy. Here's the tool system:

public abstract sealed class Tools permits SecretTool,
                                           SearchWebTool,
                                           ScrapePageTool {
    // ...
}

This tells the compiler exactly which classes can extend Tools. No surprises at runtime, and the compiler can verify exhaustiveness.

When you combine sealed classes with switch expressions, the compiler knows all possible cases:

return switch (tool) {
    case SecretTool t -> t.secret();
    case SearchWebTool t -> t.searchWeb(args.get("arg0").getAsString());
    case ScrapePageTool t -> t.scrapePage(args.get("arg0").getAsString());
};

No default case needed - the compiler knows these are the only three possibilities. If you add a new tool to the sealed hierarchy, this switch will fail to compile until you handle it. Type safety for the win.

The IO Class

Java 25 added IO to java.base as a cleaner alternative to System.out:

IO.println("Goodbye!");
IO.print("\r" + animation[i % animation.length] + " Thinking...");

The Basic Flow

Basically Gus is an agent that runs in a loop and can call user-defined tools if needed

1. LangChain4j for model abstraction.
2. ChatService sends it to the model with tool specifications
3. Model decides whether to respond directly or call a tool
4. If tools are called, Gus executes them and sends results back
5. Model uses tool results to generate final response
6. Response streams back to the user

The streaming response handler shows a thinking animation until the first token arrives, then displays the response as it generates.

Tool System

Tools extend the sealed Tools class and use LangChain4j's @Tool annotation like so:

public final class SearchWebTool extends Tools {
    @Tool("Searches the web for current information and returns relevant results")
    public String searchWeb(String query) {
        preToolHook("searchWeb", "query='" + query + "'");

        WebSearchEngine engine = TavilyWebSearchEngine.builder()
                .apiKey(apiKey)
                .build();

        WebSearchResults results = engine.search(query);
    }
}

The tool framework automatically generates the JSON schema that gets sent to the model. When the model wants to search the web, it returns a tool call request, and the ChatService executes the appropriate tool based on the sealed type.

Building and Running

Gus uses Maven and jpackage to create a native executable:

mvn -Pcomplete clean package

This produces a native app bundle at target/jpackage/gus.app. I wrote about getting jpackage to work with CrowdStrike in a previous post.

Then you can run it:

gus --openai  # Uses OpenAI's models
gus --ollama  # Uses local Ollama (default)

If you want to try it, the code is on GitHub.

❯ gus --ollama
-------------------------------------------------------------------
            ,
            |`-.__
            / ' _/
           ----\s
          /    }
         /  \\ /
     \\ /`   \\\\\\
      `\\    /_\\\\
       `~~~~~``~`

[Using provider ollama with model llama3.2]

Hi, I'm Gus, your friendly neighborhood AI CLI! How can I help today?

> What's the weather in San Francisco?

● searchWeb(query='weather San Francisco')

The current weather in San Francisco is partly cloudy with a temperature
of 62°F. Expect mild conditions throughout the day with a high of 68°F.

>

Boom.

I discovered the hard way that because CrowdStrike is installed on my machine, I couldn't run apps built with jpackage, which is Java's packaging tool to bundle a runtime with your app and produce a native package. I use this for command-line stuff in Java. Like Arc. And Gus. Everything was fine on my home machine. Until they met my work machine. CrowdStrike would kill my app and quarantine the executable file. I'm guessing our IT group will provide an exception for me, but I felt like learning more so I dove in.

[Update: As suspected, this was a CrowdStrike false positive because running jpackage locally on your own app shouldn't be a threat. Distributing it might be, of course, and thus it should be signed.]

The Problem

The problem is because running a jpackage-built app results in the process being killed immediately:

./output/Hello.app/Contents/MacOS/Hello
[1]    30464 killed     ./output/Hello.app/Contents/MacOS/Hello

CrowdStrike Falcon quarantines the executable because of a file called libjli.dylib, which is a core part of the JVM launcher, but also is unsigned (or ad-hoc signed or something). Apparently this isn't very trustworthy. Like Gus himself. The real Gus has been licking his lips around the baby chickens. The protector becomes the aggressor.

The Solution

1. Get an Apple Developer Certificate

Once enrolled in the Apple Developer Program, you need to create a Developer ID Application certificate (not "Apple Development" or "Mac App Distribution"). This is specifically for signing apps distributed outside the Mac App Store.

2. Create a Certificate Signing Request

openssl req -new -newkey rsa:2048 -nodes \
  -keyout DeveloperID.key \
  -out CertificateSigningRequest.certSigningRequest \
  -subj "/emailAddress=you@example.com/CN=Your Name/C=US"

Upload the .certSigningRequest file to Apple Developer portal, select G2 Sub-CA, and download the resulting .cer file.

3. Import the Certificate

# Import the certificate
security import developerID_application.cer -k ~/Library/Keychains/login.keychain-db

# Import the private key
security import DeveloperID.key -k ~/Library/Keychains/login.keychain-db

# Download and import Apple's intermediate certificate
curl -O https://www.apple.com/certificateauthority/DeveloperIDG2CA.cer
security import DeveloperIDG2CA.cer -k ~/Library/Keychains/login.keychain-db

# Verify it's available
security find-identity -v -p codesigning

You should see your Developer ID Application identity listed.

4. Create an Entitlements File

The JVM requires specific entitlements to run with hardened runtime:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>com.apple.security.cs.allow-jit</key>
    <true/>
    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
    <true/>
    <key>com.apple.security.cs.disable-library-validation</key>
    <true/>
</dict>
</plist>

Save this as entitlements.plist.

5. Build and Sign with jpackage

jpackage \
  --name Hello \
  --type app-image \
  --input /path/to/input \
  --main-jar Hello.jar \
  --dest /path/to/output \
  --runtime-image /path/to/runtime \
  --mac-sign \
  --mac-signing-key-user-name "Developer ID Application: Your Name (TEAMID)" \
  --verbose

If jpackage doesn't apply entitlements correctly, you'll need to manually re-sign (update: this is a bug that has been fixed and should ship in JDK 26 making this step unnecessary):

codesign --force --sign "Developer ID Application: Your Name (TEAMID)" \
  --entitlements entitlements.plist \
  --deep --options runtime \
  output/Hello.app

6. Verify the Signature

codesign -dv output/Hello.app/Contents/MacOS/Hello
codesign -d --entitlements - --xml output/Hello.app/Contents/MacOS/Hello

You should see your Developer ID signature and the entitlements listed.

Boom

❯ ./output/Hello.app/Contents/MacOS/Hello
Hello, Chad

Boom.

Update: Maven settings to make this all happen as an optional profile step

I'm taking this code out of my demos now since I can run this all unsigned on my work laptop. But if anyone wants to distribute a jpackaged app to folks on machines running greedy AI security bots, the code below is for you.

<build>
    <plugins>
        <plugin>
            <groupId>org.panteleyev</groupId>
            <artifactId>jpackage-maven-plugin</artifactId>
            <executions>
                <execution>
                    <id>create-installer</id>
                    <phase>package</phase>
                    <goals>
                        <goal>jpackage</goal>
                    </goals>
                    <configuration>
                        <name>YourApp</name>
                        <type>APP_IMAGE</type>
                        <!-- ... other config ... -->
                        <!-- NO macSign, macSigningKeyUserName, or macEntitlements here -->
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile>
        <id>signed</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.panteleyev</groupId>
                    <artifactId>jpackage-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>create-installer</id>
                            <configuration>
                                <macSign>true</macSign>
                                <macSigningKeyUserName>${env.MAC_SIGNING_KEY_NAME}</macSigningKeyUserName>
                                <macEntitlements>${env.MAC_ENTITLEMENTS}</macEntitlements>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>

                <!-- temp fix until JDK 26 I hope -->
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.1.0</version>
                    <executions>
                        <execution>
                            <id>resign-with-entitlements</id>
                            <phase>package</phase>
                            <goals>
                                <goal>exec</goal>
                            </goals>
                            <configuration>
                                <executable>codesign</executable>
                                <arguments>
                                    <argument>--force</argument>
                                    <argument>--sign</argument>
                                    <argument>${env.MAC_SIGNING_KEY_NAME}</argument>
                                    <argument>--entitlements</argument>
                                    <argument>${env.MAC_ENTITLEMENTS}</argument>
                                    <argument>--options</argument>
                                    <argument>runtime</argument>
                                    <argument>--deep</argument>
                                    <argument>${project.build.directory}/jpackage/YourApp.app</argument>
                                </arguments>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Set the environment variables before running the signed build:

export MAC_SIGNING_KEY_NAME="Developer ID Application: Your Name (TEAMID)"
export MAC_ENTITLEMENTS="/path/to/entitlements.plist"
mvn package -Psigned

This keeps your local development builds fast and only runs the signing steps when you actually need them for distribution.

Like many technologists, I grew up glued to computers. Between my gaming addiction and my BBS operation (building and rebuilding systems in Telegard, Renegade, Wildcat, etc.), suffice it to say computers are a big part of who I am today. And now that I have 3 kids of my own (all under 6 years old), I want them to be able to explore computers the same way I did. Except, I don't. There is no way I'll give them the same freedom I had, as "computers" are now just black box portals into much darker and sinister things. Sadly.

I know what you're thinking: "get off my lawn, let the kids be kids, you had Leisure Suit Larry, Chad!". But remember, LSL was a text-based adventure that moved slowly from scene to scene, where you had to solve open-ended puzzles with text-based prompts and a few clues. No dark patterns, no in-game purchases (except for maybe a beer at Lefty's), no slot-machine sounds with flashing lights directly targeting dopamine receptors, no browsing to TikTok or YouTube for "walkthroughs" or even worse, to watch other people play the game. It was just me helping Larry look for love in all the wrong places.

OK, to be clear, I wouldn't let my kids anywhere near LSL if it existed today, but my point is, the world has changed. A lot. And my job as a family protector is to keep my kids away from 99.999% of the content out there.

But I'm not all rain clouds. I've found a few games along the way that we've enjoyed together. Games that are slow, thoughtful, creative, without mature undertones or messaging, and void of most dark patterns.

Below is my list, and if you have others, I'm looking for a few more.

Lumino City

Lumino City is excellent and a fun one to play together. The storyline is simple: a girl (Lumi) searches for her granddad, the city's handyman, who disappears in the beginning leaving behind his manual. The game is a slow, point-and-click adventure that progresses scene by scene, with a beautiful world that was created physically out of paper and glue and motors, and then brought to life digitally. How cool is that?

Old Man's Journey

Old Man's Journey features another great storyline that starts with an old guy getting a letter, and then going on a long journey across land, sea, and air, to find the sender of the note, with bits and pieces of his story revealed along the way. This one does have a love story with the loss of a loved one at the end, so although it's not mature content, it is definitely emotion-evoking, but that's a small part of the game as the rest meets all my criteria above.

Machinarium

Machinarium is a cute'ish robot game where you start outside the city putting the robot back together, and then proceed to solve puzzles going back through the city to find out what happened. It does present a robot love story where my daughter called them "mommy and daddy robots", and the game is slightly darker than the others because the world seems sort of "fun post-apocalypse", but it still meets most of my criteria and we enjoyed playing it.

Stardew Valley

Stardew Valley is slightly different as it is a non-linear open-world farming simulator, but it's super fun and quite kid-friendly as you can farm, fish, ride horses, chop down trees, buy chickens, goats, pigs, and build houses and rooms and stuff. There are a few things that are a bit more mature like love stories and dark caves with scary skulls that scared the kids a bit, but all of that stuff is mostly avoidable.

A Few Notable Ones

We did play Behind the Frame, which was a fun painting game with some mysteries along the way, but it got pretty weird and ended with what I think was the main character never forgetting her first love despite having a family. Too emo for me.

We also played Rival Stars Horse Racing because my daughter rides horses. It's kind of fun, but pretty advanced.

One of my sons is in love with tractors so we played Farming Simulator. Dude. I think it's easier to actually farm than play this simulator. When we actually got the tractor moving and stuff, he was over the moon.

That's mostly it on the computer front. As they get a bit older, I'll be exploring some basic circuits-type stuff, maybe super simple programming concepts, but with the same themes as above.

What do you think?

I suppose this is a good thing as I then can spend more time on higher leverage things, but it does raise a yellow flag given most of my career in tech has been in understanding the inner workings of things. But, I guess I haven't look at the kernal code, or my keyboard drivers, or the OS code, or Excel's code (nor do I have that), or anything else that has added layers of abstraction over the years.

Even this post itself, although 100% written by me [2] (I just can't use AI tools to write for me, the style bothers me beyond belief), I asked an agent to go and find my blog in my projects tree and add the post. It's even using the static site generator I created myself. What a world.

What's next?

[1] Yes, we used Ruby to launch the site quickly back in 2020, but we have since created two new Java static site generators and ported the site over to one of them, to be deployed soon alongside some new other new stuff we're building.

[2] Ok I used AI to create the image, obviously

Project 1: Building Speedcam

My first project, which is still ongoing, involves porting OpenCV code to Java's new FFM API for faster object detection. Specifically I have a camera at the front of our property on the road logging speeding offenders. It works, but it's pretty slow, and I'd like to keep the processing both batch oriented, and local. So far so good, but since the API is quite new and OS-specific compiling, linking, etc is complex, you reach the limits of how much even the best frontier models can handle. They mostly just keep regurgitating the same "fixes" probably buried in Stack Overflow and then get increasingly frustrated before giving up.

Project 2: Building Arc

Then I wanted to write about that experience, but I didn't have a blog, so I built a static site generator in Java that puts the HTML/CSS layout at the center, and uses tags and such to embed data. The Java code handles the magic but sort of hides behind the scenes. Many people believe the logic should be at the center of everything, and have the Java code spit out some HTML. This hurts my head, but I think philosophically it's the difference between someone that comes from a classic MVC background (like me), vs someone that comes from a more backend-centric world view.

Project 3: Building Bingo

Anyways, my third project, if you can even call it that, is ridiculously simple, even stupid (although we coach the kids not to call things stupid). My group is spread across the globe and we meet a few times a year on Zoom to just hang out and chat with no work agenda. But I try not to come empty handed and risk virtual-meeting crickets so I usually bring an ice-breaking game. At 6am, before our 9am meeting, I decided to give Claude Code a whirl to create an interactive Bingo game, and in about an hour, I had a board live that supports multiple rounds of questions, hot keys, a nice little ding when someone gets bingo, and with a bit of prompting I was able to narrow in on questions I thought were decent. And it turned out fun! At least it seemed fun. My team is obligated to tell me it was fun.

ICE

So why did I re-build a game that surely 100 sites offer, and then write yet-another-post on how AI wrote some HTML and JS that my dog could probably write after a few hours at dog code bootcamp? I guess what I find interesting is this trend towards, what I've decided to call the Individualized Creator Economy (maybe ICE isn't the most popular acronym right now but it felt better than Custom Creator Platform).

ICE is a return to custom software vs off-the-shelf or as-a-service models. It's the ability to vibe code (with human in the loop) exactly what you want in the amount of time it would take to search the Internet, give someone your email address, try out their thing, only to find out it wasn't what you thought, etc.

ICE is software limited only by one's creativity vs one's skillsets. This I think is the main point. Engineering is not just about writing code or soldering wires, it's about making something come alive. As a kid I used HyperCard to build choose-your-own-adventure games, and Telegard and Wildcat BBS to build BBS sites. As I got older I created companies and used code to make those come alive. Software has become increasingly powerful but also increasingly complicated. Part of what I loved about "serverless" was the notion of abstracting out the infra layer, and AI tools seem to be trending towards a world in which you can abstract out a lot of the heavy lift of code also -- limited by creativity.

ICE is moving faster while still following the rules of a larger organization. In my Bingo example, technically, I'm supposed to put all new software through a security review before using it for work. But this could take months, so having it ready by my 9am meeting is obviously untenable. Enter ICE -- where I can build it, and no sensitive data were harmed in the process. Maybe this is the biggest point here, IDK.

What do you think? Is this stupid your experience?

Since I work on the team that makes the Java Platform, I couldn't bare using some Javascript blog engine, so I built my own using Cursor and Claude-4-Opus. Enter, Arc.

It's not great. The code is like someone stuffed Stackoverflow and Baeldung into a blender and then blew it up with dynamite, but it took me about 5 hours (half of which was learning the tools), and I'm really curious if I can refactor my way into something broadly useful for others. All that said, it's really super fast, at least.

Arc is a static-site generator written in Java. It's basic function is to take Markdown files, mash them into some templates, and turn that all into plain-ole' HTML. I'm old school, and I have a core belief that HTML should be largely maintained as HTML, with some variables and control-flow built in, not littered throughout controller logic. Remember MVC? I liked that. Is it still a thing? Modern day JS frameworks hurt my brain.

Features:

• Converts Markdown files to HTML using CommonMark
• Supports YAML frontmatter for metadata
• Simple template system
• Variables: {{ variable }}
• Loops: {for post in posts}...{% endfor %}
• Conditionals: {% if variable %}...{% endif %}
• Includes: {% include "header.html" %}
• Has a built-in hot reload mode for development
• Uses jpackage to build a native executable

Also it's pretty fast. Here it is building this site:

❯ time arc
-------- STARTING ARC GENERATE() --------
Copied assets to: site/assets
Found 2 markdown posts to process
Found 4 markdown pages to process
Generated: posts/2025-05-28-building-arc.html
Generated: posts/2025-05-26-welcome-to-my-new-site.html
Generated: speaking.html
Generated: writing.html
Generated: index.html
Generated: about.html
-------- SITE GENERATION COMPLETE --------
arc 0.21s user 0.03s system 149% cpu 0.160 total

Using (if you already have the arc binary)

Using it to build your own site is super easy, you just run the arc command (or arc --watch for hot reloads) inside the directory where your app lives. That said, getting arc at this time requires building it.

The directory structure arc expects is as follows:

app/
├── posts/         # Blog posts in Markdown
├── pages/         # Static pages in Markdown  
├── templates/     # HTML templates
└── assets/        # CSS, JS, images
site/              # Generated output

You can find a sample template here.

Building the Arc Binary (and using it)

1. git clone https://github.com/carimura/arc
2. mvn clean package (this will compile and build the executable with jpackage)
3. Create a script in your path that points to the executable like so

#!/bin/bash
/path/to/arc/target/jpackage/arc.app/Contents/MacOS/arc "$@"

4. Go to your app directory (sample here) and just type arc or arc --watch for hot reloads.

5. cd site

6. jwebserver

7. go to `http://localhost:8000' and gasp at the simplicity. or the horror.

That's it!

The jpackage command that is happening inside Maven

jpackage
  --name arc
  --dest /path/to/arc/target/jpackage
  --type app-image
  --app-version 1.0
  --input /path/to/arc/target
  --main-class com.pinealpha.arc.Process
  --main-jar arc-1.0-SNAPSHOT-jar-with-dependencies.jar
  --java-options --enable-preview

TODO

• Maybe distribute native binaries for multiple platforms
• RSS feed
• template inheritance
• actually review the code in more detail, refactoring, cleanup

Conclusion

I dunno. AI wrote most of the code, so it pains me, but we refactored a little together so it pains me a little less. Then AI wrote this blog post, but the writing style made me cringe, so I completely rewrote it, feeling bad that my agent might find out and get hurt.

Anyways, it was fun. I have lots of thoughts on AI but I'll save those for another post on this fresh new blog.

To end, here's some ascii art from my AI friend about me and it (him?) coding together:

     👦                    🤖
    /|\                   /|\
    / \                   / \
   -----                 -----
  |     |               |     |
  |  💻 |               |  💻 |
  |_____|               |_____|
  
  "Let's build         "Affirmative.
   something cool!"     Initiating
                        collaboration
                        protocol."
                        
        ✨ Building Arc Together ✨

From shipping a feature to winning a new customer to finding out you're having a girl, the boom 💥 emoji has become lingua franca to concisely express one's emotions. A few weeks ago I received an email from a former investor:

"Did I make the BOOM icon in Slack? (Indirectly through you?)

Would you blog that shit so I can tell the story over pints and not be called a lying a-hole."

The answer to his question is yes. At least I think. So. Here's his blog post.

We created the original boom 💥 emoji in 2012

The investor who sent the email above happened to be our first Iron.io investor in 2010, and following our progress whenever something exciting would happen he'd respond with "boom!". This became common speak in our company, even across multiple countries and languages.

When we started using Hipchat in 2011, we had to settle for simply using the English word, but then I found they'd make a custom emoji for your company when referring a customer. This might seem very uneventful now, but in 2011, a custom emoji was a big deal.

So on January 3rd, a buddy of mine sent the following email to Pete Curley's (founder of Hipchat) automated feedback request email:

Date: January 3, 2012
From: Brian Glynn
To: Pete Curley

"Great! Nice service. Unless something changes we'll definitely be continuing with the service.

On a related note, I'm hanging out with my buddy Chad Arimura cofounder of Iron.io. I didn't give him proper referral credit when signing up, and he's eager for his custom emoticon. Can you retroactively hook him up?"

And after a few iterations with our longtime designer, Andy Burkovetsky, we came up with a pretty sweet animation sequence:

(Thanks to Luke Stephen Rehmann for the explosion of our explosion in comments)

and sent the following email:

Date: February 10, 2012
From: Chad Arimura
To: Pete Curley

Pete!

Here's the first generation of our new HipChat icon. We'd love to rev it down the road when we have more time. Feel free to snake it for your own uses if you like it. We think it's sorely needed to express our emotions when someone does something awesome.

(boom)

Chad

And his response:

Date: February 11, 2012
From: Pete Curley
To: Chad Arimura

Just put it in. It'll take a few hours for it to show up for everyone on your team. Boom.

--

Pete Curley
Co-Founder, HipChat.com

And lo and behold, the fruits of our labor:

Going Global

A month later, I was hanging out in the Atlassian office (they were partners of ours at Iron.io) and I think it was Garret (or maybe Pete) walked in and I was excited to show them the sweet sweet emoji and recommended they make it global. Again, this was a big deal back then.

Shortly after that, we noticed that they agreed and made the emoji global. I was bummed they didn't let me know, but they had just gotten acquired so they were busy doing acquiree things.

And shortly after that, Slack dominated the scene, and :boom: 💥 (animation and all at the time) became a global option, obviously inspired by Hipchat's global emoji set.

So that's the story.

We probably can't take full credit. In doing 3 minutes of research for this blog post, I realize now that :collision: was part of Unicode 6.0 in 2010, but this certainly was nowhere on our radar, and certainly no option in Hipchat. Standard Unicode Emoji 1.0 didn't arrive until 2015. "Boom" isn't on the list, but it's global in Slack and predictive in iOS as well.

Jonathan, you owe me a pint for writing this.

Boom.

Chad

SimpleWorker from 2010

Last month, Iron.io was acquired by Xenon Ventures. Many of the team members are staying and will continue to grow the business and actively develop IronWorker and IronMQ. Customers are in great hands and should expect to see operational excellence, innovation, and best-in-class service. We wouldn't have sold the business to anyone unwilling to carry the torch of "customer love".

It's been amazing to watch serverless really take shape. Who would have thought building a serverless search engine and the future is serverless from 6 years ago would foreshadow an entire category of computing? I still remember talking about tasks as the atomic unit of compute (most people saying Functions now), and small units of LXC-containerized jobs being an essential pattern of the future (Docker now). Now there are serverless conferences, serverless podcasts, serverless analysts, and even emerging serverless standards. Where did all the servers go?

As for what's next, rather than start something new and spend years getting to a point of impact, me, Travis, and some members of the Iron engineering team will be joining Oracle to spearhead major initiatives around developer experience. This ship is sailing, and it's sailing fast. That's all I can say for now, but with the momentum, vision, and seriously amazing team I've met in my first few week here, you can expect a lot coming soon that will reshape preconceptions.

Thank you all for the support over the years, especially the team both current and former, our investors, advisors, my friends, and my wife. The CEO role can be a lonely one, but I never felt alone. There are many more platitudes when parting with something that's been a part of you for the better-half of a decade so I'll leave it at that.

Find me on LinkedIn, Twitter, this blog, and email to stay in touch.

Much love, Chad

* "Thanks and onward" was an email signature from one of my investors back in 2011. I figured an appropriate title.