In the small town of Kawara in Fukuoka Prefecture, some­thing un­ex­pected is hap­pen­ing at the Saidosho Community Center. While kids in most parts of Japan are ob­sessed with Pokémon cards — or per­haps the fran­chise’s lat­est smart­phone game, Pokémon TCG Pocket — the chil­dren of Kawara are clutch­ing to some­thing a lit­tle closer to home.

They are play­ing a trad­ing card game (TCG) where the stars aren’t fan­tasy crea­tures, anime he­roes or even fa­mous base­ball play­ers, but ojisan (middle-aged or older men) from the lo­cal com­mu­nity of Saidosho.

On the sur­face, this Ojisan TCG looks like any other col­lectible card game. As of March 18, there are 47 dif­fer­ent cards in the col­lec­tion, in­clud­ing 28 fea­tur­ing lo­cal men with stats and spe­cial abil­i­ties.

Take the Firewall card, for ex­am­ple. It fea­tures Mr. Honda (74), a for­mer fire brigade chief who helped keep the town safe for decades. Then there’s Soba Master Mr. Takeshita (81), who runs a lo­cal soba noo­dle-mak­ing class and now holds leg­endary sta­tus among the town’s youth.

The most pop­u­lar of them all is prob­a­bly All-Rounder Mr. Fujii (68), a for­mer prison of­fi­cer turned com­mu­nity vol­un­teer. His card is so sought af­ter that lo­cal kids have even started ask­ing him for au­to­graphs.

“I was hon­estly shocked when they asked me to sign it,” Mr. Fujii said, laugh­ing. “I never imag­ined I’d be­come a trad­ing card, let alone have fans.”

Each card comes with dif­fer­ent at­tacks and an as­signed el­e­men­tal type — just like a clas­sic fan­tasy card game — but with a hu­mor­ous, real-world edge. For in­stance, Firewall is, un­sur­pris­ingly, a fire type, equipped with a Super Guard move, which deals a hefty 200 dam­age.

A card called Plasma Conductor, fea­tur­ing a smil­ing, be­spec­ta­cled ojisan jux­ta­posed with an im­age of a light­bulb, is an elec­tric type. At the bot­tom of the card, there is a line of text ex­plain­ing how he can fix any elec­tri­cal ap­pli­ance with­out fail.

The cre­ator of the game is Eri Miyahara, the Secretary General of the Saidosho Community Council.

“We wanted to strengthen the con­nec­tion be­tween the chil­dren and the older gen­er­a­tions in the com­mu­nity. There are so many amaz­ing peo­ple here. I thought it was such a shame that no one knew about them,” she said in an in­ter­view with Fuji News Network (FNN). “Since the card game went vi­ral, so many kids are start­ing to look up to these men as heroic fig­ures.”

The plan worked. Kids have started at­tend­ing lo­cal events and vol­un­teer­ing for com­mu­nity ac­tiv­i­ties — just for a chance to meet the ojisan from their cards. Participation in town events has re­port­edly dou­bled since the game launched.

Interestingly, Ojisan TCG did­n’t start as a com­pet­i­tive game. The first set of cards was de­signed purely for col­lect­ing, but the lo­cal chil­dren quickly turned it into some­thing more dy­namic. They be­gan com­par­ing stats and de­clar­ing, “My card is stronger than yours.”

Seeing this, the game’s cre­ator de­cided to take it to the next level. New rules were in­tro­duced, al­low­ing the cards to be used in ac­tual bat­tles. The ob­jec­tive is­n’t to de­feat the op­po­nen­t’s card but to out­play it based on the char­ac­ters’ skills and abil­i­ties.

The rar­ity of a card is­n’t based on fan­tasy stats — it’s tied to real-world con­tri­bu­tions. The more ac­tively the ojisan en­gages in vol­un­teer work or com­mu­nity ser­vice, the higher the chances of their card be­ing up­graded to a shiny ver­sion with a glossy lam­i­nated ef­fect.

While the cards — all made en­tirely by hand — are cur­rently in high de­mand and of­ten out of stock, they are only avail­able for sale at the Saidosho Community Center.

A pack of three cards costs ¥100, while a pack of six cards — in­clud­ing a shiny card — costs ¥500. Despite the lim­ited sup­ply, de­mand re­mains high, with many kids sav­ing their pocket money for a chance to score a shiny ver­sion of their fa­vorite ojisan.

I’m new to Substack—this is my first post.

Hey, I’m Matt. I founded Vizzly as a first-time en­tre­pre­neur and ex­ited in un­der three years, sell­ing the com­pany to WPP, the world’s largest ad­ver­tis­ing or­ga­ni­za­tion. A few months af­ter start­ing the com­pany, we were ac­cepted into Y-Combinator, and I spent about four months en­grossed in San Francisco’s tech hus­tle cul­ture learn­ing from peo­ple much smarter than I. I’m not anti-SF (far from it; I have some in­cred­i­ble mem­o­ries there), but I did­n’t buy into the all-or-noth­ing mind­set of star­tups.

It’s worth not­ing that af­ter Demo Day, we set out to raise more than we ended up with—es­sen­tially, a failed Seed round. At the time, I saw this as a neg­a­tive, as­sum­ing fundrais­ing was a form of val­i­da­tion (turns out it’s not, by the way).

A year later, I came to re­al­ize that this was the best thing to hap­pen to both the com­pany and my­self. For starters, it forced us to be­come very rev­enue-cen­tric.

Additionally, it opened the door to smaller ac­qui­si­tions. Because our pref­er­ence stack (more on this later) was tiny, even a rel­a­tively small deal would pro­duce a life-chang­ing out­come for the found­ing team.

Writing this, I could go in a mil­lion di­rec­tions—and I prob­a­bly will in fu­ture posts, div­ing into dif­fer­ent as­pects. For now, I’ll fo­cus on the ‘missing mid­dle path.’

On my LinkedIn feed, it feels like there are two dom­i­nant nar­ra­tives in B2B SaaS: the VC path—go big or go home, maybe take a sec­ondary at Series A or B, but push hard no mat­ter what—or the Bootstrapper route—build sus­tain­able value with an as­set you own on a shoe­string bud­get, and reap the re­wards of cash flow and div­i­dends.

What’s rarely talked about is the third path: raise a small amount—say, less than $1M—while keep­ing 90%+ of your eq­uity, avoid­ing board seats, and build­ing for prof­itabil­ity and strong as­set value. All with­out drain­ing your per­sonal fi­nances or spend­ing a decade boot­strap­ping through rev­enue.

The rea­son it’s not more pop­u­lar is that it’s a founder-cen­tric ap­proach that does­n’t fit the ven­ture cap­i­tal model, mak­ing it a con­tro­ver­sial stance. In fact, if you pitched this path­way to a VC, I’m sure they’d ghost you quicker than their last Hinge date.

