Programming Languages
- What Zig felt like, coming from Rust
- Rust is tier-1 language at Microsoft
- Making a Python interpreter in 1024 bytes
- Learn Programming with OCaml
- Python's pre-declared constants are kinda weird
- A Friendly Introduction to Racket
- Bun 1.4
- Go 1.27
- The Mojo language (by Modular, now Qualcomm) is now open-source
- Rethinking Database Programming
- Mojo 1.0
- Rust SIMD on the GPU
- Squeak 6.1
- Tail-call optimization in C is relatively recent (2025)
- Because It's Not Fun Enough: why languages fail
- Show HN: Wyzer Programming Language
- Rust project goals: Immobile types and guaranteed destructors
- Go 1.27 Interactive Tour
- The Art of 64-bit Assembly
- Golang proposal: container/: generic collection types
- JEP 401: Value Objects (Preview) merged to OpenJDK master
- Steel Bank Common Lisp version 2.6.7
- Zig's Incremental Compilation Internals
- Scriptc by Vercel: TypeScript-to-Native compiler, no JavaScript engine in binary
- Memory safety absolutists
- Buz – A fork of Bun using modern Zig, with sub-1s incremental builds
- Fil-C: Garbage In, Memory Safety Out [video]
- Cruller: Bun's Zig Runtime, Continued on Zig 0.16
- Claude Code uses Bun written in Rust now
- Elixir-lang.org has a new design
- A Road to Lisp: Which Lisp
- How Our Rust-to-Zig Rewrite Is Going
- Understanding the Odin programming language
- Show HN: Ant – A JavaScript runtime and ecosystem
- After 7 years in production, Scarf has reluctantly moved away from Haskell
- A road to Lisp: Why Lisp
- My thoughts on the Bun Rust rewrite
- Show HN: Microsoft releases Flint, a visualization language for AI agents
- TypeScript 7
- l: A new runtime for k and q
- Python 3.14 compiled to metal – no interpreter
- Road to Elm 1.0
- Zig's new bitCast semantics and LLVM back end improvements
- LuaJIT 3.0 proposed syntax extensions
- Linux eliminates the strncpy API after six years of work, 360 patches
- Bun has an open PR adding shared-memory threads to JavaScriptCore
- Project Valhalla, Explained: How a Decade of Work Arrives in JDK 28
- How memory safety CVEs differ between Rust and C/C++
- The Birth and Death of JavaScript (2014)
- Orthodox C++ (2016)
- Swift at Apple: Migrating the TrueType hinting interpreter
- Zig by Example
- Are you expected to run five Python type-checkers now?
- C++: The Documentary
- Elixir v1.20: Now a gradually typed language
- My thoughts after using Clojure for about a month
- Why Janet? (2023)
- Zig ELF Linker Improvements Devlog
- Zig: Build System Reworked
- Perry Compiles TypeScript directly to executables using SWC and LLVM
- Go: Support for Generic Methods
- What color is your function? (2015)
- Performance of Rust Language [pdf]
- Migrating from Go to Rust
- .NET (OK, C#) finally gets union types
- Deno 2.8
- Python 3.15: features that didn't make the headlines
- Saying goodbye to asm.js
- No way to parse integers in C (2022)
- Everything in C is undefined behavior
- Bun Rust rewrite: "codebase fails basic miri checks, allows for UB in safe rust"
- Cost of enum-to-string: C++26 reflection vs. the old ways
- If AI writes your code, why use Python?
- CUDA-oxide: Nvidia's official Rust to CUDA compiler
- Just Use Go
- Mojo 1.0 Beta
- Async Rust never left the MVP state
- I am worried about Bun
- A couple million lines of Haskell: Production engineering at Mercury
- Unsigned sizes: A five year mistake
- Functional programmers need to take a look at Zig
- Why I still reach for Lisp and Scheme instead of Haskell
- “Why not just use Lean?”
- The seven programming ur-languages (2022)
- A simplified model of Fil-C
- Ada, its design, and the language that built the languages
- Official Clojure Documentary page with Video, Shownotes, and Links
- Want to write a compiler? Just read these two papers (2008)
- A perfectable programming language
- JVM Options Explorer
- Lisette a little language inspired by Rust that compiles to Go
- Why are we still using Markdown?
- Bringing Clojure programming to Enterprise (2021)
- C++26 is done: ISO C++ standards meeting Trip Report
- Swift 6.3
- An incoherent Rust
- A case against currying
- Java 26 is here
- Python 3.15's JIT is now back on track
- Show HN: Han – A Korean programming language written in Rust
- XML is a cheap DSL
- Returning to Rails in 2026
- Temporal: The 9-year journey to fix time in JavaScript
- Making WebAssembly a first-class language on the Web
- Type resolution redesign, with language changes to taste
- Notes on writing Rust-based Wasm
- Warn about PyPy being unmaintained
- UUID package coming to Go standard library
- D Programming Language
- Fabrice Bellard Releases MicroQuickJS
- A million ways to die from a data race in Go
- Programming with Less Than Nothing
- MAML – A new configuration language
- Love C, hate C: Web framework memory problems
- Configuration files are user interfaces
- WASM 3.0 Completed
- I'm too dumb for Zig's new IO interface
- .NET 10 Preview 6 brings JIT improvements, one-shot tool execution
- I'm switching to Python and actually liking it
- Run a C# file directly using dotnet run app.cs
- Why are 2025/05/28 and 2025-05-28 different days in JavaScript?
- Reflecting on a Year of Gamedev in Zig
- Exploring Polymorphism in C: Lessons from Linux and FFmpeg's Code Design (2019)
- Rust’s worst feature
- The Simplicity of Prolog
- C is not suited to SIMD (2019)
- C stdlib isn't threadsafe and even safe Rust didn't save us
- Tilde, My LLVM Alternative
- Context should go away for Go 2 (2017)
- TypeScript enums: use cases and alternatives
- Haskell: A Great Procedural Language
- WASM GC isn't ready for realtime graphics
- Solving the first 100 Project Euler problems using 100 languages
- Can you complete the Oregon Trail if you wait at a river for 14272 years?
- Great things about Rust that aren't just performance
- Why I Chose Common Lisp
- Obvious things C should do
- Getting silly with C, part (void*)2
- Some programming language ideas
- C++26: A Placeholder with No Name
- Today I learned that bash has hashmaps (2024)
- Is XYplorer really written in VB6?
- Why we built Vade Studio in Clojure
- Zig's comptime is bonkers good
- C: Simple Defer, Ready to Use
- What Is miniKanren?
- Types are a basic tool of software design (2018)
- Ada's dependent types, and its types as a whole
- Lua is so underrated
- A Minecraft server written in COBOL
- Ruby 3.4.0
- C++ is an absolute blast
- Four limitations of Rust's borrow checker
- Rosetta 2 creator leaves Apple to work on Lean full-time
- Compiling C to Safe Rust, Formalized
- How types make hard problems easy
- Error Stacking in Rust
- Half My Life with Perl
- Java in the Small
- How we centralized and structured error handling in Golang
- Borrow Checking, RC, GC, and Eleven Other Memory Safety Approaches
- Modelica
- Should programming languages be safe or powerful?
- The Luon programming language
- Elixir/Erlang Hot Swapping Code (2016)
- What every systems programmer should know about concurrency (2020) [pdf]
- Making memcpy(NULL, NULL, 0) well-defined
- Tree Calculus
- JSON5 – JSON for Humans
- JSON parsers that can accept comments
- The Starlark Programming Language
- Biggest shell programs
- Speeding up Ruby by rewriting C in Ruby
- Show HN: My C compiler compiled itself
- DuckDuckGo donates $25k to the Perl and Raku Foundation
- Good union types in Go would probably need types without a zero value
- 8 months of OCaml after 8 years of Haskell in production (2023)
- RAII and the Rust/Linux Drama
- 1/0 = 0 (2018)
- Move semantics in Rust, C++, and Hylo
- How much memory do you need in 2024 to run 1M concurrent tasks?
- Goodbye, Rust. I wish you success but I'm back to C++ (sorry, it is a rant)
- Rust in QEMU Roadmap
- Python type hints may not be not for me in practice
- 1B nested loop iterations
- The Borgo Programming Language
- Lies we tell ourselves to keep using Golang (2022)
- The two factions of C++
- PHP 8.4
- Hyrum’s Law in Golang
- OCaml Syntax Sucks (2016)
- Traits are a local maximum
- Show HN: Nova JavaScript Engine
- Stop making me memorize the borrow checker
- Retrofitting spatial safety to lines of C++
- Thomas E. Kurtz has died
- Async await: the worst thing to happen to programming?
- Unusual Raku Features
- Steve Jobs, NeXTSTEP, and early object-oriented programming (2016)
- What's New in F# 9
- Show HN: Jaws – a JavaScript to WASM ahead-of-time compiler
- Rust for tokenising and parsing
- Upcoming Hardening in PHP
- State of Python 3.13 performance: Free-threading
- Zig's (.{}){} Syntax
- Writing secure Go code
- New better alterative to XML, JSON and YAML
- Weird Lexical Syntax
- Programming languages that blew my mind (2023)
- Async Rust is not safe with io_uring
- A comparison of Rust’s borrow checker to the one in C#
- Should JavaScript be split into two languages?
- Unsafe Rust is harder than C
- Using Rust in non-Rust servers to improve performance
- Why Safety Profiles Failed
- Pretty.c
- Optimizers need a rethink
- Marketing the Odin programming language is weird
- The empire of C++ strikes back with Safe C++ blueprint
- Blocking code is a leaky abstraction
- Civet: A Superset of TypeScript
- Show HN: Go Plan9 Memo
- Net 9.0 LINQ Performance Improvements
- Smart pointers for the kernel
- C++ proposal: There are exactly 8 bits in a byte
- setBigTimeout
- Hofstadter on Lisp (1983)
- Advancing Memory Safety
- The C23 edition of Modern C
- Embedded Rust in Production?
- TypedDicts are better than you think
- My negative views on Rust (2023)
- PEP 760: No more bare excepts
- Proposal: JavaScript Structs
- Show HN: Kotlin Money
- Fun with Go Iterators
- Python 3.13.0 Is Released
- Gleam Is Pragmatic
- Arthur Whitney's one liner sudoku solver (2011)
- Whence '\n'?
- Why does Lisp use cons cells? (1998)
- COBOL has been “dead” for so long, my grandpa wrote about it
- Pledging $300k to the Zig Software Foundation
- The Liberating Experience of Common Lisp
- Some Go web dev notes
- Serialization Is the Secret
- Everything you need to know about Python 3.13 – JIT and GIL went up the hill
- Tcl 9.0
- Rewriting Rust
- The lost language extensions of MetaWare's High C compiler (2023)
- Show HN: I Wrote a Book on Java
- Brainfuck Enterprise Solutions
- Hy 1.0 – Lisp dialect for Python
- DirectX Adopting SPIR-V as the Interchange Format of the Future
- Swift 6
- GraalPy – A high-performance embeddable Python 3 runtime for Java
- Ergo: Erlang-inspired event driven actor framework in Go
- Why Haskell?
- Comfy, the 2D rust game engine, is now archived
- Don't defer Close() on writable files (2017)
- Google says replacing C/C++ in firmware with Rust is easy
- Asynchronous IO: the next billion-dollar mistake?
- What's new in C++26 (part 1)
- Swift is a more convenient Rust
- Clojure 1.12.0 is now available
- Deploying Rust in existing firmware codebases
- Lesser known parts of Python standard library
- Honey, I shrunk {fmt}: bringing binary size to 14k and ditching the C++ runtime
- Rust's Ugly Syntax (2023)
- The Future of TLA+ [pdf]
- The 4-chan Go programmer
- Kotlin for data analysis
- Microsoft donates the Mono Project to the Wine team
- Writing a Rust compiler in C
- Why Does Elisp Suck
- JavaScript dates are about to be fixed
- I sped up serde_json strings by 20%
- Mimalloc Cigarette: Losing one week of my life catching a memory leak (Rust)
- Parsing protobuf at 2+GB/s: how I learned to love tail calls in C (2021)
- Getting back into C programming for CP/M
- An unordered list of things I miss in Go
- What you learn by making a new programming language
- 0xCAFEBABE & 0xFEEDFACE (2003)
- Writing a C Compiler: Build a Real Programming Language from Scratch
- Go is my hammer, and everything is a nail
- GIL Become Optional in Python 3.13
- Ladybird browser to start using Swift language this fall
- Go structs are copied on assignment (and other things about Go I'd missed)
- Recent Performance Improvements in Function Calls in CPython
- Official proposal for Type Unions in C#
- Maximal min() and max()
- C++'s `noexcept` can sometimes help or hurt performance
- Why does everyone hate Haskell, jazz, and pure math?
- Enum class improvements for C++17, C++20 and C++23
- Clang vs. Clang
- Null-Restricted and Nullable Types
- Russ Cox is stepping down as the Go tech lead
- Hundred Rabbits is a small collective exploring the failability of modern tech
- Porffor: A from-scratch experimental ahead-of-time JS engine
- Translating All C to Rust (TRACTOR)
- C Macro Reflection in Zig
- Functional languages should be so much better at mutation than they are
- Don't blindly prefer `emplace_back` to `push_back` (2021)
- Defense of Lisp macros: The automotive field as a case in point
- Node.js adds experimental support for TypeScript
- Pnut: A C to POSIX shell compiler you can trust
- Types as Interfaces
- Jiff: Datetime library for Rust
- Pin
- Aro – Zig's new C compiler
- Ruby methods are colorless
- What's the point of std:monostate? You can't do anything with it
- Ask HN: What's Prolog like in 2024?
- A brief interview with Awk creator Dr. Brian Kernighan (2022)
- I Hope Rust Does Not Oxidize Everything
- Run CUDA, unmodified, on AMD GPUs
- I'm not a fan of strlcpy(3)
- Java Virtual Threads: A Case Study
- Crafting Interpreters
- Free-threaded CPython is ready to experiment with
- We need visual programming. No, not like that
- I have no constructor, and I must initialize
- Python with Braces
- What Happened to Perl 7? (2022)
- Reflection for C++26
- Weekend projects: getting silly with C
- Meta LLM Compiler: neural optimizer and disassembler
- Misconceptions about loops in C
- Google Sheets ported its calculation worker from JavaScript to WasmGC
- How GCC and Clang handle statically known undefined behaviour
- GCC's new fortification level: The gains and costs (2022)
- Three ways to think about Go channels
- Ruby: A great language for shell scripts
- Own Constant Folder in C/C++
- NPM and NodeJS should do more to make ES Modules easy to use
- Java string interpolation feature has been cancelled
- The upcoming iterator design for Go 1.23
- 'Equals' has more than one meaning in math
- I learned Haskell in just 15 years
- Leveraging Zig's Allocators
- The Swift compiler is slow due to how types are inferred
- Elixir 1.17 released: set-theoretic types in patterns, durations, OTP 27
- Swift Static Linux SDK
- Forsp: A Forth+Lisp Hybrid Lambda Calculus Language
- No one should use the AT&T syntax (2021)
- Ask HN: 30y After 'On Lisp', PAIP etc., Is Lisp Still "Beating the Averages"?
- Ruby's Timeout is dangerous and Thread.raise is terrifying (2015)
- Circle C++ with memory safety
- Monads are like burritos (2009)
- Arthur Whitney releases an open-source subset of K with MIT license
- Go: Sentinel errors and errors.Is() slow your code down by 3000%
- What I think about Lua after shipping a project with 60k lines of code
- PyPy has been working for me for several years now
- Proposal to change default annotation processing policy in JDK 23
- The CompCert C Compiler
- The Evolution of Lisp (1993) [pdf]
- Hurl, the Exceptional Language
- Try Clojure
- Why not just do simple C++ RAII in C?
- "No way to prevent this" say users of only language where this regularly happens
- A Road to Common Lisp (2018)
- Amber: Programming language compiled to Bash
- CamelCase vs underscores: Scientific showdown (2011)
- The problem with new URL(), and how URL.parse() fixes that
- Swift Tooling: Windows Edition
- Bend: a high-level language that runs on GPUs (via HVM2)
- How to read C type declarations (2003)
- Exercises to Learn Rust
- You probably don't need to validate UTF-8 strings
- F* – A Proof-Oriented Programming Language
- Some notes on Rust, mutable aliasing and formal verification
- Translation of Rust's core and alloc crates to Coq for formal verification
- Branded types for TypeScript
- Homoiconic Python
- Garbage Collectors Are Scary
- So We've Got a Memory Leak
- What I mean when I say that machine learning in Elixir is production-ready
- Algebraic Data Types for C99
- Ointers: A library for representing pointers where bits have been stolen (2021)
- The search for easier safe systems programming
- The C++ Iceberg
- How to Use the Foreign Function API in Java 22 to Call C Libraries
- A History of C Compilers – Part 1: Performance, Portability and Freedom
- Rusty.hpp: A Borrow Checker and Memory Ownership System for C++20
- Swift's native Clocks are inefficient
- Verified Rust for low-level systems code
- PHP Doesn't Suck Anymore
- Figma’s Journey to TypeScript
- Cognition: A new antisyntax language redefining metaprogramming
- BASIC turns 60
- Borgo is a statically typed language that compiles to Go
- Asynchronous Programming in C#
- TypeSpec: A new language for API-centric development
- 93% of paint splatters are valid Perl programs (2019)
- Speeding up C++ build times
- What if null was an Object in Java?
- Leaving Rust gamedev after 3 years
- PEP 686 – Make UTF-8 mode default
- Pharo 12
- TypeScript: Branded Types
- Show HN: Getada: rustup-like installer for Ada's toolchain/package manager
- The Performance Impact of C++'s `final` Keyword
- An Exploration of SBCL Internals (2020)
- Ruby vs. Python comes down to the for loop (2021)
- Racket Language
- JEP draft: Exception handling in switch
- 3rd Edition of Programming: Principles and Practice Using C++ by Stroustrup
- C-Macs – a pure C macOS application
- The Rust calling convention we deserve
- Java 23: The New Features Are Officially Announced
- Tree-shaking, the horticulturally misguided algorithm (2023)
- Is .NET just miles ahead or am I delusional?
- PHP in 2024
- The Vala Programming Language
- Go's Error Handling Is Perfect
- Xr0: C but Safe
- Improvements to static analysis in GCC 14
- What even is a JSON number?
- Bun 1.1
- Overview: What are Cpp2 and cppfront? How do I get and build cppfront?
- A proposal to add signals to JavaScript
- Type Inference Was a Mistake
- Garbage collection for systems programmers (2023)
- Go Enums Still Suck
- Rust data structures with circular references (2021)
- Why choose async/await over threads?
- Gerbil Scheme – A Lisp for the 21st Century
- C++ left arrow operator (2016)
- The C++ Killers (Not You, Rust)
- Regex character "$" doesn't mean "end-of-string"
- I Improved My Rust Compile Times
- Java 22 Released
- C++ creator rebuts White House warning
- Cranelift code generation comes to Rust
- We were wizards – a foreword to Learning Perl (1993)
- 20 Years in the Making, GnuCOBOL Is Ready for Industry
- Zig, Rust, and Other Languages
- What's worked in Computer Science: 1999 vs. 2015 (2015)
- The Montreal problem: Why programming languages need a style czar
- More powerful Go execution traces
- I'm excited about Darklang
- C++ Safety, in Context
- gh-116167: Allow disabling the GIL
- Show HN: Flyde – an open-source visual programming language
- Dada, an experimental new programming language
- Embedded Swift on the Raspberry Pi Pico
- Array languages vs. the curse of the spreadsheet
- The hunt for the missing data type
- Rust for Embedded Systems: Current state, challenges and open problems
- CS 6120: Advanced Compilers: The Self-Guided Online Course
- R: Introduction to Data Science (2019)
- Go Enums Suck
- V Language Review (2023)
- Reading "A Programmer's Guide to Common Lisp"
- Go run
- Ask HN: How many of you Apple developers still use Objective C?
- Cve-rs: Fast memory vulnerabilities, written in safe Rust
- Cake – C23 and Beyond (2023)
- Porting to GCC 14: C language issues
- My PHP Problems
- Python datetime pitfalls, and what libraries are (not) doing about it
- Why is Common Lisp not the most popular programming language?
- We need to talk about parentheses (2020)
- Aho – a Git implementation in Awk
- A look at the Mojo language for bioinformatics
- Context Control in Go
- Unison Cloud
- RustPython
- How Programming Languages Got Their Names
- Go 1.22
- Two's complement integers with only sign bit set should be a trap representation
- Deno in 2023
- A reasonable configuration language
- .NET on Linux: What a Contrast
- Microsoft seeks Rust developers to rewrite core C# code
- Pkl, a Programming Language for Configuration
- A Tour of the Lisps
- Python types have an expectations problem
- Dart/Flutter now has macros/metaprogramming
- Ruby's exceptional creatures
- Sane C++ Libraries
- WASI 0.2.0 and Why It Matters
- Shouldn't FROM come before SELECT in SQL? (2011)
- Embracing Common Lisp in the modern world
- You (probably) don't need to learn C
- Making Rust binaries smaller by default
- From slow to SIMD: A Go optimization story
- Why Zig When There Is Already C++, D, and Rust?
- C23: A Slightly Better C
- Boehm-Demers-Weiser conservative C/C++ Garbage Collector
- So you think you know C? (2016)
- The bane of my existence: Supporting both async and sync code in Rust
- Identifying Rust's collect:<Vec<_>>() memory leak footgun
- JEP Draft: Deprecate memory-access methods in sun.misc.unsafe for removal
- Std: Clamp generates less efficient assembly than std:min(max,std:max(min,v))
- We switched to Java 21 virtual threads and got a deadlock in TPC-C for Postgres
- Niklaus Wirth, or the Importance of Being Simple
- Polymorphic Types in C [pdf]
- OpenD, a D language fork that is open to your contributions
- Thinking in an array language (2022)
- Apple hiring compiler developers for improving Swift / C++ interoperability
- Smalltalk simplicity and consistency vs. other languages (2022) [video]
- Is Fortran “A Dead Language”? (2022)
- JEP draft: String Templates (Final)
- Mathematica 14
- Missing the Point of WebAssembly
- Python 3.13 Gets a JIT
- Dennis Ritchie on the priorities of && || vs. == etc. (1982)
- Don't pass structs bigger than 16 bytes on AMD64
- Go: What we got right, what we got wrong
- Niklaus Wirth has died
- Benchmarking 20 programming languages on N-queens and matrix multiplication
- The Odin Programming Language
- Bun, JavaScript, and TCO
- What's up Python? Epic CPython commit, Django 5 and 2FA for PyPI
- BASIC was not just a programming language
- Learn Modern C++
- Ruby 3.3
- The C++20 Naughty and Nice List for Game Devs
- Was BASIC that horrible or better?
- Memory safety is necessary, not sufficient
- C++ Should Be C++
- I Love Ruby
- Progress toward a GCC-based Rust compiler
- Wasm3 entering a minimal maintenance phase
- Misra C++:2023
- Swift was always going to be part of the OS (2022)
- Show HN: A pure C89 implementation of Go channels, with blocking selects
- The Case for Memory Safe Roadmaps
- The best WebAssembly runtime may be no runtime
- Building a bare-metal bootable game for Raspberry Pi in C#
- How many lines of C it takes to execute a + b in Python
- Python Is Easy. Go Is Simple. Simple != Easy
- Bjarne Stroustrup Quotes
- The Flix Programming Language
- "Useless Ruby sugar": Argument forwarding
- PHP 8.3
- Fortran 2023
- I think C++ is still a desirable coding platform compared to Rust
- Writing and linting Python at scale
- Roc – A fast, friendly, functional language
- datetime.utcnow() is now deprecated
- The Changing "Guarantees" Given by Python's Global Interpreter Lock
- NilAway: Practical nil panic detection for Go
- Show HN: Numbat – A programming language with physical dimensions as types
- Why do people still use VBA?
- .NET 8
- A decade of developing a programming language
- I accidentally a scheme
- OCaml: a Rust developer's first impressions
- Fourteen Years of Go
- .NET 8 Standalone 50% Smaller On Linux
- Rust – Faster compilation with the parallel front-end in nightly
- Switching to Elixir
- Officially Qualified – Ferrocene
- Gleam: a type safe language on the Erlang VM
- Writing a Compiler is Surprisingly Easy (part 1)
- A four year plan for async Rust