Travis Oliphant wrote NumPy in an empty semester — and still wants open source to pay

Lex Fridman introduces Travis Oliphant as the programmer behind NumPy, SciPy, and Anaconda, then asks for the first program he remembers. It was fourth grade: a BASIC loop on an Atari 800, or maybe an Atari 400, printing things in a class. They used GOTO. A teacher told him not to — that it violated good software engineering — and that was the first time he realized the game had principles. He did not meet those principles again until a high-school AP course in Pascal. C waited until college.

The romance came earlier. At ten his father brought home a Timex Sinclair, excited about the spreadsheet; Oliphant made him buy the BASIC add-on. The machine had 2K of memory, they added a 16K pack, and storage was a tape drive that turned bits into sound. He still remembers that sound. Around twelve they moved to a TI-99/4A with sprites, graphics, and music you could program. That, he says, is when he really fell in love.

Math had always been the draw, though he is clear-eyed about why children get labeled good at it: early math is memory, times tables, a short buffer. He had a decent one, so adults called him mathematical. What he actually liked was problem-solving. A computer was that habit applied. He did not yet see the machine as an extension of his mind — it was too rudimentary; a thought and a running program were separated by too much labor. Years later Python would close that gap. "I could think in Python," he says.

That remark opens a detour on language. Oliphant's other fluent language is Spanish; he remembers the day he began to dream in it. Fridman, who speaks Russian, talks about a tongue loaded with war, famine, broken promises, and a culture of rhyming poetry — and about how Dostoevsky, less dependent on musicality, still works in English while poetry does not. Oliphant agrees that language leads the mind down paths, then says the sad part out loud: much of science and technology lives in English, so a lot of genius never surfaces. It is one reason he leans toward tools that empower people and resists authoritarian structures.

Oliphant first met Python in 1997 as a biomedical-engineering doctoral student at the Mayo Clinic. He had already pulled signal from satellites as an electrical engineer, using MATLAB, Perl, VMS scripts, and the Fortran tools around them. That year he filtered languages, including Yorick. Two things kept Python from being discarded. One was arrays: in 1995 MIT alumnus Jim Hugunin had written Numeric, the first real n-dimensional array object in the language. People now say tensor; Oliphant still thinks it should be called an ndarray, and he lost that naming fight.

The other was complex numbers. A computer scientist can treat a complex as two floats and tell users to build it. For someone who lives in FFTs, a complex number is one of the algebras that joins physical and mathematical ideas. If the language does not ship it, every group reinvents it, and the inventions do not share an approach. Shared abstractions, he says, are powerful because a community can think the same way, and dangerous because they hide what was left behind. That inertia is why a language like Julia, which he likes, still struggles against the tide of Python.

The moment he fell in love was smaller. In 1998 he looked back at Python he had written in 1997 for elastography work — pushing waves into the body with ultrasound and MRI, then inverting for elasticity — and he could still understand it. Perl from 1995 was a blank. He was not becoming a Python expert. He could keep using the language without becoming one. Indentation instead of braces was a leap, and he knew the concrete costs: paste errors, mixed tabs and spaces, dumb terminals. He almost never hit them, and he liked a visual field without extra characters. Perl prized compactness until the culture made unreadability a badge. Python let him use the English-language center he already ran all day.

He wonders, without having studied it, what it is like to learn those English keywords if you grew up in Japanese or Chinese. Array thinking, though, he will defend to anyone steeped only in systems or web programming. APL in the 1960s treated a whole array as an object, invented glyphs and even a keyboard, and grew a culture — like Perl's — that prized writing the Game of Life in thirty characters. Microsoft, culturally, missed array programming for years. MATLAB inherited the tradition; Numeric inherited broadcasting and reduction; NumPy inherited Numeric. Once an n-dimensional array is a first-class citizen, he says, you stop thinking of it as an implementation detail and start thinking in dimensions.

SciPy is the older child. In 1998 and 1999 Oliphant was using Numeric the way he had used MATLAB and finding holes: no ordinary-differential-equation solver he could just call, no integrator, no optimizer that took a function and returned a minimum. People on the mailing list, Conrad Hinson and David Ascher among them, wished out loud for those libraries. He was a poor graduate student whose wife thought he was working on a PhD — he was — and part of a PhD he loved was the freedom to decide what to build. He started writing the tools he needed.

