Board

Late in the Revolutionary War, Benjamin Franklin published a report detailing how the British army had enlisted Native American tribes to commit atrocities against settlers. One tribe, he reported, had provided its British paymasters with 102 scalps, including 18 marked with flame — the scalps of children whose parents had been burned alive. The story […]

Plus! Netflix; Scale and Conversation; Flywheels; Scale and Unavoidable Politics; Green Nationalism

Plus! Celsius; The Uber Playbook; Price Discrimination and Amortization; Pricing Power; Sanctions; Diff Jobs ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌ ‌Open in browserWelcome to the weekly free edition of The Diff.

Could microprocessors run full computers? This question seems obvious today, but in 1974, this was Gary Kidall's insight behind developing the operating system CP/M. It was an OS specifically built for small computers. Written in Kidall's programming language, PL/M. Kidall sold CP/M licenses through his company, Digital Research. CP/M was special because it separated the physical I/O system (now called BIOS – Basic I/O System) from the disk operating system (at the time, called the BDOS – Basic

The US is fundamentally rethinking its approach to regulating competition, and M&A, and tech, and big tech buying startups. The FTC’s attempt to block Meta from buying Within is a test case for all of this. So, how many interesting problems can we count?

Chips are the clearest example that economic efficiencies will not be the ultimate decider of technology’s end state: politics will play an important role.

The end-to-end principle is a design pattern used in the early Internet that suggests that Specific application-level functions usually cannot, and preferably should not, be built into the lower levels of the system – the core of the network. It was formalized in a 1984 paper, End-to-End Arguments in System Design, by Saltzer, Reed, and Clark. The paper uses an example of securing a file transfer between two computers. There are many steps during the transfer where the file could get corrupted

For some companies, revenue is a feature.

Last week I was talking to a potential angel investor and he was asking a number of questions. My first comment to him was how it’s dramatically more difficult than it seems. Yes, it’s …

Lately, I’ve been thinking more about David Friedberg’s Rubric for Business Value Creation. I’m always searching for ideas that capture an important concept with broad applicability. After working …

Cathedrals are intricately designed places of worship that have become too sacred to change. Building them required serious planning and thousands of man-hours. Compare that to bazaars, which were public forums that constantly changed – new merchants came and left, new products arrived and disappeared. This distinction was applied to different forms of open-source development in The Cathedral and the Bazaar [http://www.catb.org/~esr/writings/cathedral-bazaar/cathedral-bazaar/] back in 1999. It

Low churn rates have been the cornerstone of enterprise SaaS. Once you signed an enterprise contract with Oracle, you weren't getting out of it anytime soon. A reader of this blog once sent me this adage, > Mainframes don't get replaced. They get shutdown when the company goes out of business or gets sold. Times are changing. It's never been easier to create a SaaS company, and customers have more than realized the trade-offs of vendor lock-in. 1. Customers are increasingly pushing for data s

Y Combinator’s latest startup batch

Our startup ecosystem, like all markets, goes through regular ups and downs. Sometimes we go through a period of unusually high highs, like the back half of 2020 and most of 2021. Sometimes we go t…

Startup winter has come to India. What should you do next?

The majority of data that transfers over the network at companies like Google and Uber isn't encoded as JSON and don't use REST APIs. Instead, the messages are encoded as protocol buffers over RPC APIs. Why this is most likely the future and what are the implications? Why? * JSON is a great format for human readable messages. But what's human readable is often much slower to serialize. Depending on your benchmark, protobufs about 5x faster than JSON. * JSON is a schema-less message fo

Last week I read SPAs were a mistake [https://gomakethings.com/spas-were-a-mistake/]. I used to agree with the author, thinking that we had stumbled down the wrong path in innovation with Single page applications (SPAs) versus multi-page applications (MPAs). But I've seen the light. SPAs can encapsulate complex state for better caching, faster loads, and more native UX in browsers. Things that we load from the web went from web pages to web applications. Yes, it's more complex. Yes, there a

Yesterday, I wrote about how SPAs were a mistake. Today, I want to talk about how you can build multi-page apps (or, you know, regular websites) that are as fast as SPAs. Let’s dig in! A quick summary The sites and apps I build are absurdly fast. They load nearly instantly. Even on spotty 3G connections on the other side of the world, where many of my students live, things still load really quickly (like, 3 seconds or less fast).

When version controlling your code with git, there are generally three choices when merging feature branches into main. Each has its quirks, so which one should you use? Rebase rewrites history on top of a branch. This provides a linear history, meaning context is lost of where a feature branched off. You may also have to force push changes (since you are rewriting history) if you have already pushed to a remote. Merge will create a merge commit that joins two branches together. With the fast-

> With a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody. If the API is the documented contract exposed by an application, the API Surface Area encompasses all observable behavior from the API and any integration points. That is, API Contract ⊂ API Surface. One benefit to open-source is that you don't need to design the perfect API for your customers. That's because the effective su

Infrastructure-as-code (IaC) is often seen as a deployment tool. Write code to describe your infrastructure – either at a low level like Terraform or Cloudformation, or at a high level like the AWS Cloud Development Kit (CDK). But Infrastructure-as-code is naturally part of the continuous deployment (CD) process, but increasingly is finding its way into continuous integration (CI). Infrastructure-as-code is becoming build-as-code. Take this hypothetical scenario – you want to deploy every new

How do you design an API? Most APIs are a mishmash of "REST-like" and freeform dynamic typed JSON. However, some more mature organizations have API-style guides. Schema-driven development is a better alternative. APIs are defined programmatically with schemas. These schemas are often written in JSON (OpenAPI) or some interface definition language (IDL) – e.g., .proto or .thrift. These files are then compiled into language or platform-specific stubs for clients and servers. Schema-driven develo

When you hear the phrase “cloud native,” is Kubernetes the first thing that comes to your mind? It is for me, and I expect I’m not alone.

A look at how OSS takes over the application layer + the potential end of closed source software categories

> We reject: kings, presidents, and voting. We believe in: rough consensus and running code. – David Clark [https://en.wikipedia.org/wiki/David_D._Clark] (1992) From the 1970s to the 1990s, the goal of building a global computer network was becoming more evident. However, how it would be built was one of the most fiercely debated topics in computer science. Some refer to the 1970s-1990s as The Protocol Wars, a period where competing standards [https://xkcd.com/927/] proliferated and competed fo

Monorepos have a U-shaped utility function – great for small and large projects, difficult for mid-sized ones. But there aren't many good monorepo frameworks out in the world. Lerna is deprecated, and even new upstarts like Turborepo are getting absorbed (i.e., acquired) into other companies (Vercel). Likewise, centralized version control tools like Perforce and large-scale build tooling (buck, bazel, pants) have struggled with adoption. As someone who continues to manage projects in a monorepo

There was a project announced this week that lets you write python scripts in HTML and have them execute in the browser (pyscript [https://github.com/pyscript/pyscript]). Here's an example. Hello world! This is the current date and time, as computed by Python: from datetime import datetime now = datetime.now() now.strftime("%m/%d/%Y, %H:%M:%S") Under the covers, this uses pyodide [https://pyodide.org/en/stable/] and WebAssembly. This is on

Technical debt is a bad word, but it doesn't have to be the Godfather's offer you can't refuse debt. Organizations do everything to fight the inevitable accumulation of debt (and fail). Yet, most code should and will need to be rewritten. What if I told you technical debt wasn't so bad? Technical debt is a tradeoff. In a perfect world, your stack would be infinitely modular – the ability to add arbitrary new features without refactoring, switch clouds or technology without pain, and never deal