In short: the top 3% of in­vest­ments are ex­pected to re­turn the fund and more. So, if you’re aim­ing for a $10M out­come, they won’t be in­ter­ested. Success and re­turns of­ten in­crease with more fund­ing, which is why VCs push for con­stant fundrais­ing. With a pref­er­ence stack, they get paid back first, leav­ing you ef­fec­tively in debt. This forces you to scale to jus­tify the time and ef­fort needed to gen­er­ate a mean­ing­ful out­come.

For those won­der­ing what a pref­er­ence stack is, it’s ba­si­cally the or­der in which dif­fer­ent in­vestors get paid when a startup is sold or liq­ui­dated. You might see a head­line in TechCrunch say­ing a startup has sold for $40M. For all you know, they raised $30M, grinded for eight years, and the deal is 10% cash and 90% eq­uity ex­change—mean­ing the founders in­volved (assume there are two) are ba­si­cally ex­chang­ing over­in­flated eq­uity that will prob­a­bly be sub­ject to a four-year vest.

This is ob­vi­ously a hy­po­thet­i­cal and a great out­come based on the prob­a­bil­ity of a star­tup’s suc­cess, but it’s still a pretty mod­est out­come if you think that’s 12 years of prime life one would have sac­ri­ficed (sorry, in­vested).

I have an in­cred­i­ble amount of ad­mi­ra­tion for folks on the ven­ture jour­ney — it’s high risk, high re­ward, as I do for folks who boot­strap and pur­sue a more un­con­ven­tional route. The prob­lem with boot­strap­ping is sim­ple: not every­one can sus­tain it.

Many boot­strapped B2B SaaS star­tups were agen­cies be­fore­hand, such as Mailchimp, Basecamp, Lemlist, etc. I prob­a­bly don’t need to la­bor this point too much, but this path­way can also take a re­ally long time to cre­ate and drive value.

Of course it’s sub­jec­tive, but I think the mid­dle path pro­vides the op­ti­mal com­bi­na­tion of re­turn size, time to re­turn, all with min­i­mal fi­nan­cial risk to the founders in­volved. For most B2B SaaS busi­nesses, you should­n’t need more than $1M in cap­i­tal to get to PMF, find a GTM mo­tion that works (not that it needs to scale), and reach an ARR fig­ure where the rev­enue mul­ti­ple for val­u­a­tion starts to look pretty tasty—enough to of­fer sig­nif­i­cant up­side even af­ter in­vestors are paid out.

What no VC will tell you is that there’s a win­dow of op­por­tu­nity — some­where be­tween Pre-Seed and Series A — where founders can tap into sig­nif­i­cant up­side. This is rarely dis­cussed, and too many com­pa­nies fail be­cause they raise too much, only to end up with lit­tle to noth­ing in a liq­ui­da­tion event (as de­scribed above).

We stum­bled into the mid­dle path, and I’m grate­ful for it.

There are still draw­backs and im­por­tant fac­tors to con­sider—par­tic­u­larly how you choose to source your in­vest­ment. While most VCs may not align with this phi­los­o­phy, an­gel in­vestors are gen­er­ally more open to a 2-3x ROI.

As with every­thing, there are trade-offs. The key is un­der­stand­ing your val­ues, defin­ing what you want from the jour­ney and the out­come, and know­ing what you’re will­ing—and, more im­por­tantly, un­will­ing—to sac­ri­fice along the way. Once you have that clar­ity, you can make an in­formed de­ci­sion about the fi­nanc­ing route to pur­sue.

* A mid­dle path ex­ists; you don’t need a moon­shot or boot­strap­ping.

* There’s a sweet spot be­tween Pre-Seed and Series A.

* Know your ‘why’ and avoid get­ting drawn into a jour­ney you don’t need.

In fu­ture posts—or dur­ing caf­feine-in­duced stints of mo­ti­va­tion—I’ll dive deeper into top­ics such as fundrais­ing, M&A, GTM, PMF and a few other need­less acronyms.

My fa­vorite part about get­ting older is that some­times I wake up at 3:30 AM for no rea­son and can’t fall back asleep. This hap­pened this week­end and by 5:30 or so I had ex­hausted my usual phone games (Wordle, Quordle, Blossom, Immaculate, Strands, etc). Reading my book about the ex­tinc­tion of the di­nosaurs and re­watch­ing the 9th in­ning of a thrilling Texas base­ball win only woke me up more.

Then I saw an ar­ti­cle from Axios about how travel to the US from other coun­tries fell off a cliff in March. As a true nerd, what ex­cited me about the ar­ti­cle was that they linked to an of­fi­cial gov­ern­ment data source that I was­n’t fa­mil­iar with.

I went to the CBP’s Average Wait Time web­site and found a rich dataset that can be ex­tremely use­ful for de­scrib­ing cur­rent trends. The sys­tem is kind of clunky in that you have to se­lect in­di­vid­ual agen­cies and ter­mi­nals, and the on­line data ap­pears to only go back for 3 years de­spite the data col­lec­tion start­ing in 2008.

But the data was eas­ily ex­portable and, with a lit­tle bit of el­bow grease, you can break down US and non-US pas­sen­gers be­ing processed by CBP each and every day at the na­tion’s busiest in­ter­na­tional air­ports. That’s re­ally use­ful for show­ing if, say, some sort of pol­icy had been im­ple­mented that was mak­ing peo­ple from abroad ques­tion whether they should come to the U. S.

Having down­loaded the data for 8 of the busiest air­ports in the coun­try I wanted to show how en­tries are chang­ing. Travel can be very sea­sonal so I wanted to com­pare this year to the same time last year. And I rolled it over 30 days to be able to show any re­cent changes while not get­ting lost in the noise of daily change.

The re­sult is be­low:

The last 30 days in this group of ma­jor air­ports has seen a greater than 10 per­cent re­duc­tion in for­eign trav­el­ers be­ing processed. I sent out an early ver­sion of this graph on Bluesky and some at­ten­tion was paid to it. This im­me­di­ately made me ner­vous be­cause there is al­ways the risk of sys­temic un­der­re­port­ing any time you’re work­ing with very re­cent data.

Working with the CBP data im­me­di­ately made me think about sim­i­lar con­cerns when that come to mind when work­ing with crime data — es­pe­cially early in the year.

I’ve talked be­fore about how much I like the Texas Department of Public Safety Uniform Crime Report web­site. It gives you a ton of op­tions for down­load­ing pretty much every­thing Texas is re­port­ing to the FBI as soon as agen­cies re­port it to the state.

San Antonio Police Department is one agency that does a great job of post­ing the most re­cent com­pleted mon­th’s data early in the fol­low­ing month. The February 2025 data for SAPD, for ex­am­ple, was pub­lished very early in March 2025. So if I want to see how thefts this year com­pare to last year I can eas­ily pull up the YTD NIBRS re­port and there it is!