The first extension module was an I/O package to read DICOM medical images, his first C code against Python. Guido van Rossum's post on reference counting was the only thing that kept him from getting lost in leaks. Then he found Netlib: hundreds of Fortran 77 routines already written and tested in the 1960s through 1980s. Fortran 90, with complexes and arrays, is his favorite Fortran; you would never write a whole program in it, but a subroutine is fine. He wrapped ODE solvers and Quadpack, shipped gzip tarballs from a bad web page, and watched a hundred users appear. Pearu Peterson in Estonia sent a makefile he never fully understood. A high-school student named Robert Kern built a Windows installer for the collected "multipack." Usage jumped. Binary installers, Oliphant realized, decide whether a community grows. That lesson later became Anaconda.

In 2001 Eric Jones and Travis Vaught pulled his modules together with Pearu Peterson's F2PY and other pieces, shipped a single installer, and named it SciPy. The original vision was an entire R&D environment — arrays, math, plotting, a REPL — MATLAB inside Python. Open-source collectives, he argues, have a cooperation limit: they are superb at infrastructure and bad at product management once too many cooks arrive. Plotting went to John Hunter, a quant who released Matplotlib the same year as its own library. Enthought founded the SciPy conference around fifty practicing scientists who wanted to code well and stop depending on MATLAB. Oliphant is not an open-source zealot. What he disliked was publishing code and then telling readers they had to buy a MATLAB license to run it.

He had three children then, and would have six. He admired Richard Stallman's writing on intellectual-property law and collective work, then hit a line whose gist was: be like me and do not have kids. That was a train he could not board. There had to be a way to keep the culture of open source and still feed a family. The gap sent him, during the same PhD years, into economics he had never been taught. He was his high-school valedictorian and a strong college student, and he is embarrassed that a person can do all of that and still not know how money or prices work.

He read Marx and Adam Smith and landed on Ludwig von Mises's 1920 essay on the economic calculation problem of the socialist commonwealth, written after the Bolshevik Revolution. Without private property there are no real prices; without prices bureaucrats cannot allocate; prices emerge from trades, and trades require authority over what is traded. Top-down systems do not get that information flow. The argument clicked. Prices are a signal. Open source has a cousin: whoever can solve the problem gains influence, scored in reputation and contribution instead of currency.

The same years he was teaching at BYU — signal processing, probability, electromagnetism — and collecting bad reviews for speaking too high. Respect for students, he says, made him assume they already knew what he knew. His first class used overhead transparencies in a dim room; a quiz after two weeks showed that nobody had learned anything. He put the sheets away and turned to the chalkboard. Writing slowed him down, gave people time to think, and made him focus. Ugly handwriting, a version of himself he loved. That lesson entered SciPy: names short enough to glance at, documentation rich enough to carry someone into the details, knowledge handed over rather than shown off.

By 2004 Oliphant was on the tenure clock. The review said papers were coming, but he should do less open source and more grant writing. At the same time the young scientific-Python world was splitting. Perry Greenfield's Hubble team needed richer array types, stabler broadcasting, and record arrays Numeric did not have, so they built NumArray. Then ND Image arrived — morphology, dilations, openings, the segmentation tools a medical-imaging person had always wanted in SciPy — and it ran only on NumArray. Numeric and NumArray could not share data. A process could hold a gigabyte of each. Two memories, two stacks, two communities repeating work.

Fate handed him a gap. He had listed a digital-MRI course; two students signed up and dropped, and he had no other class that term. He decided to merge the libraries. He had written Numeric's C-API documentation with Paul Dubois, David Ascher, and Conrad Hinson, so he knew the structures. Four months produced a first version; fourteen more made it usable. The hard stretch was those first four months. The technical centerpiece was a new type object, dtype, plus real broadcasting and advanced indexing — masks and indirect indexes, not only slices. To bring both camps over he had to be backward compatible with Numeric and NumArray. Much of the odd complexity still in NumPy, he says, is a fossil of that goal. If you designed from zero you would not write it that way.

Fridman praises the empathy and the lack of ego, the same failure mode he sees in JavaScript frameworks that fork instead of listen. Listening is not enough, Oliphant adds. You have to want to build the thing. About six months in, Francesc Alted, Robert Kern, and Charles Harris joined — unsung heroes who encouraged him by contributing. The lock came in 2006, when John Hunter dropped Matplotlib's dual Numeric/NumArray backend and made NumPy the dependency. "We've done it," Oliphant thought. From 2006 to 2009 the impact floored him. People began to think in NumPy. That change of language, not just of library, is what he had not fully seen coming.

