Talks

Functionality and Expression in Computer Programs — Pamela Samuelson (IPSC 2015)

37 min read

About this talk

Speaker: Pamela Samuelson
Event: 15th Annual Intellectual Property Scholars Conference (IPSC), DePaul University College of Law, 2015 — session “Copyright Doctrine”
Date: 2015 (video uploaded 2015-12-11; the conference was in August 2015, from memory; not checked)
Length: 23:18
Channel: Ipsc 2015
Watch: IPSC 2015 – Pamela Samuelson – ‘Functionality and Expression in Computer Programs

How to read this page. It has two kinds of content, always marked:

  • 🎙 In the talk. What Samuelson says, with [MM:SS] timestamps. Only these parts are her views. Quote marks mean exact caption words (the captions are rough).
  • 📚 Deeper theory. Background from the legal traditions she draws on, including cases and thinkers she does not name. It is not her claim unless a timestamp says so. Anything not checked live is marked “from memory; not checked”.

Suggested route. Summary → Map → Key terms → Part 2: The intellectual map (read once, slowly) → Deep dives in order → “Putting it together”. The “current debate” section covers what happened after 2015, including how Google v. Oracle ended.

Speakers

LabelWhoRoleConfidence
SamuelsonPamela SamuelsonProfessor of law and information, UC Berkeley School of Law. Main speaker.High. Named in the video details (institution given as Berkeley Law). She does not say her own name in the talk. Her first-person remark about “more than 30 years” of interest matches her known career.
Questioner 1Unnamed audience memberAsks about Whelan v. Jaslow and efficiency vs the “purpose” of software [17:26]–[19:06]Medium. The captions drop the question; I infer it from her answers.
Questioner 2Unnamed audience memberAsks how efficiency relates to processes and methods [20:43]Medium. Same caveat.

The transcript has no separate speaker labels. The question text is mostly missing, so only her answers are quoted.

Caption warnings. Auto-captions garble legal names. Corrections used on this page, checked against the talk’s own context:

  • “Oracle be Google”, “Oracle II” = Oracle v. Google (the Java API case).
  • “Wayland vs jazz low”, “wayland”, “Whelan” = Whelan Associates v. Jaslow Dental Laboratory (3d Cir. 1986).
  • “Computer Associates be all tied”, “all high”, “all tied”, “all kind” = Computer Associates v. Altai (2d Cir. 1992), the “abstraction-filtration-comparison” test.
  • “Lotus leaf worland”, “Lotus be Borland” = Lotus v. Borland (1st Cir. 1995).
  • “Sega versus accolade”, “Sega vehicle” = Sega v. Accolade (9th Cir. 1992). “the kinetics case” = Sony v. Connectix (9th Cir. 2000), the PlayStation emulator.
  • “lexmark”, “static control” = Lexmark v. Static Control Components (6th Cir. 2004).
  • “traffic’s” = TrafFix Devices v. Marketing Displays (2001), the dual-spring road-sign case.
  • “Baker”, “Sylvan” = Baker v. Selden (1879) and Selden’s bookkeeping system.
  • “maser dicta”, “murderer argument” = Mazer v. Stein (1954) dicta and the merger argument.
  • “judge also”, “judge routine” = Judge William Alsup, the trial judge. “Judge … Malik” [14:16] = Judge Kathleen O’Malley, who wrote the 2014 Federal Circuit opinion.
  • “frant Appleby Franklin” = Apple v. Franklin (3d Cir. 1983).
  • “the alice”, “Allison” = Alice Corp. v. CLS Bank (2014).
  • “section 102P”, “102 B”, “102 BM” (these chapter titles and captions) = § 102(b) of the Copyright Act. “Section 102C” in the chapter list is also a caption error: no § 102(c) is discussed. The talk is at that point on the Federal Circuit’s 2014 reasoning.
  • “Compatibility Issues” / “Human Interoperability” chapter titles are correct in substance.
  • “copyright, patent bucket” lines are noisy: she is describing “the patent bucket” vs “the copyright bucket”.
  • “fake early selvan” [20:43] = the Baker v. Selden bookkeeping system (Selden’s system).

Possible factual slips / unverified details in the talk.

  • [12:39] “six thousand method headers” re-implemented. The Supreme Court later described about 11,500 lines of declaring code across 37 API packages (Jones Day and coverage via the search; exact counts from memory; not checked). The two numbers are different units (method headers vs lines), so this is probably not an error, but I could not reconcile them.
  • [11:05] “nine million Java programmers”: this is the figure the Federal Circuit opinion used (from memory; not checked). It is a litigation-record number, not an independent count.
  • [15:51] Her explanation that Judge O’Malley expanded copyright because she “was going to uphold all of the patents in alice” is a personal conjecture about motive, which she labels “my theory”. There is no evidence in the talk that the court said this. Treat it as opinion.
  • [06:24] She says the “structure, sequence and organization” language “since 1989 is kind of fallen out of use”. SSO as a phrase comes from Whelan (1986), not 1989 (from memory; not checked). The caption may also have garbled the year.

Summary