Some back of the spread­sheet math points to an 18 per­cent de­cline in theft of­fenses in San Antonio through February 2025 com­pared to the first two months of 2024.

But you have to be care­ful when us­ing this data.

Running an Ad Hoc Query on thefts in San Antonio this year clearly shows why. This re­port lets you break down of­fenses by type and day. There were 121 thefts re­ported per day in San Antonio be­tween January 1 and February 18, 105 per day from February 19 through 24, and 88, 67, 75, and 18 on February 25, 26, 27, and 28 re­spec­tively.

Law en­force­ment agen­cies have over a year un­til they have to sub­mit fi­nal 2025 data to the FBI, so these num­bers will be ad­justed (usually up). The January num­bers are prone to ad­just­ment as well though the amount of change tends to di­min­ish sub­stan­tially af­ter a month or two.

Theft fell 5 per­cent in San Antonio in 2024 and the early data from January and February points to a de­cline so far in 2025. But un­cer­tainty with the data sug­gests cau­tioned is war­ranted when guessti­mat­ing what that de­cline may end up be­ing.

Carl Sagan preached that ex­tra­or­di­nary claims re­quire ex­tra­or­di­nary ev­i­dence. Claiming that theft in San Antonio is falling a lot is­n’t ex­actly ex­tra­or­di­nary, but the de­gree of de­cline shown in the topline fig­ures screams for more ev­i­dence to sub­stan­ti­ate it. The closer look helps to eval­u­ate and con­tex­tu­al­ize the like­li­hood of a de­cline so far this year al­low­ing for an ap­pro­pri­ate level of an­a­lytic cau­tion.

Which brings us back to an­a­lyz­ing air trav­el­ers com­ing to the US.

As I said, I’d never worked with this dataset un­til very re­cently, so it made me ner­vous that my first us­age pointed to a huge, sud­den, very re­cent de­cline. One easy way to fig­ure out if the de­cline was a real change or a data re­port­ing is­sue is to do the same process but for US trav­el­ers be­ing processed by CBP. I as­sume that US trav­el­ers haven’t changed be­hav­ior, so if there’s a huge de­cline there then we’re prob­a­bly look­ing at a data re­port­ing is­sue.

Here is what we get do­ing this ex­er­cise with New York’s JFK air­port.

And just for fun I did Orlando which shows a wild change:

All four air­ports show an iden­ti­cal trend over the last 30 days with a huge drop in non-US pas­sen­gers go­ing through CBP pro­cess­ing and an in­crease in US pas­sen­gers which does­n’t stand out. This strongly sug­gests that what we’re see­ing is not slow data en­try — be­cause I’d ex­pect US and non-US pas­sen­gers to show the same trend if that was the case.

Then, to be sure it is­n’t a data re­port­ing is­sue I went back the next day and down­loaded the last week of CBP pro­cess­ing at JFK. The old data showed 260,250 en­tries be­tween 3/29 and 4/3/2025 while the newly up­dated data showed 260,250 en­tries over that span. An ex­act match gives very strong con­fi­dence that we’re see­ing a trend rather than a data is­sue here.

There are quirks in the data that need to be re­mem­bered when con­tex­tu­al­iz­ing the data.

Travelers head­ing to the US from Canadian air­ports tend to go through cus­toms at the Canadian air­port so the data we have now may ac­tu­ally be un­der­stat­ing the de­cline. And some posters on Bluesky pointed out that Easter is much later this year which may mean fewer trav­el­ers to Orlando for Spring Break, but no such im­pact ex­ists with Easter 2024 be­ing ear­lier than Easter 2023, so I’m skep­ti­cal that it’s play­ing much of a role.

The ev­i­dence clearly shows that for­eign­ers have stopped com­ing to the United States as much as they were at this point last year. This newslet­ter does­n’t delve into pol­i­tics, and the rea­son for this change is both pretty ob­vi­ous and not in need of fur­ther dis­cus­sion here.

From a data per­spec­tive, how­ever, it’s an in­ter­est­ing case study in find­ing an im­por­tant trend and work­ing to en­sure what you’re see­ing is real. This is an is­sue that de­serves close at­ten­tion as time goes on and the CBP’s dataset is a great way to fol­low it to see if things get bet­ter, worse, or stay the same as the year goes on.

What is this?If you want to au­to­mate ac­tions on a web­site, like re­peat­edly fill out a form, you nor­mally can’t do it with AI apps like Cursor or Claude be­cause they don’t have ac­cess to a web browser. With Browser MCP, you can con­nect AI apps to your browser so they can au­to­mate tasks on your be­half.

Speed up and au­to­mate your work­flowsEn­able your AI ed­i­tor to au­to­mat­i­cally test your code end-to-end. Test user flows, val­i­date UI el­e­ments, and en­sure your ap­pli­ca­tion works as ex­pected across dif­fer­ent sce­nar­ios. Automate repet­i­tive web-based tasks with ease. From data col­lec­tion and form fill­ing to work­flow au­toma­tion, save time and re­duce er­rors in your day-to-day op­er­a­tions.

Automation hap­pens lo­cally on your ma­chine, re­sult­ing in bet­ter per­for­mance with­out net­work la­tency. Since au­toma­tion hap­pens lo­cally, your browser ac­tiv­ity stays on your de­vice and is­n’t sent to re­mote servers.Uses your ex­ist­ing browser pro­file, keep­ing you logged into all your ser­vices.Avoids bot de­tec­tion and CAPTCHAs by us­ing your real browser fin­ger­print.

Get started with Browser MCP in three sim­ple step­sAdd the Browser MCP ex­ten­sion to your browser. Add the Browser MCP server to your AI ap­pli­ca­tion to con­nect with the browser ex­ten­sion.Be­gin cre­at­ing au­to­mated work­flows and let your AI as­sis­tant han­dle repet­i­tive tasks in your browser.

Everything you need to au­to­mate your browserGo for­ward to the next page­Wait for a spec­i­fied time in sec­ondsPer­form drag and drop be­tween two el­e­ments­Get the con­sole logs from the browser

is a re­viewer cov­er­ing lap­tops and the oc­ca­sional gad­get. He spent over 15 years in the pho­tog­ra­phy in­dus­try be­fore join­ing The Verge as a deals writer in 2021.

is a re­viewer cov­er­ing lap­tops and the oc­ca­sional gad­get. He spent over 15 years in the pho­tog­ra­phy in­dus­try be­fore join­ing The Verge as a deals writer in 2021.

JPGs are ready to post just about any­where, while RAWs yield an un­fin­ished file filled with ex­tra data that al­lows for much richer post-pro­cess­ing. That op­tion for a RAW file (and even the generic name, RAW) has been stan­dard­ized across the cam­era in­dus­try — but de­spite that, the cam­era world has never ac­tu­ally set­tled on one stan­dard­ized RAW for­mat.

