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
    J

    Just Software Solutions

    justsoftwaresolutions.co.uk · Company blog · on HN since 2009

    Anthony Williams, a C++ consultant, writes about C++ multithreading, atomics, synchronization, templates and standard library details.

    Visit blogHN submissions
    ProgrammingLanguages & CompilersSystems & Performance
    What HN says

    HN commenters link it as a reference for C++ threading and for the proposal to standardize variant in C++17.

    Stats for nerds
    18HN people shared it
    22linked in comments
    276story points
    Sep 2017last shared
    2013people per year2017

    Top posts on HN

    1. 1
      Locks, Mutexes, and Semaphores: Types of Synchronization Objects (2014)
      1 person · 96 points · first shared 2020 · 10 comments on HN
    2. 2
      Std::shared_ptr's secret constructor
      1 person · 87 points · first shared 2015 · 10 comments on HN
    3. 3
      Reclaiming C++ Data Structures with Cycles
      1 person · 55 points · first shared 2016 · 92 comments on HN
    4. 4
      Multithreading in C++0x part 1: Starting Threads
      3 people · 7 points · first shared 2009 · 1 comments on HN
    5. 5
      Invariants and Preconditions
      2 people · 4 points · first shared 2020 · Discussion on HN
    6. 6
      Core C++ – lvalues and rvalues
      1 person · 4 points · first shared 2016 · Discussion on HN
    7. 7
      Getting tuple elements with a runtime index in C++
      1 person · 3 points · first shared 2020 · Discussion on HN
    8. 8
      Core C++ – Destructors and RAII
      1 person · 2 points · first shared 2015 · Discussion on HN
    9. 9
      Using atomics for thread synchronization in C++
      1 person · 2 points · first shared 2021 · Discussion on HN
    10. 10
      New Concurrency Features in C++14
      1 person · 2 points · first shared 2015 · Discussion on HN

    What HN people wrote when they linked it

    • ramchipSep 2017

      If you're using a GUI toolkit like Qt or WxWidgets, then you have to use whatever event system the toolkit provides, since it controls the main thread's event loop. For WxWidgets for instance the doc is here: http://docs.wxwidgets.org/trunk/overview_thread.html

      I worked on a C++ trading app in the past and our approach was "services" (actors) talking via message passing. Basically a bunch of long-lived threads, each with a queue (nowadays that could be something like boost::lockfree::queue [1]), running an event loop. Message passing worked by getting a pointer to the target service's queue via a service registry (singleton initialized at startup, you could also keep a copy per service though), then pushing a message to it. If you needed to do something with the result, then that would come back via another message sent via the same system.

      It does mean if there's back-and-forth between services the code would be harder to follow as you'd have to read through a few event handlers to get the whole flow, but with well-designed service boundaries it worked quite well. I don't think futures would have been useful in our context as blocking any service for an extended time would have been very bad.

      [1] If you don't want boost, you can wrap std::queue yourself, this is a simple example where you can replace the boost mutex etc. with std ones: https://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

    • ysapirMay 2013

      Also, in this paradigm, only one thread calls refresh() at any give time (either the MonitorThread or before the thread is created, the initializer thread). This is contrary to some definitions of lock free, such as [1], "if any thread performing an operation on the data structure is suspended at any point during that operation then the other threads accessing the data structure must still be able to complete their tasks". If we kill MonitorThread, other threads accessing RSState won't be able to complete their operation.

      [1] http://www.justsoftwaresolutions.co.uk/threading/non_blocking_lock_free_and_wait_free.html

    • RotsiserMhoSep 2015

      There's a proposal to include it in C++17. See also: https://www.justsoftwaresolutions.co.uk/cplusplus/standardizing-variant.html

    Related

    Scott Meyersscottmeyers.blogspot.com43 people

    } // good to go

    Scott Meyers
    Personal · last shared 2025
    The Erlangelisttheerlangelist.com36 people

    Why Elixir (2014)

    The Erlangelist
    Personal · last shared 2026
    Herb Suttergotw.ca84 people

    Ritchie, Stroustrup, and Gosling interview

    Herb Sutter
    Personal · last shared 2026
    Molecular Mattersblog.molecular-matters.com15 people

    Adventures in data-oriented design – Part 3b: Internal References

    Molecular Matters
    Personal · last shared 2025
    1024cores1024cores.net36 people

    Lockfree Algorithms (2010)

    1024cores
    Personal · last shared 2025
    Erik Rigtorprigtorp.se21 people

    Low latency tuning guide

    Erik Rigtorp
    Personal · last shared 2026
    Aras Pranckevičiusaras-p.info79 people

    I accidentally Blender VSE

    Aras Pranckevičius
    Personal · last shared 2026
    Probably Danceprobablydance.com74 people

    Fibonacci Hashing: The Optimization That the World Forgot

    Probably Dance
    Personal · last shared 2026