Central question. Copyright is supposed to protect expression, and patents function. Software breaks that division: Congress gave copyright to computer programs, including object code, “the most functional part of software” [00:11]. So where does copyright stop? How do you separate the part of a program that is protectable expression from the part that is an unprotectable “procedure, process, system, method of operation” (17 U.S.C. § 102(b))?

Main thesis.

  1. You cannot cleanly separate function from expression in software: “it’s turtles all the way down” [15:51]. The courts need proxies and context, not a clean line.
  2. The case law gives four main approaches (Whelan, Altai, Lotus v. Borland, and the Lexmark / merger line). Only Borland gives § 102(b) real meaning, and the Federal Circuit in Oracle v. Google went against it.
  3. There are many kinds of “compatibility” in these cases. The hardest one in Oracle is human interoperability: nine million programmers have learned the Java command names.
  4. Patents are shrinking after Alice. She calls that “happy news”, but worries that copyright will be asked to “step up to the plate” and fill the gap. She thinks that is the wrong response.
  5. She thinks program behaviour, languages, interfaces and algorithms should be excluded from copyright, and she would adopt the Altai test to exclude them. Copyright “doesn’t have to do all the work”, because trade secrecy, licensing and first-mover advantage do most of it.

Close. The talk ends in Q&A about Whelan v. Jaslow, efficiency, and why merger and § 102(b) are “not that far away” from each other [22:19]. It stops mid-discussion at 23:05.

Stance. An academic critic of expansive software copyright. She says the case “has given me heartburn” [00:11]. She was on the Google side as amicus (see current debate). She is candid that she is “agnostic” on some non-literal elements [15:51].

Map — talking points

#PointTime
1Why she is back on the subject: Oracle v. Google “has given me heartburn”. Copyright covers object code; patents are weakening after Alice[00:11]
2What is clearly protected (source and object code, expressive screen displays) vs the puzzle of non-literal structure and § 102(b)[01:44]
3Whelan is “largely been the bunk”, cited mostly in the Third Circuit and by the Federal Circuit[01:44]–[03:17]
4Altai filters out functional elements but does not mention § 102(b) terms (procedures, processes, systems, methods) or efficiency[03:17]
5Lotus v. Borland gives § 102(b) a meaning; Lexmark is a merger-of-function-and-expression case[03:17]
6The district court in Oracle v. Google (Alsup): the API is a system or method of operation; relies on Lotus, Sega, merger[04:52]
7The Federal Circuit (2014): originality in design, no compatibility exception, § 102(b) just restates idea/expression, “capable of patent” dicta[06:24]–[07:57]
8Five types of compatibility in the cases (Altai, Sega/Accolade-type adaptation, Connectix, Borland, Oracle)[07:57]–[09:30]
9Human interoperability: nine million Java programmers and “speak in a different dialect”[09:30]–[11:05]
10The compare method header: “looks more like math”, copyright, patent, both or neither?[11:05]–[12:39]
11Categorical exclusivity (patent bucket vs copyright bucket) and TrafFix as a model: look at the patent[12:39]–[14:16]
12Her theory about why the Federal Circuit ruled as it did; patents shrinking, copyright expanding[14:16]–[15:51]
13Can you separate function and expression? No: proxies. What should be excluded: behaviour, languages, interfaces, algorithms[15:51]
14Copyright need not do all the work: trade secrecy, licensing, first-mover advantage[17:26]
15Q&A: Whelan v. Jaslow, the dental-lab software, business process as “idea”[17:26]–[20:43]
16Q&A: efficiency as a merger issue; Baker v. Selden; merger and § 102(b) as near-interchangeable[20:43]–[22:19]

Part 1 — Before you read

Key terms

  • Idea/expression dichotomy. Copyright protects the author’s expression, never the underlying idea. Codified (with a longer list) in 17 U.S.C. § 102(b): “In no case does copyright protection for an original work of authorship extend to any idea, procedure, process, system, method of operation, concept, principle, or discovery, regardless of the form in which it is described.” (statutory text from memory; not checked.)
  • § 102(b)‘s extra words. Whether “procedure, process, system, method of operation” add anything beyond “idea” is the first fault line in the talk. Whelan says no (a mere restatement). Borland says yes.
  • Literal vs non-literal elements. Literal: the exact code (source, object). Non-literal: structure, sequence and organization (SSO), modules, data structures, interface names, behaviour.
  • Object code. The machine-readable binary a compiler produces. Congress’s 1980 CONTU-inspired amendments treated programs as “literary works”, so even the binary is covered (from memory; not checked). She calls it “the most functional part of software” [00:11].
  • API (application programming interface). The names, signatures and calling conventions through which one program uses another’s functions. In the case: the declaring code (the method header, e.g. the signature of a comparison method) vs the implementing code (the body that does the work). Google wrote its own implementing code but re-used the Java declarations.
  • Merger. If there is only one or very few ways to express an idea, the expression “merges” into the idea and is not protected. Efficiency or compatibility constraints can shrink the number of ways.
  • Scènes à faire. Elements dictated by the task, the standards or the external environment. Part of the Altai filtration step (from memory; not checked).
  • Interoperability / compatibility. Words that mean different things across the cases. She separates five kinds (see deep dive 3). Do not read “compatibility” as one concept.
  • Categorical exclusivity. The idea that a thing belongs either to patent or to copyright, never both. She says the Supreme Court has not been “very happy” with it [12:39]–[14:16].
  • Human interoperability. Her phrase for the fact that people (programmers) have learned a vocabulary, so a rival that changes the names forces them to relearn.
  • Words that differ across traditions.
    TermIn copyright doctrineIn software engineering
    ”Interface”A set of expressive-looking words, possibly copyrightableA contract of names and types between modules; function, not prose
    ”Structure”SSO: a possible form of non-literal expressionArchitecture, a design decision
    ”Efficiency”A merger-type constraint that narrows expressionSpeed/memory trade-offs; often a design choice with many options
    ”Idea”The unprotectable abstractionThe program’s purpose or algorithm

