What, why, who?

ACCU Membership: https://tinyurl.com/ydnfkcyn --- The Past, Present and Future of Programming Languages - Kevlin Henney - ACCU 2025 --- Programming languages ...

I am happy to announce that a draft of my upcoming book “Control structures in programming languages: from goto to algebraic effects” is now available at https://xavierleroy.org/control-structures . The book compares several programming languages from the standpoint of control structures. OCaml is used intensively to discuss control in functional programming, including continuation-passing style, control operators, exceptions, user-defined effects and effect handlers, with many examples that I...

Stephen Wolfram explains the rich ruliology of lambdas, made particularly significant by their connection to practical computing. Covers basic computations to undecidability to multiway graphs and evaluation strategies.

Personal blog of Stephen Diehl - Software engineer writing about technology, programming, and the future

Cricket is a lazy gradually-typed functional language with objects. It's very tiny but very expressive; anyone can implement it themselves!

This post briefly maps out many different subfields of programming language theory, in an effort to make it more accessible to those outside academia.

Jonathan Blow critiques modern software practices and argues for simpler, more efficient programming models, discussing language and tooling design principles t...

Walk-through comparing array-oriented languages APL, BQN and Uiua by re-implementing and refactoring the standard-deviation algorithm, highlighting language sem...

Simon Peyton Jones discusses small-core language design in Haskell and the new Verse language, delving into functional-logic programming concepts and their educ...

Jonathan Blow outlines the design philosophy, type system, and compilation goals of his Jai programming language, offering insights into modern language design ...

