2071
Lisp Comes of Age (1980)
A report on the 1980 LISP conference at Stanford University, held the week after the AAAI Artificial Intelligence Conference. Written for Byte.
Top posts
Every blog post that took off on Hacker News, ranked by the votes of its best submission. 3,709 posts.
2072
Sorbet and 100% cov makes Ruby refactoring possible
Safely refactoring Ruby traditionally involves many incremental steps and feature flags. Sorbet and 100% branch coverage make it possible to refactor a lot of code safely.
2073
Golang Diaries: Generics
My coding time this year has been invested in Quamina , an event-filtering library implemented in Go. Just in the last couple of weeks I spotted an opportunity to bring Go’s shiny new generics to bear, and not just anywhere, but for a central data structure. I got good results, but the process was sort of painful; I…
2074
REPL vs CLI: IDE wars
An unfair heavily biased apples-to-oranges comparison… unless?
2075
Understanding Memory Management, Part 5: Fighting with Rust
This is the fifth post in my planned multipart series on memory management. You will probably want to go back and read Part I , which covers C, parts II and III , which cover C++, and part IV , which introduces Rust memory management. In part IV, we got through the basics of Rust memory management up through smart…
2076
Parsing S-expressions in C (2019)
Over the past couple weeks I've been trying to work out how I want to store my game configuration. At first I started playing with XML, which was nice because I could stream a file rather than loading the entire thing into memory but I turned away from XML because …
2077
Swift for C++ Practitioners, Part 1: Intro and Value Types
Swift for C++ Practitioners, Part 1: Intro & Value Types
2078
Thread Safety in C++ and Rust
Lately I’ve been experimenting with Rust, and I want to report some of whatI’ve learned about thread-safety. I am an enthusiastic dabbler in Rust: Ispend mo...
2079
Recto – A Truly 2D Language
Recto is a 2D programming language that uses nested rectangles as its core syntax, encoding structure and recursion directly in space instead of a linear stream of text. Recto explores new ways to write, parse, and reason about code—and even natural language—spatially.
2080
2081
The Design and Use of QuickCheck
QuickCheck is the grandfather of property-based testing libraries. Despite being imitated in over thirty languages, the original implementation remains pre-eminent due to the type system and consistent logic of the Haskell language in which it is written.
2082
Smart Pointers in (GNU) C
I am a big fan of C, but some part of me always yearn to have just enough higher level constructs.
2083
2084
SBCL Fibers – Lightweight Cooperative Threads
A draft design document describing lightweight userland cooperative threads for SBCL.
2085
Not Explicit
Oftentimes when I am conversing about the design of Rust with other users - as on RFCs or the internals forum - I witness a peculiar remark about “explicitness.” It usually goes something like this: I do not like Feature Design X because it is too implicit. Magic is okay in Other Language Y, but Rust is supposed to be…
2086
2087
You could have invented Parser Combinators
Computer Science, Machine Learning, Programming, Art, Mathematics, Philosophy, and Short Fiction
2088
Rust: Structuring and handling errors in 2020 (2020)
After working through “the book” on the Rust programming language and getting started with the first non-trivial, real-world application I found myself faced with a question I didn’t yet feel well-equipped to handle: “How should you structure error handling in a mature rust application?”
2089
REPL Driven Design
If you follow me on facebook you know that I’ve been publishing daily CoronaVirus statistics. I generate these statistics using the daily updates in the Johns Hopkins github repository .
2090
Writing your own C++ standard library from scratch
The C++ standard library (also know as the STL) is, without a doubt, an astounding piece of work. Its scope, performance and incredible back...
2091
Go Data Structures (2009)
When explaining Go to new programmers, I've found that it often helps to explain what Go values look like in memory, to build the right intuition about which operations are expensive and which are not. This post is about basic types, structs, arrays, and slices.
2092
In Go, pointers (mostly) don't go with slices in practice
You're probably reading this page because you've attempted to access some part of my blog (Wandering Thoughts) or CSpace , the wiki thing it's part of. Unfortunately you're using a browser version that my anti-crawler precautions consider suspicious, most often because it's too old (most often this applies to versions…
2093
2094
2095
A Crash Course on ML Modules (2015)
I was having lunch with a couple of Haskell programmers the other day and the subject of the ML family came up. I’ve been writing a lot of ML lately and mentioned that I thought *ML was well worth learning for the average Haskeller. When pressed why the best answer I could come up with was “Well.. clean language, Oh!…
2096
Type inference
Type inference is a major feature of several programming languages, most notably languages from the ML family like Haskell. In this post I want to provide a brief overview of type inference, along with a simple Python implementation for a toy ML-like language.
2097
Lessons learned from a successful Rust rewrite
I have written about my on-going rewrite-it-to-Rust effort at work: 1 , 2 , 3 . And now it's finished, meaning it's 100% Rust and 0% C++ - the public C API has not changed, just the implementation, one function at time until the end. Let's have a look back at what worked, what didn't, and what can be done about it.
2098
A lowering strategy for control effects in Rust
The Rust language has incrementally grown a set of patterns to support control-flow effects including error handling, iteration, and asynchronous I/O. In The registers of Rust , boats lays out four aspects of this pattern shared by Rust’s three effects. Today these effects are typically used in isolation, or at most…
2099
Asynchronous Programming in Rust
Asynchronous programming in Rust continues to make exciting strides, including the upcoming stabilization of the futures API . But, while these core APIs make it possible to write async Rust code today, it's not easy: it's a far cry from the smoothness of synchronous code.
2100
C++ Safety, in Context
Scope. To talk about C++’s current safety problems and solutions well, I need to include the context of the broad landscape of security and safety threats facing all software. I chair the ISO C++ s…