People and cases named (a reading list)

Cases she names or the captions point to: Whelan v. Jaslow; Computer Associates v. Altai; Lotus v. Borland; Sega v. Accolade; Sony v. Connectix; Lexmark v. Static Control; TrafFix v. Marketing Displays; Baker v. Selden; Mazer v. Stein; Apple v. Franklin; Alice v. CLS Bank; Oracle v. Google (district court, Federal Circuit 2014). Judges named: Alsup, O’Malley. Her own paper (title not given in the talk; it is the “paper” she mentions, from memory; not checked, probably “Functionality and Expression in Computer Programs: Refining the Tests for Software Copyright Infringement”, Berkeley Technology Law Journal, 2016).

Samuelson’s own frame

A 30-year view, from her 1980s work on the CONTU report and software copyright, to 1990s “manifesto” scholarship, to 2015. She reads the case law as a long search for proxies that sort functional from expressive material, and she says the sorting is “a really deep problem” [01:44]. She is not a patent-abolitionist; she welcomes patent contraction but fears displacement of work onto copyright.

The current debate (2015 to Oct 2026)

Searches run 30 Oct 2026, standard mode. Where a claim comes from memory instead, it is marked.

1. How Oracle v. Google ended (Supreme Court, 5 Apr 2021).

  • Timeline. Alsup held in 2012 that the API’s structure and organization was not copyrightable. The Federal Circuit (O’Malley writing) reversed in 2014 and sent the case back on fair use. The Supreme Court denied certiorari in 2015. A jury found fair use in 2016. The Federal Circuit reversed again in March 2018. See the Harvard timeline and the summary in Berkeley’s page on the case. The Supreme Court then took the case.
  • What the Court decided. In Google LLC v. Oracle America, Inc., the Court ruled 6-2 for Google: copying about 11,500 lines of Java SE API code into Android was fair use. Justice Breyer wrote; Justice Barrett did not take part; Justice Thomas dissented, joined by Justice Alito. Fair use was treated as a legal question for de novo review, and the 2018 Federal Circuit judgment was vacated (Jones Day; Mondaq summary). The copied part was around 0.4% of the 2.86 million lines in the Java API code (Mass Law Blog; figure via search summary). The Court found all four fair-use factors favoured Google, and stressed that Google took what programmers needed “to put their accrued talents to work” in a new program (as reported; I did not read the opinion text myself).
  • What it left undecided. The Court assumed, “for argument’s sake”, that the declaring code was copyrightable, and did not decide it (Copyright Alliance, Mass Law Blog). Practical effect: anyone sued over an API may still have to fight copyrightability and fair use. So the question this talk asks (is the interface protectable at all?) is still formally open in the Supreme Court. The Federal Circuit’s 2014 ruling that the API was copyrightable was not endorsed, but also not overruled on the merits. (The 2014 holding sits in a Federal Circuit applying Ninth Circuit law; whether regional circuits follow it is my inference, from memory; not checked.)
  • Compared with the talk (2015, case live).
    • Samuelson saw copyrightability as the question and argued for exclusion under § 102(b). The Court answered a different question (fair use) and avoided hers.
    • Her worry that copyright “expand to fill the gap” left by patents [15:51] was not tested by the Court.
    • Her “human interoperability” point [11:05] reappears in the fair-use reasoning: the Court reasoned about programmers’ accrued skill (as reported). So her concern went to the fair-use door, not the copyrightability door. This is a reading of mine, not hers.
    • The majority also noted that code which “always serve[s] a functional purpose” is different from other works (as reported via search summary). This echoes her function/expression theme, but as a fair-use factor, not a scope limit.
  • Samuelson after the decision. She co-led Berkeley’s “Google v. Oracle: An Initial Appraisal” event on 20 Apr 2021 (BCLT), and discussed the case with Mark Lemley on a Techdirt podcast. She joined the amicus briefs for Google, and co-authored (with Clark Asay) a 2018 article on fair use for software (Berkeley Law; Berkeley Law “Copyright Common Sense”).

2. Fair use spread outward. Lawyers quickly tried to apply Google to other fields (for example, the Warhol litigation), and the Second Circuit declined to read it broadly (Copyright Alliance review; Authors Alliance). My searches did not find 2023–24 appellate decisions applying Google to software interfaces, so the post-2021 API case law is unverified here.

3. Patents, as Samuelson predicted, stayed weak. Alice (2014) still governs software-patent eligibility (from memory; not checked for 2026 changes). This is the premise of her “copyright steps up” worry. I did not search for current eligibility-reform bills.