Jonathan Blow’s talk “The Gauntlet” critiques contemporary software practices and outlines design principles and language-level features (drawn from his Jai wor...

In-depth discussion with two language designers on compiler construction and programming-language paradigms—relevant, expert-level content.

Live-coding session showing how to port code from Zig to the experimental Jai language provides practical insight into systems-level programming and language de...

PLDI 2024 research talk introducing a new safe GPU programming language; highly relevant to programming-language researchers and GPU systems developers.

In-depth discussion on designing a programming language around its AST, covering type systems, effects, and implementation details—valuable for language and com...

Long-form technical interview with the creator of the C3 programming language covering language design and the speaker’s engineering career.

Bartosz Milewski provides an intensive introduction to category theory with programming examples, fitting both educational and theoretical criteria.

Philip Wadler’s lecture introduces category theory concepts for programmers, bridging mathematics and software development.

Technical presentation on building a type system from scratch, relevant to language and compiler enthusiasts.

What did category theory ever do for us (functional programmers)? - An extreme pragmatic and un-academic approach. Examples are in Scala. Talk given at Scale b...

A summary of why Jane Street uses OCaml, including a discussion of how OCaml fits into the broader space of programming languages. Given to our summer interns....

PL Virtual Meetup: https://www.meetup.com/Programming-Languages-Toronto-Meetup/ CtFP Textbook: https://github.com/hmemcpy/milewski-ctfp-pdf Github Repo: https:/...

Conversation with an engineer about designing a functional UI framework in OCaml, covering architecture decisions and related tooling—fits technical-educational...

In this Lambda World 2019 keynote, Emily Riehl discusses category theory and computational effects. Slides are available here: http://www.math.jhu.edu/~eriehl...

ACCU Membership: https://tinyurl.com/ydnfkcyn Join us for ACCU Conference 2025 - 1st-4th April - Online & in Bristol, UK https://accuconference.org/ --- Not Yo...

Conference talk that surveys historical and emerging trends in programming languages, providing contextual and educational value for software engineers.

Watch me start writing an entirely new #programming #language and #codegen from scratch! You can support my work at: http://patreon.com/renerebe https://github....

Uploader: NotImplemented Duration: 717s Views: 10124

ERRATA: • The "Church-Turing Thesis" is different from the "Church-Turing Theorem". The "theorem" is the claim which I discussed in the video- namely, that the ...

[C++ Under the Sea 2024 conference] https://cppunderthesea.nl/ 11th of October 2024 Video recording sponsored by think-cell: https://www.think-cell.com [T...

This presentation was recorded at GOTO Aarhus 2023. #GOTOcon #GOTOaar https://gotoaarhus.com Magnus Madsen - Assistant Professor at Aarhus University RESOURCE...

The purpose of monads and their alternatives (old and new). For people who love monads, hate monads, and those who don’t get them. Make FP click by joining “Ho...

Kit Langton explores algebraic effects, emphasizing separating syntax from semantics. Kit demonstrates this through the Kyo library, discussing syntax and seman...

The Lambda Calculus is a tiny symbol manipulation system which suffices to compute anything Turing-computable. Thanks to this expressive power, LC is woven into...

Orca operates on a base of 36 increments. Operators using numeric values will typically also operate on letters and convert them into values as per the following table.

Even though lots of people nowadays advocate for applying functional programming principles to JavaScript, not many of them know the principles of Lambda Cal...

Yet it seems to me that the situation right now is that LtU has readers with very different backgrounds, among them many readers who haven't studied PL formally.

Haskell is the world’s best programming language, but let’s face the harsh reality that a lot of times in life you’ll have to write in other programming languages. But alas you have been fully Haskell-brained and lost all ability to program unless it is type-directed, you don’t even know how to start writing a program without imagining its shape as a type first. Well, fear not. The foundational theory behind Algebraic Data Types and Generalized Algebraic Data Types (ADTs and GADTs) are so fundamental that they’ll fit (somewhat) seamlessly into whatever language you’re forced to write. After all, if they can fit profunctor optics in Microsoft’s Java code, the sky’s the limit! This is an “April Fools” joke in the tradition of my previous one in some of these ways that we are going to twist these other languages might seem unconventional or possibly ill-advised… but also the title is definitely a lie: these languages definitely should have them! :D

Intuitively Template Haskell provides new language features that allow us to convert back and forth between concrete syntax, i. e.

A re-construction of the fundamentals of programming as a small mathematical theory (PRISM) based on elementary set theory. Highlights: $\bullet$ Zero axioms. No properties are assumed, all are proved (from standard set theory). $\bullet$ A single concept covers specifications and programs. $\bullet$ Its definition only involves one relation and one set. $\bullet$ Everything proceeds from three operations: choice, composition and restriction. $\bullet$ These techniques suffice to derive the axioms of classic papers on the "laws of programming" as consequences and prove them mechanically. $\bullet$ The ordinary subset operator suffices to define both the notion of program correctness and the concepts of specialization and refinement. $\bullet$ From this basis, the theory deduces dozens of theorems characterizing important properties of programs and programming. $\bullet$ All these theorems have been mechanically verified (using Isabelle/HOL); the proofs are available in a public repository. This paper is a considerable extension and rewrite of an earlier contribution [arXiv:1507.00723]

A high-performance and high-level purely functional data-parallel array programming language that can execute on the GPU and CPU.

Why are there so many programming languages? One of the driving reasons for this is that some languages tend to produce fast code, but are a bit of a pain to use (C++), while others are a breeze to write, but run somewhat slow (Python). Depending on the ratio of CPUs to programmers, one or the other might be relatively more important.

I've been interested in various topics like Combinatory Logic, Lambda Calculus, Functional Programming for a while and have been studying them. However, unlike the "Theory of Computation" which str...

Students often ask for a recommendation on what language they should learn next.

In the formless days, long before the rise of the Church, all spells were woven of pure causality, all actions were permitted, and death was common.

There are roughly three classes of language features: Features that the language is effectively designed around, such that you can't add it after the fact....

Implementing an interactive language requires considering both compile-time and run-time performance. Traditional switch-based bytecode interpreters are easy to implement but have lower run-time performance compared to optimizing compilers. A sweet spot in performance can be found by aiming for combined compile-time and run-time performance within a certain range. Various options for implementing fast interpreters, existing compilers like LLVM and Cranelift, custom compilers, and using WebAssembly as a backend are discussed. The idea of having two backends for a language to support quick startup and aggressive optimization is also explored. There are still many unknowns and further research is needed to determine the feasibility and performance of different approaches.

The article discusses the problems with using null in programming languages like Kotlin and C#, highlighting that null can lead to confusion and errors. It argues that null is not an extensible solution for representing absence of value and suggests using sum types or optional types instead. The author believes that languages should focus on improving optional types rather than trying to make null safer.

Colin Davis discusses "little big ideas" in programming language design, focusing on the balance between innovative features and conventional choices. He highlights Mojo and Go as examples, noting how Mojo combines modern improvements with familiar concepts, while Go prioritizes simplicity and a strong ecosystem. Davis suggests that small design decisions, like memory management and parameter passing, can greatly enhance a language's usability and performance.

The author recounts experiences in designing a computer programming language and issues a warning about language complexity. Despite challenges, a subset of the language was successfully implemented. The author emphasizes the importance of simplicity and reliability in programming languages for critical applications.

Pascal is not recommended for serious programming due to limitations in its standard form. The language's strict typing and lack of features like separate compilation make it challenging for complex projects. Pascal is better suited for educational purposes rather than practical programming tasks.

The author discusses the limitations of tagged unions and pattern matching in language development, suggesting that they are overrated for implementing language ASTs and IRs. Despite the benefits of tagged unions, the complexity they add may not always justify their use, especially in cases where simpler alternatives like class hierarchies can offer similar functionality. The post also highlights the potential for enhancing pattern-matching capabilities in mainstream languages to improve code readability and maintainability.

The document discusses the challenges of telling unpleasant truths and the conflict that arises when sharing these truths in the field of Computing Science. The author argues that remaining silent about these truths compromises the intellectual integrity of the field. The document also lists a number of truths related to programming languages and the use of language in computing systems. The author questions whether the field should continue to ignore these truths and urges for a change in attitude.

A compiler translates high-level code to lower-level code, and building one is a common project in computer science education. This book provides a beginner-friendly guide to building a compiler for a C-like language, suitable for undergraduates with programming experience. The author offers free online access to the textbook and related code resources, with options to purchase a physical copy.

The text discusses how pipelines in the shell language support vectorized operations on collections and point-free style, where no data is explicitly mentioned. It also demonstrates how imperative code can be incorporated within pipelines for tasks like generating HTML tables. The unique features of pipelines include their ability to handle vectorized code, point-free composition, and integration of imperative instructions.

Undefined Behavior is often viewed negatively, but it can be a valuable tool for language designers. It allows programmers to convey insights to the compiler for optimizations. Responsible use of Undefined Behavior can enhance language design and code performance.

Functional programming in C++ can help in writing better software by making code easier to reason about and eliminating thread race conditions. Pure functions, which only rely on input parameters and produce consistent outputs, offer benefits such as thread safety and easier testing. Refactoring towards purity can improve code quality, even if full purity is not achieved, by disentangling computation from the environment it operates in.

Zig-style generics, like those in C++, may not work well for all languages due to limitations in compiler support and type inference. Armchair suggestions about adopting Zig-style generics in other languages may overlook these challenges. The flexibility and metaprogramming capabilities in Zig may not easily translate to other statically-typed languages.

An article criticized Rust's gamedev hype, but its popularity stems from meeting modern programming needs like speed and safety. Efforts are underway to enhance Rust's capabilities for various industries and improve compile times significantly. Proposed enhancements include incremental linking, parallel frontend, and macro expansion caching to make Rust more efficient for developers.

The text discusses the importance of having a clear and consistent data notation in programming languages like Clojure. It emphasizes the advantages of a notation that closely aligns with the in-memory representation of data, making it easier for developers to work with and understand data structures. Additionally, it suggests that a well-designed data model and notation are crucial for efficient data manipulation and code analysis.

The text discusses the concept of design duality in programming, focusing on the trade-offs between objects and data representations. It highlights the importance of making conscious design choices when introducing new types, whether as data, objects with extensible implementations, or abstract data types with restricted extensibility. The author emphasizes the need for programming languages to better support and encourage these design considerations.

The author suggests that using the term "undefined behavior" in newer languages like Zig and Rust may not be the best choice due to differences in semantics. In C, implementations can define some behaviors left undefined by the standard, but in Rust and Zig, any program showing undefined behavior is considered invalid. The author proposes using terms like "non-trapping programming error" or "invalid behavior" to better convey the intended semantics in these languages.

BQN's arithmetic functions mirror mathematical notation and apply element-wise to arrays. BQN supports basic arithmetic operations like addition, subtraction, multiplication, division, exponentiation, and root functions. Character arithmetic is a distinctive feature allowing manipulation of characters with symbols like + and -.

BQN has issues with incoherent monad-dyad pairs and train structures, making code readability and implementation challenging. Modifications like the Constant modifier ˙ attempt to address these challenges. However, there are still limitations in tacit code construction and array reductions that impact the language's usability.

The author spent a decade developing the programming language Inko, transitioning from gradual to static typing and using Rust for the compiler. Recommendations include avoiding gradual typing, self-hosting compilers, and focusing on functionality over performance when building a new language. Building a language for long-term use is a time-consuming process that requires prioritizing user needs over technical complexities.

The text discusses key concepts in programming, such as primitive expressions, means of combination, and means of abstraction. It highlights the role of the environment in determining the meaning of symbols in expressions. The evaluation process involves reducing expressions to procedures applied to arguments, leading to a deeper understanding of programming concepts.