Tenure in 2006–2007 split the department, went to the university president, and came back as an invitation to try again in two years. He declined, called Eric Jones, and in 2007 moved to Texas. He stayed at Enthought four years and became president; together they helped Jones buy out a partner. It did not end well. He and Jones are not friends now. He still respects him and will not tell one side of the story. In 2012 he and Peter Wang founded Continuum Analytics, renamed Anaconda in 2015.

Before that exit he had already run an experiment. He had a graduate student and no grant, and he did not want the usual fundraising circuit, so he wrote *Guide to NumPy*, published it himself, and took PayPal. The rule was simple: if the book made $250,000, or after five years, he would open it. In three years he sold 30,000 copies and made $90,000 — enough to pay the student $25,000 a year. About five angry emails called him a bad person for charging; more people treated a book as a fair way to fund open source. A year and a half later he had a salary at Enthought and a SciPy docs group needed the pages, so he opened the book early. Chris White at DARPA remembered the pricing stunt, called Anaconda back, and a proposal that had skipped demo day still got funded. Ninety thousand dollars of book sales became millions in research money.

A 2012 letter to the NumPy list announced he was leaving the project. Looking back he would not have built array scalars as a substitute for types. Python 2 had let user classes become real types; he barely understood that metaclass hook and built a Python-1-era system in which every dtype is an instance of the same type. The cost is not speed. It is clumsiness: new types, quaternions, posits, gradual typing, and a clean join with Numba are all harder. The visible scar is the GPU. There is no fundamental reason a NumPy array should not run on a GPU; CuPy exists because of that history. He is pushing data-apis.org — not one array, a shared API — because today's split, with TensorFlow and PyTorch bolted onto C++ libraries that discovered Python late, is worse than 2005. Facebook, he says, let the community into the structure; Google wanted users more than contributors. He still leans toward the hackers, and he knows you can lean that way and run out of money.

Early in NumPy, Oliphant asked Guido van Rossum for lunch in San Mateo with Paul Dubois and floated putting the array object into Python 3. They did not get NumPy into the language; they did get the bones of it, including a memoryview object whose C guts he wrote and whose Python face Antoine Pitrou and Stefan Krah later had to repair. What he learned from Guido was openness, a willingness to defer on the scientific side, and the habit of answering contributors so they do not walk away. The missing matrix-multiply operator arrived about ten years late. Guido's 1998 note on reference counting is still why Oliphant could write his first extension. The BDFL resignation over the walrus operator is, to him, a familiar kind of pressure: do anything that matters and you will not be universally loved.

The 2012 NumPy letter was a hard season. Critics are necessary, he says, because you cannot get everything right; meanness is something else. When information is incomplete, people fill the gaps with the worst story. He would rather project good intent, because people often rise to it, and because a software team that wants to ship has to practice that projection. It is an engineering requirement, not a moral slogan. Twitter and Facebook learned that negativity buys engagement, so the fight is structural. He also sits in an awkward middle: he cares enough about entrepreneurship to make some open-source people uneasy, and enough about open source to make investors uneasy.

Python 3 is his case study in inertia. In 2005 he was already talking to Guido about riding the Python 3 migration. Support for Python 2 lasted until 2020. Versions 3.0 through 3.2, in his view, did not have enough to like; he treats 3.3 as the real 3.0, 3.4 as the first he wanted, and 3.5 — with the `@` matrix operator — as the one you had to take. Print becoming a function fixed something Guido had always hated. It was not a reason for a huge population to move. You cannot relocate people with "this is the new version" alone. The other lesson is money. Guido had a job, but that job was not full-time Python. The language ran on volunteer labor. Fridman wonders if scarcity is a feature, like underfunded Olympians. Oliphant will grant a piece of that. He does not think money and values are opposites.

Andrej Karpathy, then leading Tesla Autopilot, tweeted that swapping `np.sqrt` for `math.sqrt` in a data-loading path helped, and someone replied that `x 0.5` was faster still. Oliphant is unsurprised. A NumPy math function is a universal function. Call it on a scalar and the scalar is broadcast to a zero-dimensional array, run through the whole ufunc machine — casting, broadcasting, unpacking — and only then handed to a C library sqrt. Python's runtime can specialize a scalar and skip that pageant. Below about a thousand elements, maybe ten thousand, native Python can win, especially when the work is I/O bound. Past that, arrays bring cache locality, SIMD, and easy parallelism. He agrees that premature optimization is a real vice. Clarity lost to a faster square-root is often the worse trade.

