Skip to content
HomeVideosBooksBlogs
AllTop postsTopics
Podcasts
HistoryListsWatch laterLiked videosFollowing

The videos, books, blogs and podcasts Hacker News keeps recommending, all in one place.

VideosBooksBlogsPodcastsAboutPrivacySettings

Data from Hacker News, HackerTube, HackerBooks, HackerBlogs and Open Library. Credits · Not affiliated with Y Combinator.

HomeVideosBooksBlogsPodcasts
Ctrl K
    M

    Martin Cracauer

    medium.com/@martincracauer · Personal blog · on HN since 2016

    Martin Cracauer, a Common Lisp (SBCL) developer, writes about garbage collection, compile-time computing, static typing in Lisp and developer focus.

    Visit blogHN submissions
    Languages & CompilersSystems & Performance
    What HN says

    Commenters cite his articles for Lisp type checking and for how userfaultfd and write barriers work in generational garbage collection, and call one article great.

    Stats for nerds
    20HN people shared it
    18linked in comments
    521story points
    Oct 2023last shared
    2017people per year2023

    Top posts on HN

    1. 1
      Software Development at 1 Hz
      1 person · 180 points · first shared 2016 · 118 comments on HN
    2. 2
      Static Type Checking in Common Lisp
      7 people · 169 points · first shared 2019 · 64 comments on HN
    3. 3
      LLVM’s garbage collection facilities and SBCL’s generational GC
      4 people · 148 points · first shared 2018 · 34 comments on HN
    4. 4
      Generational Garbage Collection, Write Barriers and Userfaultfd(2)
      7 people · 10 points · first shared 2016 · Discussion on HN
    5. 5
      A Gentle Introduction to Compile-Time Computing (2017)
      2 people · 6 points · first shared 2017 · 1 comments on HN
    6. 6
      On Attention, Focus and Autism in the Tech Workplace
      2 people · 4 points · first shared 2017 · 4 comments on HN
    7. 7
      Programming productivity: flow and “the zone” versus running and obstacles
      2 people · 4 points · first shared 2019 · 1 comments on HN
    8. 8
      A gentle introduction to compile time computing part 3 scientific units 8e41d8a727ca
      2 people · first shared 2019
    9. 9
      A gentle introduction to compile time computing part 2 cb0a46f6cfe8
      1 person · first shared 2017

    What HN people wrote when they linked it

    • vindarelJul 2020

      It's a great article. Related, for Common Lisp: https://lispcookbook.github.io/cl-cookbook/type.html

      and also:

      - https://medium.com/@MartinCracauer/static-type-checking-in-the-programmable-programming-language-lisp-79bb79eb068a (by an author of the CLASP implementation, C++ & LLVM for CL)

      - https://github.com/stylewarning/coalton - a library (pre-alpha): adding Hindley-Milner type checking to Common Lisp which allows for gradual adoption, in the same way Typed Racket or Hack allows for. It is as an embedded DSL in Lisp that resembles Standard ML or OCaml, but lets you seamlessly interoperate with non-statically-typed Lisp code (and vice versa).

    • cracauerAug 2017

      Last year I wrote about focus and attention when programming and how slow tools and slow compile-run workaround time hurt us.
      "Software Development at 1 Hz (medium.com)"
      https://news.ycombinator.com/item?id=12577283

      This is my followup with more general attention and focus issues for some parts of the workplace.
      https://medium.com/@MartinCracauer/on-attention-focus-and-autism-in-the-tech-workplace-8246526fbbc0

      If you like it I would also appreciate a retweet.
      https://twitter.com/MartinCracauer/status/902199195674824704

    • ravi-deliaOct 2023

      If anyone is curious about how signals are used for garbage collection (specifically SIGSEGV) check out this article:

      https://medium.com/@MartinCracauer/generational-garbage-collection-write-barriers-write-protection-and-userfaultfd-2-8b0e796b8f7f

      It's handy for knowing which areas of the heap have been untouched (and thus don't need to be scavenged in a generational gc).

    • ristosOct 2019

      Yeah you can do optional static typing in common lisp:
      https://medium.com/@MartinCracauer/static-type-checking-in-the-programmable-programming-language-lisp-79bb79eb068a

      The typing discipline in strong. I think it also has type inference but I'm not 100% sure

    • sanxiynOct 2019

      I first learned about userfaultfd's utility to GC from https://medium.com/@MartinCracauer/generational-garbage-collection-write-barriers-write-protection-and-userfaultfd-2-8b0e796b8f7f

    Related

    Wingologwingolog.org237 people

    FFS SSL

    Wingolog
    Personal · last shared 2026
    Paul Khuongpvk.ca106 people

    SBCL: The Ultimate Assembly Code Breadboard

    Paul Khuong
    Personal · last shared 2026
    Andrea Coralloakrl.sdf.org19 people

    The original magic Emacs garbage collection hack (2019)

    Andrea Corallo
    Personal · last shared 2024
    Peter Seibelgigamonkeys.com328 people

    Practical Common Lisp (2005)

    Peter Seibel
    Personal · last shared 2026
    John Regehrblog.regehr.org401 people

    Teaching C

    John Regehr
    Personal · last shared 2026
    Loris Crokristoff.it105 people

    Why Go and Not Rust?

    Loris Cro
    Personal · last shared 2026
    Nikodemus Siivolarandom-state.net18 people

    Pretty Pictures: Ray tracing in Lisp

    Nikodemus Siivola
    Personal · last shared 2023
    Tim Bradshawtfeb.org20 people

    The lost cause of the Lisp machines

    Tim Bradshaw
    Personal · last shared 2025