Most cam­eras cap­ture RAW files in pro­pri­etary for­mats, like Canon’s CR3, Nikon’s NEF, and Sony’s ARW. The re­sult is a world of com­pat­i­bil­ity is­sues. Photo edit­ing soft­ware needs to specif­i­cally sup­port not just each man­u­fac­tur­er’s file type but also make changes for each new cam­era that shoots it. That cre­ates pain for app de­vel­op­ers and early cam­era adopters who want to know that their pre­ferred soft­ware will just work.

Adobe tried to solve this prob­lem years ago with a uni­ver­sal RAW for­mat, DNG (Digital Negative), which it open-sourced for any­one to use. A hand­ful of cam­era man­u­fac­tur­ers have since adopted DNG as their RAW for­mat. But the largest names in the space still use their own pro­pri­etary files. And there’s no sign of that chang­ing any­time soon.

Some smaller cam­era man­u­fac­tur­ers have been us­ing the DNG for­mat for years, while oth­ers like Sigma have adopted it more re­cently. The whole point of DNG is to of­fer flex­i­bil­ity, ease of use, and ide­ally, a lit­tle more fu­ture­proof­ing — since the for­mat is open to use and roy­alty-free.

DNG was cre­ated in 2004 by Thomas Knoll, one of the co-cre­ators of Photoshop, and was based on the even older TIFF im­age spec­i­fi­ca­tion. DNG is ca­pa­ble of hold­ing ad­di­tional cam­era meta­data em­bed­ded within it. While other RAW for­mats are usu­ally cou­pled with an XMP side­car file for stor­ing meta­data, DNG is slightly stream­lined since it’s just one file that al­lows non­de­struc­tive meta­data ed­its within it.

Regardless of which cam­era brand you use, a RAW pro­cess­ing work­flow is mostly the same: you take a pic­ture, im­port it to a com­puter, open and process the file us­ing edit­ing soft­ware, and then ex­port a “finished” file in a uni­ver­sal for­mat (like JPG) for shar­ing or print­ing. Where things of­ten get the messi­est is with soft­ware com­pat­i­bil­ity.

Sigma: “Adding pro­pri­etary data al­lows the cam­era in­for­ma­tion to be given more ac­cu­rately to the de­vel­op­ing soft­ware. However, it is less ver­sa­tile,” Sigma said in a state­ment pro­vided by US PR rep Jack Howard. (Some of its cam­eras use DNG, while oth­ers use the pro­pri­etary X3F for­mat.)

Pentax: “The ad­van­tage of pro­pri­etary for­mats is that they can evolve on their own; the dis­ad­van­tage is that they may not be sup­ported by third-party ap­pli­ca­tions,” said Shigeru Wakashiro, General Manager of Product Planning for Ricoh Imaging Company (which owns Pentax). Of course, Pentax is the lone man­u­fac­turer that gives users a choice be­tween a pro­pri­etary PEF file and DNG. The Ricoh ex­ec­u­tive added, “The dis­ad­van­tage of us­ing DNG is that if all man­u­fac­tur­ers use the DNG for­mat, it will be dif­fi­cult to man­age the for­mat sep­a­rately for each man­u­fac­turer.”

Sony’s soft­ware for pro­cess­ing ARW RAW files is called Imaging Edge. Like most first-party soft­ware from cam­era man­u­fac­tur­ers, it’s ter­ri­ble and un­in­tu­itive to use — and should be saved for sit­u­a­tions like a high-res­o­lu­tion mul­ti­shot mode where it’s the only method to use a cam­er­a’s pro­pri­etary fea­ture. The same goes for other first-party apps like Canon Digital Photo Professional and Nikon NX Studio.

The only other time it may be nec­es­sary to use those apps is if you buy a cam­era as soon as it’s re­leased and its RAW files aren’t yet sup­ported by Adobe or other soft­ware mak­ers. That mo­ment of fric­tion is when a pro­pri­etary RAW for­mat is most an­noy­ing, pri­mar­ily af­fect­ing early adopters. It’s a re­stric­tion that se­verely af­fects cam­era re­view­ers and YouTubers, who of­ten can’t try out RAW files in any ini­tial hands-on test­ing.

Getting that soft­ware sup­port out to users as soon as pos­si­ble takes a bunch of test­ing and work, and it’s not al­ways com­pleted as quickly as new cam­era own­ers would like. “For new cam­eras, this means mak­ing sure that we add sup­port for new or changed be­hav­iors in RAW file for­mats,” Eric Chan, a dig­i­tal imag­ing fel­low at Adobe, tells The Verge. “For ex­am­ple, new com­pres­sion modes, cap­ture modes such as High Dynamic Range and more. In ad­di­tion, mea­sur­ing each new de­vice sen­sor for char­ac­ter­is­tics such as color and noise.”

“I have yet to hear a good rea­son for us­ing pro­pri­etary RAW for­mats. The un­der­ly­ing data is the same. If a man­u­fac­turer comes up with ad­di­tional data that is­n’t in­cluded in the DNG stan­dard, the for­mat is ex­ten­si­ble enough that a cam­era man­u­fac­turer can throw it in there, any­way.” That’s what Ben Sandofsky, de­vel­oper at Lux Optics, mak­ers of Halide, told me. So maybe some cam­era brands are set in their ways and like hav­ing full con­trol. Ultimately, we’re sort of at their mercy and whether they choose to be more guarded with a pro­pri­etary for­mat or use an open one like DNG.

Knowing where your en­gi­neer salary comes fromWith the re­cent flurry of US fed­eral fir­ings, many peo­ple are point­ing and laugh­ing at the Trump-voting fed­eral em­ploy­ees who are just now find­ing out that they’ve voted for them­selves to be let go. How could you have this poor a men­tal model of what your job even is? Well. In my opin­ion, many soft­ware en­gi­neers are op­er­at­ing un­der a men­tal model that’s just as bad, and are of­ten do­ing the equiv­a­lent of vot­ing for the per­son promis­ing to fire them.

I won’t quote the tweets, but I reg­u­larly see sto­ries like “I con­vinced my id­iot bosses to fi­nally let me do only tech debt work, and would you be­lieve they fired me af­ter a few months?” Or “I’ve been bust­ing my ass on this un­der­funded pro­ject and I still got a bad per­for­mance re­view”. Or “it’s so un­fair that I haven’t been pro­moted - look at all this amaz­ing ac­ces­si­bil­ity/​stan­dards/​open-source work I’ve been do­ing!” The ba­sic struc­ture goes like this:

A bright-eyed en­gi­neer joins a tech com­pany, ex­cited to go and make the world a bet­ter place

They throw them­selves into var­i­ous pieces of work that don’t make money (improving FCP per­for­mance, bet­ter screen­reader sup­port, refac­tor­ing)

Their man­agers des­per­ately try to redi­rect them to work that does make money, caus­ing a long frus­trat­ing power strug­gle

Eventually the bright-eyed en­gi­neer gives up and un­hap­pily fo­cuses on Profitable Product X, or

