Engineering: References
Mon, Feb 28, 2022 ❝References on simplicity in software engineering❞Contents
These are references that I have used over the years to build up a mental model. This is far far far from complete. These are just the ones that came to mind. In particular, there must be 10+ references missing regarding OOP programming, the do’s and don’ts, the good and bad.
Topics
- Inter-process communication mechanisms, (enterprise) patterns, software, considerations
- ZeroMQ,
- In-memory message queues,
- Caches
- Concurrency/parallelism
- coroutines
- user-space scheduling, threading
- Python generators (many sources)
- concurrency vs parallelism, design vs execution
- blocking vs non-blocking channels in Go
- async/await, promises/futures
- Why OOP does/doesn’t suck
- Error handling:
- exceptions, monadic, assertions, abort/panic
- checked vs unchecked exceptions
- value of crashing/aborting/panicking
- sentinel return values for errors
- insight into errors, information
- the nature/place of error handling in control flow
- Architectural and design decisions of open source projects:
- prioritized features
- distinguishing features/aspects
- Function programming:
- monadic patterns
- Maybe / Option / Optional
- Trade-offs, mitigating trade-off-forced decisions:
- persistence or performance
- limited use of language features, memory sources, etc. to take or remain in control over program structure and complexity
- precursor to cloud: movement towards lightweight (NoSQL) persistence, in-memory databases/stores
References
This is tricky. This is based on many years of incremental, gradual progress looking into and trying to understand programming, program structure, difficulty, programming paradigms, etc. Note that there is no point in trying to recall any of this verbatim. The idea is to learn from different circumstances, different design choices, alternatives, exploration, thought processes and whatever else you can discover. Build up a mental model. Good speakers in conference talks are generally clear in the underlying problem they are trying to solve, and then take you with them on the journey of how they solved it.
This lists all the references I remembered and was able to find again, or rediscovered. This is by no means complete. Not even close.
Object-Oriented Programming:
- Alan Kay at OOPSLA 1997 - The computer revolution hasnt happened yet (YouTube)
- Defending OOP (Harmful Software)
- Dr. Alan Kay on the meaning of “Object-Oriented Programming”
- Midori posts (Joe Duffy)
- Null References The Billion Dollar Mistake (YouTube), mirror
- OSCON 2010: Rob Pike, “Public Static Void” (YouTube)
- “Systems that run forever self-heal and scale” by Joe Armstrong (2013) (YouTube)
- What’s wrong with Object-Oriented Programming?
- Why OO Sucks (Joe Armstrong), mirror at cat-v
Concurrency:
- 15 Years of Concurrency (Joe Duffy)
- A look at Nanomsg and scalability protocols (Why ZeroMQ shouldn’t be your first choice) (Brave New Geek)
- Advanced Topics in Programming Languages: Concurrency/message passing Newsqueak (YouTube)
- Asynchronous Everything (Joe Duffy)
- Concurrency is not Parallelism by Rob Pike (YouTube), transcript
- Coroutines in C (Simon Tatham)
- Coroutines in C with arbitrary arguments (250bpm)
- Distributed Messaging with ZeroMQ (Brave New Geek)
- Dmitry Vyukov — Go scheduler: Implementing language with lightweight concurrency (YouTube)
- Fast, scalable networking in Go with Mangos (Brave New Geek)
- Go Concurrency Patterns: Pipelines and cancellation (Sameer Ajmani)
- Google I/O 2012 - Go Concurrency Patterns (YouTube)
- Google I/O 2013 - Advanced Go Concurrency Patterns (YouTube)
- libdill: Structured Concurrency for C
- Origins of Go concurrency style by Rob Pike (YouTube)
- Performance of green threads and why it matters
- User-level threads……. with threads. - Paul Turner - Google
Miscellaneous:
- Computer Science - A Guide for the Perplexed • Joe Armstrong • GOTO 2018 (YouTube)
- David Beazley, on the Python GIL:
- dotGo 2015 - Rob Pike - Simplicity is complicated (YouTube)
- Enforced Error Handling (250bpm)
- Errors are values (The Go Blog, Rob Pike)
- Finish your stuff (250bpm)
- Go & Versioning series (Russ Cox)
- Joe Armstrong - Keynote: The Forgotten Ideas in Computer Science - Code BEAM SF 2018 (YouTube)
- PyPy blog - contains many blog posts describing the process of developing PyPy and optimization.
- Regular Expression Matching Can Be Simple And Fast (Russ Cox)
- Regular Expression Matching: the Virtual Machine Approach (Russ Cox)
- Regular Expression Matching in the Wild (Russ Cox)
- Regular Expression Matching with a Trigram Index (Russ Cox)
- Reusability Trap (250bpm)
- The Do’s and Don’ts of Error Handling • Joe Armstrong • GOTO 2018 (YouTube)
- The error model (Joe Duffy)
- The Generic Dilemma (Russ Cox)
- “The Mess We’re In” by Joe Armstrong (YouTube)
- UTF-8: Bits, Bytes, and Benefits (Russ Cox)
- Why should I have written ZeroMQ in C, not C++ (part I) (250bpm)
- Why should I have written ZeroMQ in C, not C++ (part II) (250bpm)