4. New pressure on the same fault line: AI and code. The functionality/expression question now appears in suits over AI coding tools. In Doe v. GitHub (the Copilot class action), the district court narrowed the claims and the plaintiffs’ core theory is a DMCA § 1202(b) attribution claim, not copyright infringement on the merits (Knowing Machines explainer; Law360). The Ninth Circuit heard argument on 11 Feb 2026, and one summary reports an opinion on 16 Sep 2026 affirming dismissal of the § 1202(b) claims. Sources conflict on timing, and I could not confirm the opinion text, so treat it as provisional. I found no ruling on whether training on public code is fair use in that case (Leagle listing).

Part 2 — The intellectual map

This is the depth layer. The talk compresses about a century of doctrine into 23 minutes of case names. Each tradition below says what problem it tackles, who built it, and how it feeds Samuelson. All dates and holdings in Part 2 are from memory; not checked, unless a link is given. They are well-known, but verify before citing.

2.1 The idea/expression line — Baker v. Selden to § 102(b)

Problem. If copyright protected ideas, one author could monopolise a whole field. If it protected nothing but exact words, copying would be easy. Where is the line? Chain.

  • Baker v. Selden (US, 1879). Selden wrote a book explaining a bookkeeping system, with blank ruled forms. Baker made forms that did the same job. The Court held that copyright in the book did not give Selden rights over the system or the forms needed to use it. The book may be protected; the art it describes is for patents, if anything. She cites this twice: for categorical exclusivity (“what Baker taught”, [12:39]) and for merger (“once you adopt the system then anybody who wants to use the same system is basically going to have to use something that’s pretty darn similar”, [20:43]–[22:19]).
  • Mazer v. Stein (1954). Lamp bases (statuettes) were copyrightable even though they were used in a lamp, and even though they might have been patentable. The Federal Circuit in Oracle took from it that just because something’s patentable doesn’t mean it’s not copyrightable [07:57]. Samuelson says the Court’s next sentence limited that statement, and that the Federal Circuit “should have read the whole” of it [07:57].
  • The 1976 Act, § 102(b). Congress wrote the idea/expression rule into the statute and added “procedure, process, system, method of operation”. The legislative history says the 1976 Act did not intend to change the law (from memory; not checked).
  • CONTU (1978) and the 1980 amendment. A commission recommended copyright for programs; Congress agreed. This is the origin of the problem she opens with: the most functional artefact (object code) was put in the expressive bucket. Feeds the talk. Her whole project is to give the extra § 102(b) words content. Without that, the “idea” label does nothing, and everything in software looks like potential expression.

2.2 Functionality doctrines — merger, scènes à faire, useful articles

Problem. Some elements are shaped by the job, the standard, or the machine, not by authorial choice. Chain. Baker (merger in embryo) → Morrissey v. Procter & Gamble (1st Cir. 1967), merger for contest rules → Mazer → Altai’s filtration (1992) → Lexmark (6th Cir. 2004), where Static Control’s chip had to contain the printer’s lock-out code to work → TrafFix (2001), where a utility patent is “strong evidence” that a feature is functional, so trade dress cannot protect it. How it feeds the talk.

  • Lexmark is her example of “a merger of functioning expression” [03:17].
  • TrafFix is her proposed method [12:39]–[14:16]: do not ask whether a thing is “really” function or expression. Look at evidence of function, such as what patents say about the same thing. “There are lots of API packages” with patents.
  • Efficiency [20:43]: “efficiency narrows the range of choices”. She treats it as a merger issue; do not force programmers to use “less efficient ways”.

2.3 The software-copyright test lineage — Whelan to Altai to Borland

Problem. Programs have non-literal structure. When is a rival’s copy of that structure infringement? Chain.

  • Whelan v. Jaslow (3d Cir. 1986). The purpose of the program is the idea; everything else that is not necessary to that purpose is expression. In practice, almost all structure is protected. Samuelson on its facts [19:06]–[20:43]: the defendant ran a dental lab and translated software that implemented a business process; “the only idea is the purpose of the software”. She says nobody thinks Whelan is “really a good decision” [01:44] outside the Third Circuit and the Federal Circuit.
  • Computer Associates v. Altai (2d Cir. 1992). Abstraction-filtration-comparison: break the program into levels of abstraction, filter out ideas, elements dictated by efficiency, external factors and public-domain material, then compare what is left. She likes this, and wants to add § 102(b) procedures/systems to the filtered list. She notes that Altai “doesn’t say filter out procedures processes systems and methods of operation even though that’s in the statute” [03:17] and she offers an explanation in the paper (not given in the talk).
  • Lotus v. Borland (1st Cir. 1995). Lotus 1-2-3’s menu command hierarchy is a “method of operation” and not protectable, because users had built macros on it and would need to relearn. The Supreme Court split 4-4 in 1996, so it left no national rule (from memory; not checked). She says Borland “does give some meaning to those terms” but “didn’t actually connect up the Altai compatibility ruling” [03:17] — she thinks that would have made it stronger.
  • Interoperability cases. Sega v. Accolade (9th Cir. 1992) and Sony v. Connectix (9th Cir. 2000): reverse engineering to build compatible games/platforms is fair use. Sega “calls the interface a section 102(b) type of procedure” [04:52]. Feeds the talk. The talk is a map of these four approaches. Her proposal: use Altai, extended by Borland’s § 102(b) reading, as the default.