The bright-eyed en­gi­neer leaves or is fired, and goes on Twitter to com­plain about their im­por­tant work not be­ing val­ued

The com­plaint in this story is ba­si­cally equiv­a­lent to “I can’t be­lieve Trump is fir­ing me from the IRS when I voted for the guy”. It rep­re­sents a fun­da­men­tal mis­un­der­stand­ing of what tech com­pa­nies are.

So what is the right un­der­stand­ing? Let’s start as sim­ple as pos­si­ble. Tech com­pa­nies are run by small groups of peo­ple with the goal of mak­ing money. Successful tech com­pa­nies make a lot of money, by de­f­i­n­i­tion. They hire soft­ware en­gi­neers in or­der to con­tinue do­ing the things that make that money, or to do new things that make more money.

At suc­cess­ful tech com­pa­nies, en­gi­neer­ing work is val­ued in pro­por­tion to how much money it makes the com­pany (directly or in­di­rectly). Patrick McKenzie has an ex­cel­lent post on this:

Profit Centers are the part of an or­ga­ni­za­tion that bring in the ba­con: part­ners at law firms, sales at en­ter­prise soft­ware com­pa­nies, “masters of the uni­verse” on Wall Street, etc etc. Cost Centers are, well, every­body else. You re­ally want to be at­tached to Profit Centers be­cause it will bring you higher wages, more re­spect, and greater op­por­tu­ni­ties for every­thing of value to you. It is­n’t hard: a bright high schooler, given a para­graph-long de­scrip­tion of a busi­ness, can usu­ally iden­tify where the Profit Center is. If you want to work there, work for that. If you can’t, ei­ther a) work else­where or b) en­gi­neer your trans­fer af­ter join­ing the com­pany.

Companies value work more the closer it is to a profit cen­ter. I don’t think you nec­es­sar­ily have to work in profit cen­ters (in most tech com­pa­nies, that would mean aban­don­ing your en­gi­neer­ing ti­tle and role). But you need to demon­strate your value to the profit cen­ter in or­der for your own work to be val­ued. I’m not say­ing you need to do this to keep your job. Companies pay lots of peo­ple who don’t de­liver value, some­times for many years. What I’m say­ing is this:

If your work is­n’t clearly con­nected to com­pany profit, your po­si­tion is un­sta­ble

In other words, you’re prob­a­bly de­pend­ing on a kind-hearted man­ager (or CEO) who per­son­ally val­ues your work. When they leave, you’re in trou­ble. Or you’re de­pend­ing on a large com­pany not re­ally car­ing to check if a small team is bring­ing in prof­its. When they look, you’re in trou­ble. Or you’re de­pend­ing on a cul­tural cli­mate where your work has tem­po­rary cul­tural ca­chet (e.g. bio­fu­els in the early 2000s). When that changes, you’re in trou­ble. The only way to have a sta­ble po­si­tion is to be con­nected to the way the com­pany makes money.

In or­der to know if your work is con­nected to com­pany prof­its, you have to know two things:

What is your com­pa­ny’s busi­ness model? How do they make money?

How does your work sup­port the busi­ness model?

Publicly traded com­pa­nies must pub­lish their busi­ness model and fi­nances every year, which means you can ei­ther just go read that or read what peo­ple are writ­ing about it on busi­ness blogs, mag­a­zines, and so on. (If you’re work­ing for a well-known com­pany, you can prob­a­bly just ask a LLM). If you’re work­ing for a pri­vate com­pany, that can be harder, but usu­ally it’s not too hard to get the gist. For in­stance, the broad strokes of where Valve get their money from are pretty clear: it’s Steam, not their first-party games.

Being an en­gi­neer at a com­pany will give you much more vis­i­bil­ity into the busi­ness model. For in­stance, you can run an­a­lyt­ics queries that iden­tify the ten largest cus­tomers. Often you won’t have to run these queries di­rectly - they’ll be shared among the prod­uct-and-busi­ness folks, in chan­nels that most en­gi­neers have no in­ter­est in. It’s worth try­ing to learn about the busi­ness model. For in­stance, if I were work­ing for Valve, I’d want a much clearer an­swer than “it’s Steam”: I’d want to know which kind of games were bring­ing in the most money, the dis­tri­b­u­tion be­tween new users and ex­ist­ing users, and so on.

Once you have an idea how your com­pany makes money, you can gauge how your work sup­ports it. If you build a prod­uct that many peo­ple are buy­ing, this is easy: cal­cu­late how big a per­cent­age of com­pany profit your prod­uct is. What if you don’t build a prod­uct? Say you’re on the ac­ces­si­bil­ity team, or the German lo­cal­iza­tion team. In that case, you ought to fig­ure out why your com­pany is in­vest­ing in these things. For ex­am­ple, work­ing on ac­ces­si­bil­ity might be valu­able be­cause:

It al­lows us to sell to (e.g.) vi­su­ally-im­paired cus­tomers, grow­ing the to­tal ad­dress­able cus­tomer base by X%

It en­ables us to meet spe­cific reg­u­la­tory re­quire­ments that al­low us to sell to large en­ter­prise cus­tomers (e.g. gov­ern­ments)

It makes us look good, or at least avoids us look­ing bad

It’s just good work that is worth do­ing be­cause it’s the right thing to do

Some rea­sons are only im­por­tant when times are good. If the com­pany is do­ing great and has more money than it knows what to do with, the last two points are prob­a­bly worth spend­ing money on. (If the com­pany is do­ing re­ally great, like a lot of com­pa­nies in 2019, “literally any­thing” is worth spend­ing money on in or­der to ac­cu­mu­late en­gi­neers). When in­ter­est rates rise, those rea­sons van­ish.

These rea­sons will ap­ply to some com­pa­nies more than oth­ers. For in­stance, if you work at Google, the first rea­son is im­por­tant be­cause grow­ing a cus­tomer base worth ~270B by 2% un­locks ~5.5B of new rev­enue. If Google is pay­ing your team less than 5B in to­tal, your team is prob­a­bly mak­ing enough money to jus­tify its ex­is­tence. But if you work at a smaller com­pany with rev­enue mea­sured in mil­lions, that math goes the other way.

There’s an ob­vi­ous con­se­quence to this: if you want your work to be val­ued (i.e. you don’t want to be reshuf­fled or fired), and you want to work on per­son­ally-sat­is­fy­ing fea­tures like ac­ces­si­bil­ity, or UI pol­ish­ing, or any­thing else not di­rectly con­nected to profit - you need to go and work for a very prof­itable com­pany.

When I wrote about this idea - that very large tech com­pa­nies de­liver mar­ginal fea­tures as a way of slightly grow­ing their mas­sive ad­dress­able cus­tomer base - some read­ers found the idea de­press­ing. Maybe so! But at least it’s a the­ory for how it might be pos­si­ble to work on these kinds of fea­tures and get paid for it. The al­ter­na­tive the­ory is some­thing like:

Accessibility, clean code, good per­for­mance, and so on are all Good Features

I just need to keep look­ing un­til I find a Good Company and not a Bad Company

I don’t think that a smart en­gi­neer who thinks about this prob­lem will come away be­liev­ing this. But lots of smart en­gi­neers don’t like think­ing about how their work con­nects to com­pany prof­its, so their im­plicit be­liefs of­ten add up to some­thing like this. These en­gi­neers will of­ten go through the five-step process I men­tioned in the in­tro­duc­tion to this post. I hate to see tech­ni­cally strong, mo­ti­vated, kind-hearted en­gi­neers run head­long into burnout for com­pletely pre­dictable rea­sons.

It’s easy to fall into the trap of think­ing that you get paid for work be­cause it’s im­por­tant

You get paid for work be­cause it makes money. If your work does­n’t con­tribute to that, your po­si­tion is in­her­ently un­sta­ble

If you want a sta­ble po­si­tion, you should try and fig­ure out how your work con­nects to com­pany prof­its, and strengthen that con­nec­tion if pos­si­ble

All kinds of seem­ingly-un­prof­itable work makes money, par­tic­u­larly at large com­pa­nies where small per­cent­ages are a lot

If you want to work on seem­ingly-un­prof­itable work, you’re prob­a­bly bet­ter off work­ing for large suc­cess­ful tech com­pa­nies

posts │ re­sume │ github │ linkedin │ rss │ what I’m work­ing on now← Paths through the space of all pos­si­ble so­lu­tions­Build­ing your sense of what’s im­por­tant at a tech com­pany →

An ar­ti­fi­cial in­tel­li­gence (AI) sys­tem has for the first time fig­ured out how to col­lect di­a­monds in the hugely pop­u­lar video game Minecraft — a dif­fi­cult task re­quir­ing mul­ti­ple steps — with­out be­ing shown how to play. Its cre­ators say the sys­tem, called Dreamer, is a step to­wards ma­chines that can gen­er­al­ize knowl­edge learn in one do­main to new sit­u­a­tions, a ma­jor goal of AI.

“Dreamer marks a sig­nif­i­cant step to­wards gen­eral AI sys­tems,” says Danijar Hafner, a com­puter sci­en­tist at Google DeepMind in San Francisco, California. “It al­lows AI to un­der­stand its phys­i­cal en­vi­ron­ment and also to self-im­prove over time, with­out a hu­man hav­ing to tell it ex­actly what to do.” Hafner and his col­leagues de­scribe Dreamer in a study in Nature pub­lished on 2 April1.

In Minecraft, play­ers ex­plore a vir­tual 3D world con­tain­ing a va­ri­ety of ter­rains, in­clud­ing forests, moun­tains, deserts and swamps. Players use the world’s re­sources to cre­ate ob­jects, such as chests, fences and swords — and col­lect items, among the most prized of which are di­a­monds.

Importantly, says Hafner, no two ex­pe­ri­ences are the same. “Every time you play Minecraft, it’s a new, ran­domly gen­er­ated world,” he says. This makes it use­ful for chal­leng­ing an AI sys­tem that re­searchers want to be able to gen­er­al­ize from one sit­u­a­tion to the next. “You have to re­ally un­der­stand what’s in front of you; you can’t just mem­o­rize a spe­cific strat­egy,” he says.

Collecting a di­a­mond is “a very hard task”, says com­puter sci­en­tist Jeff Clune at the University of British Columbia in Vancouver, Canada, who was part of a sep­a­rate team that trained a pro­gram to find di­a­monds us­ing videos of hu­man play2. “There is no ques­tion this rep­re­sents a ma­jor step for­ward for the field.”

AI re­searchers have fo­cused on find­ing di­a­monds, says Hafner, be­cause it re­quires a se­ries of com­pli­cated steps, in­clud­ing find­ing trees and break­ing them down to gather wood, which play­ers can use to build a craft­ing table.

This, to­gether with more wood, can be used to make a wooden pick­axe — and so on, un­til play­ers have as­sem­bled the cor­rect tools to col­lect a di­a­mond, which is buried deep un­der­ground. “There’s a long chain of these mile­stones, and so, it re­quires very deep ex­plo­ration,” he says.

Previous at­tempts to get AI sys­tems to col­lect di­a­monds re­lied on us­ing videos of hu­man play2 or re­searchers lead­ing sys­tems through the steps.

By con­trast, Dreamer ex­plores every­thing about the game on its own, us­ing a trial-and-er­ror tech­nique called re­in­force­ment learn­ing — it iden­ti­fies ac­tions that are likely to beget re­wards, re­peats them and dis­cards oth­ers. Reinforcement learn­ing un­der­pins some ma­jor ad­vances in AI. But pre­vi­ous pro­grams were spe­cial­ists — they could not ap­ply knowl­edge in new do­mains from scratch.

Key to Dreamer’s suc­cess, says Hafner, is that it builds a model of its sur­round­ings and uses this ‘world mod­el’ to ‘imagine’ fu­ture sce­nar­ios and guide de­ci­sion-mak­ing. Rather like our own ab­stract thoughts, the world model is not an ex­act replica of its sur­round­ings. But it al­lows the Dreamer agent to try things out and pre­dict the po­ten­tial re­wards of dif­fer­ent ac­tions us­ing less com­pu­ta­tion than would be needed to com­plete those ac­tions in Minecraft. “The world model re­ally equips the AI sys­tem with the abil­ity to imag­ine the fu­ture,” says Hafner.

This abil­ity could also help to cre­ate ro­bots that can learn to in­ter­act in the real world — where the costs of trial and er­ror are much higher than in a video game, says Hafner.

Testing Dreamer on the di­a­mond chal­lenge was an af­ter­thought. “We built this whole al­go­rithm with­out that in mind,” says Hafner. But it oc­curred to the team that it was the ideal way to test whether its al­go­rithm could work, out of the box, on an un­fa­mil­iar task.

Twenty years ago to­day, Linus Torvalds made the very first com­mit to Git, the in­for­ma­tion man­ager from hell.

Over these last 20 years, Git went from a small, sim­ple, per­sonal pro­ject to the most mas­sively dom­i­nant ver­sion con­trol sys­tem ever built.

I have per­son­ally had a hell of a ride on this par­tic­u­lar soft­ware roller coaster.

I started us­ing Git for some­thing you might not imag­ine it was in­tended for, only a few months af­ter it’s first com­mit. I then went on to co­found GitHub, write ar­guably the most widely read book on Git, build the of­fi­cial web­site of the pro­ject, start the an­nual de­vel­oper con­fer­ence, etc - this lit­tle pro­ject has changed the world of soft­ware de­vel­op­ment, but more per­son­ally, it has mas­sively changed the course of my life.

