Jim Newton

Associate Professor

Team

Automata and Applications

Campus

Paris

Contact

jim.newton@epita.fr

Short Bio

I am an assistant professor at EPITA Paris and at LRE, and member of the Automata and applications research group at LRE.

See also: https://www.lrde.epita.fr/wiki/User:Jnewton

Publications

PhD Thesis. Representing and Computing with Types in Dynamically Typed Languages: Extending Dynamic Language Expressivity to Accommodate Rationally Typed Sequences. Defended 20 November 2018, Sorbonne Université / EDITE de Paris, prepared at EPITA/LRDE (advisor: Didier Verna, director: Thierry Géraud).

This thesis presents code-generation techniques for run-time type checking of heterogeneous sequences in dynamically typed languages. It extends regular-expression-style pattern matching to rational type expressions over heterogeneous sequences (lists, vectors), using meta-programming to generate, at compile time, efficient finite-state-machine-based matching code specialized to each type expression — avoiding the high cost of building that automaton at run time. Building the automaton requires computing a disjoint type decomposition, which in turn motivates an extension of Binary Decision Diagrams (BDDs) to accommodate subtyping in the Common Lisp type system, together with an analysis of BDD worst-case size, used to optimize generated typecase code while preserving its semantics.

Published.

Rejected.

Courses

Course handouts and lecture notes for courses I teach or have taught at EPITA.

Invited Talks

Talks given to Lisp, Scala, and Clojure community conferences and user groups.

Advanced Data Structures. An introduction to fundamental data structures — linked lists, stacks, binary search trees, heaps, and graphs — implemented from scratch in Python. Rather than dwelling on theory, the course emphasizes building and using these structures directly, applying graph algorithms (depth-first and breadth-first search, topological sort, Dijkstra, Bellman-Ford) to concrete problems such as expression evaluation, text compression, and puzzle solving, and connecting mathematical definitions (graph theory, regular languages, tree isomorphism) to their corresponding Python implementations.

Practical Classical Algebra. A review of classical algebra for programmers, taught alongside a parallel introductory Python course. Students reinforce mathematical topics — logic, relations, recursion, divide and conquer, combinatorics, polynomials, limits, roots, and abstract algebra (monoids, groups, rings, fields) — by writing short programs that perform the corresponding computations, making explicit the close relationship between mathematical and computational thinking.

Calculus For Computer Scientists. An introduction to calculus organized around the needs of computer scientists rather than the traditional physics/engineering curriculum. The derivative is introduced first as a set of symbolic reduction rules operating on abstract syntax trees — familiar territory for programmers — before revisiting its formal limiting definition; integration follows, from Riemann sums through the Fundamental Theorem of Calculus to standard integration techniques. Python, NumPy, and SciPy are used throughout, both as computational tools and as a means of building intuition.

Practical Linear Algebra. A course that is simultaneously an introduction to Linear Algebra and an intermediate Python programming course. Concrete vector and matrix computation in n-dimensional real space comes first, building toward the abstract notion of a vector space; topics include Gaussian and Gauss-Jordan elimination, determinants and matrix inversion using exact integer arithmetic, bases, dimension, orthonormality, the Gram-Schmidt process, and eigenvalues/eigenvectors. Every chapter pairs its theory with programming exercises that reinforce both the mathematics and the students' object-oriented and functional Python skills.

Practical Functional Programming. An introduction to functional programming in Scala, covering the basics of the language, recursion, functional-style graphs built on maps, higher-order functions, for-comprehensions and sequence manipulation, and functional-style object orientation — taught for the SCALAIN elective and for APFON (Applications in Functional Programming).

Introduction to Signal Processing (MASI). An introduction to the mathematics of signal processing: what a signal is, and how to analyze and manipulate it. Topics include energy and power, correlation and convolution, Fourier series, the Fourier transform, and analog-to-digital conversion. This English-language handout began as a translation of Guillaume Tochon's hand-written lecture notes, since augmented with additional proofs, background, and clarification.

Theory of Graphs (THEG). A course in graph theory and graph algorithms, working from formal definitions through to working Python implementations. Lectures progress from graph isomorphism and machine representations of graphs, through graph search techniques, to single- and multiple-source shortest-path algorithms (Dijkstra, Bellman-Ford, Floyd-Warshall) and matchings, with each lecture paired with programming homework.

Mississippi Governor's School

For three years (2022–2024) I served as an instructor for the Mississippi Governor's School, a summer enrichment program for gifted Mississippi high-school students. Each year I taught a two-week course connecting abstract mathematics to programming: students used ideas from abstract algebra, logic, and combinatorics as source material for writing programs, and in turn used programming to reinforce the underlying mathematics — all while practicing explaining and defending their ideas to their peers. The three offerings share a common spirit and much shared material, but each has its own handout and slides.

Forge Flow

Forge Flow documents the best-known practices we have developed for creating and maintaining courses on EPITA's Forge/Intranet service (Project Hosting, PaCv2) — the underlying Moulinette-as-a-Service (MaaS) infrastructure used to distribute assignments and automatically grade student submissions. Setting up a course on the Forge is powerful but far from straightforward: a course involves coordinating four separate git repositories (professor, student, moulinette, and grader), each with its own role and its own Makefile targets for propagating changes between them. This document walks through that repository model, the workflow for authoring and releasing assignments, and the grading pipeline, based on several years of hands-on experience running courses on the system.

Current Research

Article under development

Ongoing, publicly-visible projects on GitHub.

Regular Type Expressions (RTE). A cross-language implementation of rational type expressions: a regular-expression-style pattern language for type-checking heterogeneous sequences (lists, vectors, etc. containing a mix of types), compiled to a deterministic symbolic finite automaton. This is the main line of research behind the PhD thesis and most of the publications above, implemented and kept in sync across four languages:

HeavyBool. A "heavy boolean" is a value that behaves as true or false in a boolean context but also carries metadata about why. The motivating case is nested existential/universal quantifiers: when such an expression is false, ordinary booleans give no way to recover which witnesses or counter-examples caused it, since by the time the result is known the bound variables are already out of scope. HeavyBool threads that explanation through as metadata instead, and is implemented in Scala, Clojure, Common Lisp, and Python.