2.4 Interoperability, standards and lock-in (law and economics)

Problem. Who owns a standard that many people depend on? If copyright covers the interface, the owner controls entry. Chain. Network effects and lock-in (Katz and Shapiro, Arthur, 1980s) → “compatibility” as a competition issue (Lotus v. Borland users’ macros) → software-copyright scholars on “open interfaces”: Samuelson, Lemley, Menell (and others) on both sides → EU SAS Institute v. World Programming (CJEU 2012: functionality, programming language and data-file formats are not protected by the Software Directive; from memory; not checked). How it feeds the talk. Her five-way sort of compatibility [07:57]–[09:30] is the legal version of this economics. The “human interoperability” point [09:30]–[11:05] is the new one: switching costs on people, not machines. This is a rare move: the cost is learned skill. Compare the EU rule above, which covers programming languages directly (from memory; not checked).

2.5 Patent–copyright relations and “categorical exclusivity”

Problem. Are the two regimes mutually exclusive, or can an artefact sit under both? Chain. Baker (use goes to patent) → Mazer (a patentable design can be copyrightable) → Dastar and TrafFix (the Supreme Court is wary of using IP to get around the limits of other IP; from memory; not checked) → Alice (2014) shrinking software patents. How it feeds the talk. Her opening worry [00:11]: if patents lose software, “copyright has to step up to the plate”. Her proposal [14:16]: do not apply categorical exclusivity; use the patent as evidence of function. She is explicit that the right outcome for the compare method header may be neither [12:39].

2.6 Why function and expression do not separate — philosophy of computing

Problem. A program is both a text and a machine action. Is “what it does” separable from “how it is written”? Chain. Turing and the stored-program idea (1936–45): code and data are the same stuff → the Curry–Howard idea (1960s–80s): programs are proofs, so code is specification (from memory; not checked) → software engineering’s levels of abstraction (Dijkstra, Parnas, 1960s–70s): every layer is “what” for the layer above and “how” for the layer below → Lessig’s “code is law” (1999) as a legal gloss. How it feeds the talk. This is the root of “turtles all the way down” [15:51]: every “idea” at one level is the “expression” at the level above. Altai’s abstraction levels try to formalise this. She does not name any of these thinkers, but her conclusion (“you can’t really” separate them) is the legal reading of this view. Mark: this lineage is my addition.

Problem. If copyright is narrowed, will innovators lose incentive? Chain. Trade secret law (UTSA 1979, DTSA 2016) → contract and licensing (EULAs, open-source licences, GPL as a copyright-based hack) → first-mover and complementary-asset strategies (Teece, 1986) → open-source and “network effect” business models. How it feeds the talk. [17:26]: copyright “doesn’t have to do all the work”, because developers “rely on trade secrecy and licensing a lot” and “first mover advantage is more important than many other kinds of things”. She puts this at the end of her argument, as the answer to “but who will pay for innovation?“.

Problem. Courts sometimes shape doctrine to the policy mood. Chain. Legal realists (Holmes, Llewellyn, Frank, 1920s–30s) → Posner and the economic analysis of IP → specialised courts: the Federal Circuit (1982) was set up to unify patent law and is known as pro-patent (from memory; not checked) → the question of a patent court deciding a copyright appeal because the case began with patent claims. How it feeds the talk. Her “theory” [14:16]–[15:51] is a realist claim: a patent-oriented judge, losing patents to Alice, would defend copyright. Labelled as her conjecture above. It is also a structural point: the Federal Circuit heard a copyright question only because patent claims were joined to the case (from memory; not checked), and applied Ninth Circuit law.

How the traditions meet

                 Baker v. Selden (1879): system ≠ expression
                                |
        §102(b) text (1976) --- CONTU / 1980: programs get copyright
                  |                           |
     merger / scènes à faire         object code = "most functional"
   (Lexmark, TrafFix, efficiency)             |
                  \                           v
   Whelan (1986) <---- how to carve non-literal structure ----> Altai (1992)
   "purpose = idea"                                    filtration
                                   \                  /
                                  Borland (1995): method of operation
                                           |
         interoperability (Sega, Connectix, Borland macros) + human interoperability
                                           |
              Oracle v. Google: district court (2012) -> Fed Cir (2014)
                                           |
        patents shrink (Alice 2014) -> "copyright steps up"?  <-- Samuelson's worry
                                           |
        Samuelson's answer: proxies, exclude behaviour/languages/interfaces/algorithms;
        secrecy, licensing, first-mover do the rest
                                           |
              2021 Supreme Court: assumes copyrightability, decides FAIR USE

Part 3 — Deep dives

1. The problem: functional software in an expressive regime

🎙 In the talk. She says she has been interested “over more than 30 years” and that “the Oracle be Google case has given me heartburn” [00:11]. Copyright is for original expression, patents for functionality, “but we have with computer programs a subject matter where Congress assign copyright to protect the most functional part of software namely the object code” [00:11]. She welcomes the news that “the patents aren’t doing as much work on software” after Alice [00:11]. She worries that copyright will be asked to take over. Clear cases: source and object code, and video-game graphics that look “like movies” [01:44]. The puzzle is non-literal elements: “how do you tell the difference between the structure that’s a method of operation in the structure that’s expression is a puzzle” [01:44].