I thought it would be fun to­day, as the Git pro­ject rolls into it’s third decade, to re­mem­ber the ear­li­est days of Git and ex­plain a bit why I find this pro­ject so end­lessly fas­ci­nat­ing.

Before we get into the his­tory of Git and my re­la­tion­ship with it, I want to start with why Git ex­ists and the mind­set that it was started with.

Git started from frus­tra­tion in the Linux ker­nel de­vel­op­ment com­mu­nity over ver­sion con­trol and col­lab­o­ra­tion.

The ker­nel com­mu­nity has al­ways used mail­ing lists for col­lab­o­ra­tion. It’s ac­tu­ally a pretty fas­ci­nat­ing method of col­lab­o­ra­tion - it is mas­sively scal­able, highly dis­trib­uted, lo­cal first, ca­pa­ble of fine grained dis­cus­sion of patches, cryp­to­graph­i­cally se­cur­able, etc.

The gist of the mail­ing list col­lab­o­ra­tion flow is:

* pub­lish a tar­ball (sort of zip file) of a known state of the pro­ject

* peo­ple down­load that and ex­pand it lo­cally

* mod­ify it with what­ever fea­ture or fix they want to change

* run GNU diff on it to cre­ate a patch that the main­tainer can ap­ply to that ini­tial known state to add that fea­ture

* email that patch or a se­ries of them to a mail­ing list

* the list dis­cusses the changes

* the main­tainer ap­plies the patch for the next tar­ball re­lease or asks for changes

I would love to do a whole blog post about how mail­ing list col­lab­o­ra­tion works and how cool var­i­ous as­pects of it are, but that’s for an­other time.

However, in this world, the ver­sion con­trol sys­tems of the time were sim­ply not help­ful - they seemed like a step back­ward in func­tion­al­ity. They had clunky ac­cess con­trol mech­a­nisms, they weren’t dis­trib­uted, they were in­cred­i­bly slow.

The com­mu­nity worked pri­mar­ily with patches and tar­balls and ex­ist­ing SCMs were just not good enough.

If you think about it, the patches and tar­balls work­flow is sort of the first dis­trib­uted ver­sion con­trol sys­tem - every­one has a lo­cal copy, the changes can be made lo­cally, ac­cess to “merge” is whomever can push a new tar­ball to the server.

However, the process was still a bit cum­ber­some - man­ag­ing the patches, re­mem­ber­ing what was ap­plied and who con­tributed it, keep­ing mul­ti­ple se­ries in flight, deal­ing with con­flicts or re­bas­ing changes.

The Bitkeeper tool was de­vel­oped specif­i­cally for the ker­nel’s use case to try to build a ver­sion con­trol sys­tem that worked for this work­flow and Linus did like it, but the li­cens­ing they wanted to use did­n’t vibe with the com­mu­nity it was built for.

It’s im­por­tant to un­der­stand that this is why Git was cre­ated. Not to be a ver­sion con­trol sys­tem re­ally, but fun­da­men­tally to be a bet­ter way to do patches and tar­balls - snap­shot a set of files and show dif­fer­ences that can be dis­cussed.

This is pri­mar­ily how it’s data struc­ture was de­signed (linked lists of trees of files, con­tent ad­dress­able blob stor­age) and that struc­ture is fun­da­men­tally un­changed, from the first com­mit to this very day.

Since we’re on the topic, what did the first com­mit look like? What could Git do from it’s first mo­ment of ex­is­tence?

Well, it was a stu­pid con­tent tracker. As Linus him­self put it from day one:

The first com­mit was a col­lec­tion of seven sim­ple stand alone tools. They weren’t things like git com­mit, they were very low level data­base tools like write-tree and com­mit-tree (this changed a few weeks into the pro­ject, when every­thing started be­ing pre­fixed with git-).

Some of them evolved into the plumb­ing com­mands that still ex­ist to this day, like git cat-file and git write-tree, oth­ers were fun­da­men­tally dif­fer­ent (for ex­am­ple, git read-tree is a cur­rent Git plumb­ing com­mand but the orig­i­nal read-tree was more like the cur­rent git ls-files), how­ever, at a low level the con­cepts all ex­ist still.

Essentially, with the very first com­mit, Git could:

* Build up a “snapshot” by us­ing up­date-cache to build a cache of con­tents (essentially a tar­ball), and write-tree to write it as an ob­ject to the data­base.

* Write a “changeset” (commit) with com­mit-tree that com­mented on the changes in­tro­duced with a new tar­ball and the par­ent it was based on in or­der to setup a his­tory of “tarballs”.

* Read out those data­base struc­tures with cat-file (pull an ob­ject out of the data­base), read-tree (list out what the cache looks like) and show-diff (show the diff of the cache to the work­ing di­rec­tory).

From the very first days, Linus men­tions that he re­ally only wanted to build this plumb­ing and have it be the back­end for some UI (“porcelain”) be scripted on top of it.

He meant to build an ef­fi­cient tar­ball his­tory data­base toolset, not re­ally a ver­sion con­trol sys­tem. He as­sumed that some­one else would write that layer.

More on that in a minute. But first…

I was per­son­ally first in­tro­duced to Git around this point in the time­line by my friend and coworker, Nick Hengeveld at the ill fated startup we both worked at called Reactrix.

Interestingly, we used Git more in the way that Linus thought of the tools - as a dis­trib­uted con­tent tracker - rather than as the ver­sion con­trol sys­tem that you prob­a­bly mainly think of it as to­day.

We es­sen­tially worked for an ad­ver­tis­ing com­pany that man­aged a bunch of dig­i­tal sig­nage dis­plays with rather heavy-weight as­sets. Each of our hun­dreds of dis­plays had a unique com­bi­na­tion of ads they needed to run, most were on slow cell data up­links, and the ads changed a lot. So we needed an ef­fi­cient way to say “for ma­chine A, we need ads 1, 2 and 3 (v1). for ma­chine B, we need ads 2, 3 (v2) and 4” and in­cre­men­tally up­date them if there were new ver­sions of an ex­ist­ing ad.

We used Git - not to track changes in source code, but as a con­tent dis­tri­b­u­tion mech­a­nism. We would use a script to look at the up­com­ing sched­ul­ing, write out unique trees of only the ads that each ma­chine needed, com­mit that tree to a branch for the ma­chine and then have each ma­chine fetch and hard check­out every night.

This ap­proach had a bunch of in­ter­est­ing ad­van­tages.

* If an ad up­dated, we only trans­ferred the changed files and the changes were delta com­pressed against an ob­ject that was po­ten­tially al­ready on the ma­chine.

* All the shared as­sets had a sin­gle blob that could be checked out in mul­ti­ple con­texts - the con­tent ad­dress­able filesys­tem as­pect of Git was great for this.

* We could have thou­sands of com­bi­na­tions of hun­dreds of as­sets with­out stor­ing any con­tent twice any­where or trans­fer­ring the same thing over the net­work more than once.

