(2024-06-05) Appleton Homecooked Software And Barefoot Developers

Maggie Appleton: Home-Cooked Software and Barefoot Developers. This is a talk I presented at the Local-first Conference in Berlin, May 2024. For the last ~year I've been keeping a close eye on how language models capabilities meaningfully change the speed, ease, and accessibility of software development. The slightly bold theory I put forward in this talk is that we're on a verge of a golden age of local, home-cooked software and a new kind of developer – what I've called the barefoot developer.

let's talk about local-first, beyond local data.

everyone here is trying to make a new, beautiful local-first future happen, where the software and the data all live on our local machines and just use the cloud to sync between them whenever we get internet access.

The existing philosophy of local-first is fantastic. I’m on board with it, I know you all are too.

But come expand your minds with me for a moment, and imagine a more holistic vision for local software. What if it was about more than just databases?

there's an interpretation of local software that means software that is built close to the home and serves the needs of the home.

Clay Shirky first proposed the concept of 'situated software' in 2004.

it was practically impossible to build this small-scale software in 2004.

Sixteen years later, in 2020, Robin Sloan published a blog post called "An App Can Be a Home-Cooked Meal" which picked up on many of the same themes. ((2020-02-28) Sloan An App Can Be A Homecooked Meal)

Home-cooked apps, like meals, are apps you make for the people you know and love.

We’ve progressed enough since 2004 that someone can make one of these on their own.

I think it's fitting that all of these examples of home-cooked apps deal with the kind of data you don't want leaving your personal home, like your children, bodily functions, health, and finances.

These small-scale, personal apps...

..are drastically different from the kind of software most of us use every day, which is professionally made software

This is like a meal or cake made by a professional chef at a restaurant. Probably much more delicious than yours. (cooking)

But it is likely more complex, more expensive to make, and requires many people with expertise.

At the moment, we’re in the industrial, high-modernism age of software, where these standardized, one-size-fits-all apps are made for us by people who don’t know much about us.

How could an American getting paid six figures in Mountain View understand how to identify problems and design solutions for a homemaker in Tokyo, a street seller in Turkey, or a doctor in Tunisia?

My friend Kasey Klimes wrote a fantastic piece called "When to Design for Emergence.

He points out that our current approach is designed to only solve the most common needs of the most number of users.

Anything beyond that is what we call the long tail of user needs.

Google Maps is never going to support showing historical borders or tidal patterns, even if those things are essential to a few dozen, or even a few hundred people.

engineers are very expensive.

For industrial software, you need large teams of developers and designers and product people

And the way we fund this is primarily through US-based venture capital funding, which demands hockey stick growth in return.

But over here on the left-hand side of small-scale, specific software, we have the land of opportunity. Indie

This kind of software doesn't even need to make a profit. (That's very different than indie-lifestyle-company, it's amateur.)

But this land of opportunity currently has a skill issue.Because the Venn diagram of people with the skills to make home-cooked software and professional developers is essentially...

.a concentric circle.

The vast majority of people who might want to make a piece of home-cooked software can't because software development is too complex

So widespread, local, home-cooked software is still just a pipe dream.

This is a shame because we know the world is full of problems to be solved. While not all of those problems have software-shaped solutions, a whole bunch of them do.

So what happens if some parts of software development get faster, easier, and cheaper?

Well, 4 years ago, OpenAI released GPT-3,

I'm also talking about what's come to be called agents.

I actually don't want to talk about how advances in AI will affect professional developers

I want to talk about a different kind of developer

What I call barefoot developers

This is a term I’ve made up, based on the idea of...

Barefoot doctors.

Initiative by Mao’s government in China in the 1960s

At the time, 80% of the population lived in rural areas but had no or poor access to healthcare. Medical expertise was all concentrated in urban areas.

They selected people from rural villages and trained them up to become healthcare providers for their communities

By the mid-1970s, there were over 1.5 million barefoot doctors serving in China's villages.

Life expectancy over that period rose dramatically from 35 years to 63 years. (Was that about healthcare or food availability?)

At the moment, these are people like the teachers who make elaborate Notion spreadsheets for managing classes.

Or financial planning wonks producing extensive spreadsheets.

At the moment, they rely on low and no-code tools. And they do wildly complex things within them, pushing these apps to their limits.

But they never make it over what I call the command line wall.

This means most of their work is held hostage in the cloud and requires them to pay monthly subscription fees to access it.

These people are deeply embedded in their communities, so they understand the needs and problems of the people around them.

They could build software solutions that no industrial software company would build

And these people are the ones for whom our new language model capabilities get very interesting.

This is Vercel’s V0. It generates working interfaces based on text descriptions of what you want. I've told it to make me a personal finance dashboard

Another good example of this is TLDraw's Make Real prototype... they hooked up a multi-modal language model (GPT-4 Omni) to their canvas so that you can draw any kind of interface you like and annotate it with red drawings and text to tell the system how you want it to work And then click this “make real” button and it will make your selection into a real working piece of software.

language model legos need glue.

It can make pretty interface elements for you, it can manage state for you, make API calls, and write basic logic. But it doesn't tell you how to stick all these things together into a working application.

glue comes in two forms.

We first need language model agents that are designed to act as central orchestrators

And then we also need tools that are designed to talk to and work with these orchestration agents.

If I'm at all right about there being a sudden explosion of local, home-cooked software, how does this affect the strategy of the local-first movement?