📚 Deeper theory

  • Why Congress did it. The 1980 choice (2.1) was largely about stopping piracy of mass-market programs (from memory; not checked), and about avoiding a new right. It put a text-like right on a machine-like object.
  • Why the dichotomy strains. In most literary works, the idea can be said in many words. In code, the “idea” (what the program does) is often most of the value, and any copy of the function in other words is another program. See 2.6.
  • Patent displacement is a known pattern. When one regime narrows, owners go to the next (2.5). She names this as her fear.
  • Software is not unique. Compare architecture, recipes, forms, and databases, where law also separates “useful” and “expressive” (Baker, 2.1).

Where others push back. Supporters of broad protection (for example, parts of the software industry and many Federal Circuit judges) argue that developers invest in design, and that Congress chose to include code. They say weakened copyright invites free-riding and that the “design” of a large API is authorial (the Federal Circuit’s 2014 reasoning, as she describes it at [06:24]).

What she leaves out. Open-source licensing, which relies on copyright to work (the GPL), is not discussed; neither are non-US regimes except by implication.

Check yourself

  1. Why does the fact that object code is covered make the idea/expression line harder in software than for a novel?
  2. What does she say she is afraid of when patents shrink, and why does she dislike the fix?
  3. Which words of § 102(b) does she think the courts have failed to give meaning to?

2. The four case-law approaches

🎙 In the talk. Whelan “has largely been the bunk”, and “except in the Third Circuit it’s not really cited very often anymore because nobody thinks that it’s really a good decision except the Federal Circuit” [01:44]–[03:17]. She says Whelan treats § 102(b) as “really a restatement of the idea expression distinction” so it “doesn’t really have any meaning” [03:17]. Altai “basically” says “there are lots of functional elements in computer programs and there are categories of things that should be filtered out”, but it does not say to filter out the § 102(b) words or efficiency; she is “curious about why that is” [03:17]. Borland “actually does give some meaning to those terms” [03:17]. Lexmark shows “a merger of functioning expression” [03:17].

📚 Deeper theory

  • Whelan’s “purpose = idea” rule means the more ways there are to achieve the purpose, the more is protected (2.3). That is why critics call it too broad.
  • Altai’s silence on § 102(b) is not a mystery in the doctrine: the court used the language of ideas, efficiency and external factors, which already covers much of the same ground (an argument from the other side; from memory; not checked). Samuelson says the paper explains it; I have not read the paper.
  • Borland is a one-circuit decision and, after the 4-4 split, has limited reach (2.3).
  • Merger and § 102(b) as she ends the talk: they are “not that far away” [22:19] — a sign that she treats § 102(b) as the statutory home of the case-law doctrines.

Where others push back. Defenders of Whelan and the Federal Circuit say that Altai gives too little protection to the designer’s work, and that the “comparison” step then has little left to compare. Defenders of Altai say Whelan is too easy on plaintiffs. Some say Borland is too hard to apply to a non-menu API.

What she leaves out. The talk is 23 minutes, so there is no space for the Ninth Circuit’s Oracle-adjacent tests (e.g., Apple v. Microsoft and Johnson Controls, from memory; not checked), or the EU position (2.4).

Check yourself

  1. What does Whelan treat as the “idea” of a program, and why does that lead to broad protection?
  2. What does Altai filter out, and what does she wish it also filtered?
  3. Why does she call Borland a missed opportunity?

3. Five kinds of compatibility

🎙 In the talk. “There are several different types of compatibility issues that have been posed in these cases and it’s actually I think useful to break them out” [07:57]. Her sort: (1) Altai, two scheduling programs designed to work with the IBM operating system’s interface; (2) a case where “you have a platform and you have somebody wanting to adapt an application so that it runs on that popular platform” [07:57] (the Sega/Accolade type); (3) Connectix, where “Sony makes a platform and … the connecting does wants to make a platform that will interoperate with those games” [09:30]; (4) Borland, where “users have constructed these many programs these macros in the Lotus command language” [09:30]; (5) Oracle, which is “partly of a different sort” [09:30]. In Oracle there is machine interoperability (millions of Java programs may run on Android) and the “harder problem”, human interoperability [09:30].

📚 Deeper theory

  • Direction of dependence is what differs. Who is the platform, who is the add-on, and who has the installed base? Direction matters to antitrust and to copyright (2.4).
  • Reverse-engineering doctrine (Sega, Connectix) rests on fair use, not on copyrightability. That is the same door the Supreme Court used in 2021 (current debate §1), which is a good reason to read these cases next to Google. (My connection, not hers.)
  • Switching costs on humans. The 9 million programmers are an installed base of skills. Economists call this “human capital specific to a platform”. The Supreme Court reasoned in a similar way about programmers’ “accrued talents” in 2021 (as reported).
  • Cross-border. The EU treats programming languages as outside copyright protection (2.4).