Nick was a fairly heavy con­trib­u­tor to the early Git pro­ject to get it to work for our use case (adding SSL sup­port to http-fetch, adding re­sum­able and par­al­lel HTTP trans­fers, the first HTTP based push so­lu­tion, etc). His first patch was in September, a mere 6 months af­ter Linus’s first com­mit.

His in­tro­duc­tion of Git to me, my strug­gle to grasp it, and my even­tual light­bulb mo­ment of think­ing it was pretty cool was what mo­ti­vated me to write about it and try to make it eas­ier for peo­ple to learn.

This pushed me to com­pile the Git Community Book, the Git Internals Peepcode PDF, build the git-scm.com web­site and write the Pro Git book - all of which even­tu­ally led me to GitHub.

So, how did this stu­pid con­tent tracker be­come the most widely used SCM in the world?

Well, I go over a lot of the rea­sons I think Git and GitHub “won” in a pre­vi­ous blog post, but I do think it’s worth a quick glance at why Git it­self ended up look­ing the way that it does to­day. Also maybe tell some fun anec­dotes about the ori­gins of stuff you know and love along the way.

As you may have de­duced by the oc­ca­sion­ally un­friendly, ob­scure or in­con­sis­tent na­ture of the Git com­mands, this was­n’t a sys­tem that some­one sat down and metic­u­lously de­signed from a us­abil­ity stand­point from day one.

For the first sev­eral months, the git com­mands were all in­cred­i­bly low level - even if you know the ex­ist­ing plumb­ing com­mands, you may not rec­og­nize a sin­gle one of the com­mands that ex­isted in June of 2005 (rev-tree, mkdelta, tar-tree?)

It was fairly clear from the very be­gin­ning that the ap­proach was that Git would just be this very low level data­base/​filesys­tem type toolset and that (possibly sev­eral) other tools would use Git as their in­fra­struc­ture.

So if Linus and the early Git team did­n’t ini­tially imag­ine Git be­ing an ac­tual ver­sion con­trol tool and just wanted to build the plumb­ing, where did the “porcelain“ com­mands that we know to­day ac­tu­ally come from?

The an­swer is that they sort of slowly eked their way in over sev­eral years, mostly as shell scripts that evolved to scratch a se­ries of itches.

In the early days, there were a num­ber of user in­ter­faces that scripted Linus’s back­end tool­ing to be more user friendly. The ear­li­est and for the first few years the most pop­u­lar was git-pasky, which quickly be­came “Cogito” by Petr Baudis. The first ver­sion of these scripts were re­leased only days af­ter Git.

In early re­lease an­nounce­ments, you can get a feel­ing for the tool­ing that would start to be­come Git.

A few months in, try­ing to keep the line be­tween porce­lain and plumb­ing be­gins to break down as tool­ing in git starts to com­pete with tool­ing in the porce­lan scripts.

Over the next year or two, more and more scripts con­tin­ued to make their way into the core Git code un­til it even­tu­ally be­came clear that peo­ple’s time would be bet­ter spent work­ing on the tools dis­trib­uted with Git rather than try­ing to main­tain this plumb­ing/​porce­lain dis­tinc­tion in the tool­ing.

In 2007, Cogito fi­nally got “put up for sale” and the idea of some other porce­lain be­ing the main way that Git was used was more or less aban­doned.

Looking back through these com­mits and emails from 20 years ago, it’s fas­ci­nat­ing to see the birth of some of the in­fa­mous tools that many of us use every day.

The first ver­sion of git log was a wrap­per script that called git-rev-list –pretty, piped it through a pager and was hard-coded to start at HEAD. Here is the orig­i­nal “git log” pro­gram in it’s en­tirety:

#!/bin/sh

git-rev-list –pretty HEAD | LESS=-S ${PAGER:-less}

Actually, a lot of the cur­rent com­mands started out this way - a few lines long shell or Perl script that ran some core plumb­ing com­mands. Eventually al­most every­thing has been rewrit­ten in C as builtins for porta­bil­ity, but there was a lot of first ver­sions of com­mands in these script­ing lan­guages.

There are lots of these “firsts”, but I’ll just do one more be­cause I find it so in­ter­est­ing. The in­fa­mous “rebase” com­mand was born from a con­ver­sa­tion about work­flow be­tween Junio and Linus in June 2005.

Junio tells Linus what his work­flow has been:

Linus com­ments that the type of merge that de­vel­op­ers re­ally want here is to “re-base” the work:

Junio then re­sponds with a sim­ple script to use a new com­mand called git cherry to “re-base” a se­ries of com­mits.

As far as I can tell, this is the first time the phrase “rebase” was used in ver­sion con­trol. It’s fun to see his­tory born.

I’ve been asked many times where GitHub came up with the “Octocat” and the an­swer also lies in these early archives.

The first us­age of the word “octopus” that I’ve seen in the Git mail­ing list is Junio telling Linus that his patches were ap­plied se­quen­tially, not “octopus”.

This re­ferred to cre­at­ing a merge com­mit with mul­ti­ple par­ents, which is the other way the dif­fer­ent patches could have been merged. Eventually, “octopus merge” be­came one of the valid merge strate­gies that Git had in it’s quiver. (fun fact, Git once had “stupid” as a merge strat­egy)

At some point in the very, very early days of GitHub, Tom was look­ing for any­thing that could be an­thro­po­mor­phi­cally used as a Git totem and “Octopus” was the only term in the Git lex­i­con that seemed to fit the bill. Tom searched for cli­part that fea­tured an “octopus” and this Simon Oxley im­age was the cutest that fit the bill. So the “octocat” was born.

Twenty years and a day later, one might ask what the fu­ture of this un­likely hero is.

The funny thing is that I’m still us­ing Git in some ways in the same way that it was orig­i­nally in­tended. GitButler uses Git not only to do nor­mal com­mits for track­ing code changes, but also uses the git data­base to track the his­tory of your pro­ject. In the end, it’s still a damn good stu­pid con­tent tracker, as Linus first in­tended.

So, happy birth­day Git. You are still weird. You are still won­der­ful. Thanks for all the fish.

Diane Papan is a California Assembly mem­ber in­tro­duced a bill, California AB-501, that would stand in the way of con­vert­ing OpenAI from a non­profit into a for-profit. (Stuart Russell, Yann LeCun, Lawrence Lessig, and many oth­ers in­clud­ing me signed a pe­ti­tion in its sup­port.) Tens of bil­lions of dol­lars are at stake. Here’s what AB-501 looked like back when I signed the pe­ti­tion a few days ago.

Here’s what it looks like now. Can you spot the dif­fer­ence?

My sources as­sure me that this is NOT a cler­i­cal er­ror and that Papan’s of­fice con­firms that the change is real.

Rumor has it that Altman called Papan just be­fore the change. What did he tell her? StopAI, per­haps first to re­port this, took a dark view:

Media, get out there and find out what hap­pened.