Vectorize, inside NumPy, was the fake version of what he wanted: hand it a Python scalar function and get a ufunc, except every element bounced back into the interpreter. In 2009 or 2010 a PyPy attempt was too heavy. In 2012, after he and Wang had just started Anaconda and he had heard Dave Beazley talk about LLVM, he wrote a compiler that mapped Python bytecode onto LLVM IR and let LLVM emit machine code. Numba is itself Python. It does not parse and it does not generate code; it translates. LLVM's gift, he says, is a plateau people can collaborate on — not the internals of GCC or Intel's compiler. The project was rewritten three times. A working prototype is easy; a compiler that is not spaghetti is not.

The business split was clean: free Numba on CPUs, Numba Pro on GPUs, among the first CUDA JITs. By 2013 you could write a ufunc, land it on a GPU, auto-parallelize, and see thousand-fold speedups. Large companies will pay for speed. They will also pay for a good interface. Those, he says, are the two things people reliably buy around open source. The same years he notes a civic mismatch: the twentieth anniversary of September 11, more than six trillion dollars spent in the Middle East, and the people who write the tools that run science still often unpaid. Fridman offers a line — nations that trade together do not go to war; maybe nations that code together do not either. Open source has no border. Business does. Oliphant has run online sessions with programmers in Iran and Pakistan, and he thinks that humanizing layer might matter if the next great-power fight is a cyber war among countries that all have strong developers.

Continuum Analytics began with two technical bets: scale NumPy and pandas across machines, and keep the web from passing Python by. Friends, family, and fools had put in money, so Oliphant would not play venture's go-big-or-go-home game; he consulted so he could not lose their cash, and kept upside on the side. Dask, Bokeh, Numba, Conda, Datashader, HoloViz, Panel, and work that fed JupyterLab came out of that energy. Two DARPA proposals went out; the numerical one missed a five-minute cutoff. Chris White still let some money leak toward foundations. The packaging fight was older. At a 2012 Googleplex gathering — Wang has a photo of Oliphant talking to Guido — they said users could not get the software. Guido's answer was: fix it yourselves. He does not install new libraries. If you created the language, Oliphant grants, you can put what you need in the distribution.

The pain was already distorting NumPy. Someone told him not to change the library because they had spent a week getting Python installed, and a change meant doing it again. SciPy is full of Fortran; scikit-learn chains C++. Early Python packaging did not handle binary dependencies. They wanted one manager on Windows, macOS, and Linux, and they did not want it limited to Python. Conda shipped in 2013. `conda install scikit-learn` was, from 2013 into 2017 or 2018, the reliable way to get that stack. Pip later grew wheels, but a wheel stops at the Python boundary and vendors the binaries. Change an underlying library and you rebuild the whole wheel. He still thinks pip-installing TensorFlow is a bad idea that documentation keeps recommending. Search the web for how to install it and Conda has fallen out of the first page — the long tail of user-generated docs, even though Conda predated pip's answer.

His practical advice is a hybrid: build the environment with Conda, put NumPy, SciPy, and scikit-learn in that base, then pip-install the small pure-Python tools. Be careful pip-installing OpenCV or TensorFlow; once they land they are hard to update. He has wanted pip to defer some dependencies to a system manager — Conda, RPM — and says the feature is not hard, only unfunded. Conda-Forge community-ized recipes. Conda itself, he says bluntly, never became community-driven, and that is a fight Anaconda should not be fighting alone. Every project starts company-backed, even if the company is one person. To become infrastructure it has to pass into other people's hands.

Oliphant left Anaconda in 2018 and founded Quansight, whose stated mission is to connect data to an open economy. The consulting side is a full-stack data-science shop: infrastructure, Dask, GPUs, training, staff augmentation. Quansight Labs is the nonprofit-flavored piece. Companies can buy a "community work order" — a month of a Spyder, NumPy, or SciPy maintainer — and they may state priorities, but they may not dictate the work. Maintainers and the community decide. A slice of every Quansight project's profit goes to Labs. After years of never being paid to work on NumPy, he is finally paying other people to do it.