Where others push back. The Federal Circuit said that compatibility goes to fair use or to the defence, not to copyrightability, and that commercial interoperability goals are “irrelevant” to copyrightability ([06:24], her account of the court). She disagrees. Oracle’s argument, as she puts it [11:05], is that Google could still “speak in Java”, only in “a different dialect”.

What she leaves out. Whether Android’s partial compatibility with Java was a goal or an accident, which was contested in the litigation (from memory; not checked).

Check yourself

  1. Give the difference between Connectix and Borland in the direction of compatibility.
  2. What is “human interoperability” and why is it harder than machine compatibility?
  3. Why does she say Oracle’s “different dialect” argument is a real problem?

4. The Federal Circuit’s 2014 reasoning, and the compare example

🎙 In the talk. She walks through the district court (the API commands are “a system or method of operation within the meaning of section 102(b)” [04:52]) and the Federal Circuit’s reversal. The Federal Circuit “throws the merger argument out”, says “there’s originality in what the Sun engineers” did “because it was a creative” design, and that “there’s no compatibility exceptions to copyright” [06:24]. It relied on Apple v. Franklin for the point that interoperability is “commercial and competitive” and so irrelevant to copyrightability [06:24]. It reads § 102(b) as “just a restatement of the idea expression distinction” [06:24]. It added that otherwise all software would be unprotected [07:57]. Then the example: a method header “for comparing two numbers and figuring out which one’s bigger” [12:39]. “Where’s that poetry? I think it looks more like math to me” [12:39] (her words in the captions: “where’s that poetry I think it looks more like math to me”). It is “copyright subject matter, patent subject matter, both or neither”, and “I would argue neither is probably the right answer” [12:39].

📚 Deeper theory

  • Originality vs scope. The Federal Circuit asked whether the API was original (creative choices exist). She asks what is excluded once it is original. These are two different steps in copyright analysis. Many commentators say the 2014 court merged them (from memory; not checked).
  • Choice of many names is not authorship of the function. In a standardised header, the name and parameter types are the contract. The 2021 majority’s remark that such code is bound up with a system that “always serve a functional purpose” is the same intuition (as reported).
  • “All software would be unprotected.” The classic slippery-slope. Her reply in the talk is partial: program code and screens stay protected [15:51], and secrecy and licensing carry the rest [17:26].
  • Procedural note. The Supreme Court did not review the 2014 copyrightability holding (current debate §1).

Where others push back. Oracle and its amici: the API is a deliberately designed, hierarchical library, and re-use by a competitor (to attract the same developers) is the free-riding that copyright forbids. Justice Thomas’s dissent made a version of this, and said the code was protectable and Google’s use was not fair (Jones Day).

What she leaves out. She says “I’m not going to say the other two” cases [09:30], and the talk has no discussion of damages, or the later jury verdict.

Check yourself

  1. Which three points did the Federal Circuit make against Google (merger, compatibility, § 102(b))?
  2. Why does she say the compare header looks “more like math”?
  3. In what sense is her “neither” answer different from the district court’s holding?

5. Categorical exclusivity and the TrafFix method

🎙 In the talk. “I think a lot of my paper is about an idea of categorical exclusivity”, things belong “either in the patent bucket or the copyright bucket” [12:39]. That is what Baker “taught”, “but the Supreme Court and a couple of other cases has not been very happy about categorical exclusivity type of arguments” [12:39]–[14:16]. The better argument is TrafFix: a utility patent described the spring’s function, so the court said “let’s look at the patent” and the patent’s account of why it performs that way is strong evidence that this is functional subject matter [14:16]. “Since there are lots of API patents out there we might want to look at them” [14:16]. But software patents are being eroded after Alice [14:16]. She thinks that “is a good thing” [14:16].

📚 Deeper theory

  • TrafFix (2001): the Court said that a utility patent is “strong evidence” that the features claimed are functional, and so cannot be trade dress. Samuelson proposes using the same logic across the patent/copyright line (2.2, 2.5).
  • Irony she points to. Using patents as evidence needs patents. If Alice removes software patents, the evidence disappears (her own tension at [14:16]).
  • Overlap in practice. Design patents and copyright, trade dress and utility patents, and software patents and copyright already overlap (from memory; not checked). “Exclusive buckets” never described the practice well.

Where others push back. Others say overlap of protections is normal and harmless. Some say patent claim language is a poor guide to what is copyrightable. The TrafFix logic was designed for trade dress, where the statute has an express functionality bar (from memory; not checked).

What she leaves out. She does not address the cost of requiring courts to read patents in copyright cases.

Check yourself

  1. What is “categorical exclusivity”, and what does she think of it?
  2. How does TrafFix work as a model for software?
  3. What problem does Alice create for the TrafFix method?

🎙 In the talk. Her theory of the Federal Circuit: the judge “was going to uphold all of the patents in alice” and then said “not going to let that happen to copyright”, and “gave a very expansive interpretation” [15:51] (captions garbled; read as her conjecture). The question: “patents are shrinking now this copyrighted expand to fill the gap. I don’t think that’s the right thing to do” [15:51]. “Can you separate function and expression the answer is no and software you can’t really it’s turtles all the way down” [15:51]. So “you have to develop a set of proxies and also put things in some context” [15:51]. Protect program code and expressive screens; “maybe there are some non-literal elements” that are expression: I’m agnostic about that [15:51]. Exclude “program functional behavior, languages, interfaces and algorithms” as procedures, processes, systems [15:51]. She would adopt the Altai test to exclude such things [15:51].

