Travis Oliphant on NumPy, SciPy and Open Source

Oliphant recalls learning BASIC, becoming interested in programming through math and problem-solving, and later discusses how language—including Russian and other languages—can shape thought and understanding.

Oliphant describes encountering Python in 1997 during biomedical engineering research, finding Numeric’s arrays and mathematical features useful, and falling in love with Python after returning to code he could still understand.

They discuss indentation, readability and accessibility, and compare Python with Perl, MATLAB and APL. Oliphant explains how arrays, broadcasting and reductions support a different way of thinking about data.

Oliphant explains that he began assembling Python tools he needed for scientific work, including solvers and integration routines, and describes extending Python with C and drawing on existing numerical libraries.

The conversation covers early open-source releases, contributions from users, Linux-based development, a Windows installer that broadened access, and Oliphant’s MRI simulations and academic research.

Oliphant recounts joining Enthought’s effort to bring scientific Python tools together under the SciPy name, the project’s ambitions and coordination challenges, its early release, and the separate creation of Matplotlib and the SciPy conference.

Oliphant discusses his concerns about requiring proprietary software to run research code, his effort to understand economics and open-source funding, and how entrepreneurship drew him away from academia. They also discuss how SciPy was intended to serve scientists.

Oliphant describes goals for SciPy, including useful scientific building blocks, documentation and an interactive environment. He recalls teaching electrical engineering and adjusting his teaching approach to give students more time to follow.

Oliphant recounts requests from the Hubble image-processing community and the divergence between Numeric and Numarray. He explains why he decided to merge their capabilities into a shared array library, which became NumPy.

They discuss the personal and practical risks of the project, the importance of contributors and the first stages of implementation. Oliphant reflects on design choices he would revisit and the time required to make NumPy usable.

Oliphant describes NumPy’s multidimensional arrays, data types, broadcasting and indexing, and the work required to preserve compatibility with Numeric and Numarray. He recalls contributors joining and Matplotlib adopting NumPy.

Oliphant discusses NumPy’s growing role in science, his tenure review and his move from academia to Enthought. He explains his interest in entrepreneurship and how he viewed profit as a way to coordinate voluntary activity.

Oliphant describes writing and selling *Guide to NumPy* to support a graduate student, setting a fundraising target before making the book free, and later releasing its material for broader documentation work.

Oliphant reflects on his time at Enthought, the beginnings of Anaconda, and what he would change in NumPy’s type system. They discuss how historical design choices affect contributors, GPU support and later tools.

The discussion considers whether a common array interface can connect distinct implementations. Oliphant describes work on a shared API, compares the approaches of TensorFlow and PyTorch, and discusses community participation and funding.

Oliphant recalls an early Microsoft offer for Anaconda, his conversations and work related to Guido van Rossum and Python, and the challenges of handling criticism and leadership. They discuss positive intent, contributor engagement and communication across technical communities.

Oliphant reflects on why the Python 3 transition took time, including the value of its early releases, breaking changes, user inertia and the limited funding available for volunteer-led projects.

Oliphant describes his efforts to create opportunities for open-source entrepreneurs, then discusses when NumPy operations on scalars may be slower than alternatives and why optimization depends on the use case.

Oliphant explains universal functions, broadcasting and vectorized array operations, and how Numba can compile loops. They discuss Python’s ability to use compiled libraries and the distinction between runtime compilation and precompiled software.

The conversation turns to abstractions such as dictionaries and arrays, the value of labeling data, and work to support NumPy and SciPy. Oliphant and Fridman discuss international open-source collaboration and the hope that coding across borders can support human connection.

Oliphant traces Numba’s origin to the desire to compile Python functions for array work. He describes its typed subset of Python, type inference, decorators, LLVM, and the challenges of developing and rewriting a compiler.

Oliphant describes funding Numba through Anaconda, grants and consulting, including an early GPU-focused commercial version. He outlines Anaconda’s goals and names projects such as Dask, Bokeh, Conda and JupyterLab.

Oliphant explains the difficulty of distributing scientific Python software, why Conda was designed across operating systems and programming languages, and the distinct needs of package developers and end users.

The conversation covers scikit-learn and the challenge of installing compiled dependencies. Oliphant compares Conda and pip, discusses binary packages and package variants, and argues that Conda needs broader community participation.

Oliphant discusses Conda’s governance and the possibility of combining Conda and pip, then introduces QuantSight and its work in data science, training and support for open-source projects.

Oliphant explains QuantSight’s consulting work and QuantSight Labs’ mission to fund maintenance and development of projects including NumPy and SciPy. They discuss hardware, scaling data work and collaboration with PyTorch and TensorFlow.

Oliphant describes OpenTeams as a network connecting enterprise software needs with open-source providers, alongside a model for funding open-source work through businesses and investment. They discuss procurement, customization and the organization’s early plans.

They discuss Microsoft’s purchase of GitHub, how companies can support developers and open-source projects, and why corporate marketing may not communicate engineering work effectively. Oliphant describes the challenge of connecting open-source contributions to business priorities.

Oliphant offers advice on curiosity, breaking problems into manageable parts, understanding rather than blindly copying code, and being wary of hype cycles. He emphasizes listening to users, iterating, working through difficult problems and giving projects time.

Oliphant talks about using Emacs and Linux while building SciPy and NumPy, his changing appreciation of Lisp, and why occasional programmers benefit from accessible languages. He also discusses his move to Mac laptops.

Oliphant recommends hiring people through their contributions to open-source projects, while noting the difficulty of assessing candidates. He discusses the different strengths of product-focused and open-source contributors, and the importance of humility and learning.

Oliphant advises young people to build relationships and commitments, remain open to changing their views, follow curiosity and build alternatives rather than only attacking what they dislike. The conversation closes with thanks.