OpenTeams is the part that excites him most. Enterprises, he learned selling to Exxon, Shell, JPMorgan, and Bank of America, do not lack products. They buy platforms and then pay expensive consultants to customize them. Open source plus the same customization can be cheaper. OpenTeams is a network: it closes the enterprise deal, hands delivery to firms like Quansight, and keeps quality on the hook so the client is not just buying a lead. Quansight Initiate, an early-stage fund, sends a share of carry to Labs. Every venture fund, he thinks, should have an associated open-source lab — investors see young companies, labs see communities, and the loop should be a product. Anaconda, in his autopsy, invented too much and structured too little: Dask has already thrown off companies, Bokeh could have been one, JupyterLab several. He wants that emergence to become a recipe.

Microsoft's 2014 approach to buy early Anaconda came from two levels below Satya Nadella, after the company had bought an R shop and wanted a Python side bet. If Scott Guthrie had made the offer, Oliphant says he would probably be at Microsoft now. He calls the GitHub acquisition smart because Microsoft has always known its power is developers — Ballmer's meme was clumsy, the insight was not. What he does not yet see is a topology like OpenTeams. Cheering for developers and getting them paid are different jobs. His marketing advice to companies that want hacker goodwill is blunt: take a slice of the ad budget and give it to NumPy, SciPy, Jupyter. Treat it as marketing with a readable ROI, not charity. NumFOCUS exists to make the transfer easy. The hard part is reaching a CMO who can move the money, and not throwing cash in a way that creates new problems.

Asked what makes a good programmer, Oliphant starts with curiosity. Without it the work goes mundane and the best work does not happen. Second, do not try to do everything at once. Limit the problem: write down inputs, outputs, and what you are actually trying to accomplish before you write code. Big projects swallowed whole get done badly. Third, use other people's work. Copying from Stack Overflow — or from Codex, which he treats as a search engine over Stack Overflow — is fine if you then understand the snippet. Blind paste teaches nothing. Fourth, stay suspicious of hype cycles. Test-driven development, object orientation, Agile: each slogan has a signal, and none of them is the answer to everything.

How do you become the next person to create a SciPy? Listen to people who have a problem, which is everyone, then do the experiment. The first version will probably suck. Iteration is the core of innovation; the psychological hesitation to ship the bad thing is what stops people. Good work is not a scroll. Sit with a deep problem for an hour or two. Building SciPy and NumPy was hugely lonely. The inner drive, for him, was a belief that the thing was right: Python already had influential users and needed libraries, so writing them was a good in itself. Give a new open-source project eighteen months before you decide the feedback is in. Six months is not enough. You are dealing with human inertia.

The setup that produced those libraries was Emacs on a Linux box, first CVS, then SVN, Git later. He once tweeted that Emacs beat Vim, ate the replies, and deleted the tweet; for a one-character fix he will still open Vim. Lisp's parentheses used to block his thinking; he appreciates the structure now, and projects like Clojure and Hy, but he does not think Lisp will capture occasional programmers — people who will never code for a living and do not want cute syntax in their heads. That is why BASIC worked, and why Microsoft should have moved that niche to Python a decade earlier. He does not use many screens; he swaps windows in his head. He has been on Mac laptops for ten years because conference-room projectors defeated his Linux desktop. Hiring advice is the same as the career advice: start an open-source project, let people contribute, hire them. An hour or two of interviews tells him almost nothing; a couple of weeks of work does. Humility — admitting you need to learn — is the filter he trusts. His wife now tells him he talks too much.

Fridman asks for advice to high-school and college students who want a life they can be proud of. Oliphant starts with family, defined more widely than blood: find people you love, commit to them, and let that commitment be an anchor nothing else can give. Then find other things — ideas, groups — you can also commit to. Especially in high school, do not settle on what you think you know. Give yourself ten years. He sees students who already know everything, the way he did. Perspectives move. He was a fierce libertarian who disliked the Federal Reserve; he is more nuanced now, and he still wants a longer conversation about monetary policy.

The sentence he wants remembered is about construction. The instinct, when you dislike a thing, is to attack it. A better move is to build a replacement and attract people to your path. You do not need to destroy one project to establish another. Follow curiosity. Do not only follow money. Find something you believe is right and stay with it long enough for human inertia to catch up. Fridman closes with a programmer's joke, Hodgson's law: every sufficiently advanced Lisp application will eventually be reimplemented in Python.