📚 Deeper theory

  • Proxies are a standard legal tool when a line cannot be drawn directly: filtration levels (Altai), patents as evidence (TrafFix), standards, industry practice, and what a reasonable programmer would do (2.3, 2.6).
  • The risk of proxy-based tests is that proxies are gamed: owners file patents or publish specs to shift the proxy.
  • Why “agnostic” matters. She does not claim all structure is unprotected; she leaves room for expressive structure, so her view is narrower than “software should have no copyright”.
  • 2021. The Supreme Court did not adopt a proxy test; it used fair use’s four factors (current debate §1).

Where others push back. Critics from the pro-protection side say this list (behaviour, languages, interfaces, algorithms) is too broad, and that a long API is more than an algorithm. Critics from the other side say she is too cautious and the whole non-literal domain should go.

What she leaves out. Which proxies, in detail: the talk points to a paper for the list. I did not read it.

Check yourself

  1. What does “turtles all the way down” mean for the function/expression split?
  2. List the four things she would exclude from copyright.
  3. Why does she say she is “agnostic” about some non-literal elements?

🎙 In the talk. “Copyright doesn’t have to do all the work because actually software developers rely on trade secrecy and licensing a lot first mover advantage is more important than many other kinds of things” [17:26]. “Secrecy does most of the work in this space and maybe copyright [does] a little bit” [17:26]. A questioner raises Whelan; she notes the defendant “actually ran a dental lab” and had to “teach” the programmer his business process [19:06]–[20:43], which suggests the modules were “simply a software implementation of the business process” [19:06]. On efficiency: “efficiency narrows the range of choices” [20:43]; courts should not force programmers to use “less efficient ways of doing something” [20:43]. On Baker: the form similarities were “necessary incidents to the ability to reuse the system” [22:19]. She says that “merger and 102b” are “interchangeable” in about a dozen cases [22:19] and “once the system or method of operation is unprotected then the range of choices for anybody else who wants to express that same system are constrained” [22:19].

📚 Deeper theory

  • Trade secrecy and licensing as substitutes (2.7). The tension: secrecy cannot protect widely distributed code or published APIs, so for an open API the real choice is copyright or nothing, which is the 2021 dispute in miniature.
  • First-mover advantage and complementary assets (Teece): a point from the innovation literature that she invokes without naming it.
  • Efficiency as a merger factor is the Altai filtration step, and it is controversial because “efficient” depends on the goal (speed, memory, readability) (2.2, 2.3).
  • Business processes as ideas. Computerising a method of working puts “the method” inside the program; Baker says the method is not owned by the book (2.1).

Where others push back. Developers of APIs or libraries who sell access argue that secrecy and licensing do not work for them, and that copyright is the base of licensing (GPL and commercial dual licences depend on copyright). Others say first-mover advantage favours incumbents, not innovators.

What she leaves out. Empirical evidence for how much secrecy and first-mover do the work; she gives it as a claim, not a study (in the time available).

Check yourself

  1. Name three non-copyright ways she says developers protect software.
  2. How does she link efficiency to merger?
  3. What does she mean by merger and § 102(b) being “not that far away”?

Putting it together

Mental model. Software copyright is a boundary that has to be drawn by proxy. The statute draws it between expression and idea/system/method (§ 102(b)), but code is function all the way down, so the courts have tried four tests (Whelan, Altai, Borland, merger) with different answers. Samuelson’s view: use Altai with § 102(b) given real meaning, treat different compatibility problems differently, and do not let copyright fill the gap left by patents, because secrecy, licensing and speed already protect developers. The Supreme Court, in 2021, ended the case by a different route: it assumed the API was protectable and held that Google’s copying was fair use, so the boundary question she cared about is still open.

Open tensions.

  • Is a standard that others depend on protectable at all? Fair use may protect a copier, but it is a defence, not a scope rule.
  • Is human interoperability (learned skills) a copyright concern, a competition concern, or both?
  • Does the 2021 reasoning (functional code, accrued programmer skill, public benefit) give the same results for future APIs as for Java’s? Commentators doubt it (current debate §1).
  • With AI tools trained on public code, who counts as the author, and what remains “expression” (current debate §4)?
  • Her conjecture about the Federal Circuit’s motive cannot be checked from the opinion.

Reading path.

  • Start: this page’s Summary and Part 1 → the 2021 Supreme Court opinion’s syllabus (not read by me) → BCLT event page for Samuelson’s own post-decision view.
  • Then: Altai (2d Cir. 1992) and Lotus v. Borland (1st Cir. 1995), read in full; Baker v. Selden; the Federal Circuit’s 2014 opinion (GovInfo PDF, listed in the search results; check it is the 2014 opinion before relying on it).
  • Deeper: Samuelson’s paper (title above; from memory; not checked) and her 2018 article with Clark Asay on fair use in software; the Techdirt podcast for a conversational version; then the Doe v. GitHub materials for the AI-era question.

Graph View

Backlinks