Hash tables are much less useful in a language with great struct support. I use them a lot in Python, far less in Rust.
miniblog.
https://landoflisp.com/ describes every Lisp feature in terms of how it prevents bugs. This is a great practice in many situations!
Pharo has resumable exceptions, which are useful for coding and a delight when debugging. I don't know why they aren't more common.
Interfaces are a great way of grouping methods, but many PLs struggle with method name overlaps in unrelated ifaces.
Shen macros are interesting: here's an example of defining a macro to expand a func call to a call to the same func! https://www.shenlanguage.org/learn-shen/macros.html
Ported my first codebase to mypy today! It was pretty painless, though I think I hit a bug in the type checker.
Compiling the first GCC to support i386 on a modern linux box: https://miyuki.github.io/2017/10/04/gcc-archaeology-1.html (works surprisingly well!)
I find pattern based macro systems harder to read. It's not clear what's syntax/what's a placeholder. Perhaps a prolog approach would work?
Scheme code completion based on the type of variables! I've not seen many editors implement this.
Overview of implmenting a full R5RS macro system: https://news.ycombinator.com/item?id=15396587 (the best approach is still an open question!)
How many bugs are actually code not meeting their spec? IME most bugs are "it would be nice/consistent/robust if it handled $X this way".
The best bug report title I've ever had! https://github.com/Wilfred/suggest.el/issues/34
The line between 'full-blown DSL' and 'full-featured library' is extremely fuzzy. I find it hard to use 'DSL' in a clear, meaningful way.
There's also great list of things that lisp-style macros empower you to do here: https://stackoverflow.com/a/2563308/509706
Great article introducing the NEST macro. It's wonderfully lispy: a generic syntax transformation: https://fare.livejournal.com/189741.html
Nice post on implementing a datastructure like pandas.Series using Smalltalk reflection: https://medium.com/@i.oleks/reflective-series-or-the-power-of-doesnotunderstand-34fff1f8905f
Adding a dyn keyword to Rust in order to make dynamic dispatch more explicit: https://github.com/rust-lang/rfcs/pull/2113
Spatch is a really neat tool that lets you apply diffs to code according to syntax! https://github.com/facebook/pfff/wiki/Spatch (eg remove 1 arg at all callers)
The youngest user of Rosette is a highschooler who built a verifier that a type system is sound: https://www.youtube.com/watch?v=KpDyuMIb_E0&feature=youtu.be&t=9m20s (incredible!)
Interesting discussion of different SAT solver's in Conda's package resolution, and their performance: https://github.com/Z3Prover/z3/issues/211
Showing 161-180 of 885 posts