Programming

Insightful articles and examples to help you become a better software developer

• tef - how (not) to write a pipeline
• Jamie Brandon - Coding
• Jamie Brandon - The shape of data
• Your "Simulation" Might Not Need State
• Gary Bernhardt - Boundaries
• How to Test
• Learnings from 5 years of tech startup code audits
• The Hitchhiker's Guide to the Unexpected
• What "Worse is Better vs The Right Thing" is really about
• The most important thing to understand about queues
• Files are fraught with peril
• Rethinking Programming: Automated Observability
• Bug analytics
• A brief history of the UUID
• Centrifuge: a reliable system for delivering billions of events per day
• Lessons from 6 software rewrite storieshqRLJfPzXab7vUUxRFrbQscF
• Specific vs. general: Which is better?
• Why do config changes keep coming up in major incidents?
• I test in prod
• What is your take on checking return values?
• Repeat yourself, do more than one thing, and rewrite everything
• Scaling in the presence of errors—don’t ignore them
• Write code that is easy to delete, not easy to extend.
• A primer on functional architecture
• The Value of Values
• In space, no one can hear you kernel panic
• Observations on Observability
• The Passport: A Tool for Better Metrics
• Cybernetics Versus Informatics: Understanding the Type Wars
• Taming Complexity with Reversibility
• SRE as a Lifestyle Choice
• A freemium model for scheduling
• John Hughes - Testing the Hard Stuff and Staying Sane
• Say NO to Venn Diagrams When Explaining JOINs
• How Dark deploys code in 50ms
• STAMPing on event-stream
• Waste – An ever evolving struggle against waste
• Boundaries
• Lessons Learned while Working on Large-Scale Server Software
• Property-Based Testing Basics
• Metamorphic Testing
• Microservices versus Lean
• What programming is like
• Our Software Dependency Problem - Russ Cox
• The Perils of Semantic Coupling
• Faceted Identities
• Spectrum of Change
• Give Them The Button!
• Some Useful Techniques From Bygone Eras
• Operable Software
• Stability Patterns and Antipatterns, Michael Nygard
• Michael Nygard - Grinding the Monolith
• Components and Glue
• The Fear Cycle
• Stuart Halloway - Narcissistic Design
• Architecture Without an End State • Michael Nygard
• Uncoupling • Michael Nygard
• Turning the database inside-out with Apache Samza
• Designing an email-only Slack interface
• Education of a Programmer
• The Yoda of Silicon Valley
• Keep Ruby Weird 2018 - Closing Keynote by Avdi Grimm
• Maybe Not - Rich Hickey
• Stack Overflow: How We Do Monitoring - 2018 Edition
• Distributed Systems and the End of the API
• Design for security
• Post-mortems to the rescue
• Lone Star RubyConf 2009 - Something Interesting by Dave Thomas
• Indirection Is Not Abstraction
• Against software development
• Lean Testing or Why Unit Tests are Worse than You Think
• Open Source Language Design in Rust and Node.js by Ashley Williams
• Sam Aaron - Communicative Programming
• Systems at Scale 2018 – Rebuilding the Inbox: The Corporate and Cultural Adventures of Modernizing Yahoo Mail
• Documenting Architecture Decisions
• The Power of Living Systems
• Mike Bostock - Design is a Search Problem
• Only One Deliverable Matters
• Writing system software: code comments.
• Apathy of the Commons
• Hammock Driven Development - Rich Hickey
• Building a team: Agile!
• Good, Cheap, and Fast - PC3
• We shouldn't let people get used to the idea that software fails
• Unconditional Code - Michael Feathers
• Cutting through to what matters
• On Engineers and Influence
• The power of embedded developers
• Exploding Software-Engineering Myths
• Observability: the hard parts
• How I use Wireshark
• UTC is Enough for Everyone, Right?
• André Staltz - Open source without maintainers
• Ted Nelson -- Computers for Cynics
• Agile is Dead • Pragmatic Dave Thomas
• Past , Present and Future of JSON API
• What keeps Apache Kafka from eating the world?
• Hints for writing Unix tools
• END-TO-END ARGUMENTS IN SYSTEM DESIGN
• Two Perspectives on the End-to-End Principle
• The Law of Leaky Abstractions
• Joe Armstrong - The Forgotten Ideas in Computer Science
• Baron Schwartz - Business Observability Matters Too
• Prometheus - A Whirlwind Tour by Cindy Sridharan
• The How and Why of Fitting Things Together - Joe Armstrong
• From Kafka to ZeroMQ for real-time log aggregation
• Type Systems - The Good, Bad and Ugly by Paul Snively and Amanda Laucher
• Nathan Sorenson - Domain Specific Type Systems
• Look for the duct tape
• What makes a good REPL?
• Effective Engineer - Notes
• Antics, drift, and chaos by Lorin Hochstein
• Organizational Skills Beat Algorithmic Wizardry
• Let’s talk about usernames
• What I learnt from building 3 high traffic web applications on an embedded key value store.
• Introduction to Contract Programming
• ZeroMQ RFC 42/C4 - Collective Code Construction Contract
• Pieter Hintjens - How Conway's Law is eating your job?
• How is a Class like a Microservice?
• The best software engineering paper you haven't read
• Pieter Hintjens - ZMQ, tech, ideas, community, writing and life
• Data Driven Products Now!
• Choose Boring Technology
• What the Four Color Theorem can Teach Us About Writing Software
• Pieter Hintjens - Our decentralized future
• Greg Young - Developers are strange creatures
• Greg Young - Stop Over-Engenering
• Ideology
• Toward a Functional Programming Analogy for Microservices
• Growing Your Tech Stack: When to Say No
• Idée Fixe - David Nolen
• The Language of the System - Rich Hickey
• How do groups work on Linux?
• Clojure, Made Simple - Rich Hickey
• Safety-Critical Systems - Professor Martyn Thomas
• How Can Software Be So Hard? - Professor Martyn Thomas
• Just Say No to More End-to-End Tests
• Software Is About Storytelling
• Smart Endpoints, Dumb Pipes
• You Cannot Have Exactly-Once Delivery
• Martin Fowler - Event Sourcing
• Ashley Williams - A brief history and mishistory of modularity
• How do you cut a monolith in half?
• Best practices for staging environments
• Clojure vs. The Static Typing World
• Designing for Reliability
• Scaling Unsplash with a small team
• Metrics: not the observability droids you're looking for
• Monitoring in the time of Cloud Native
• Everyone is not Ops
• My Philosophy on Alerting
• An Introduction to Raft by Diego Ongaro, creator of Raft
• Effective Programs - 10 Years of Clojure - Rich Hickey
• "Managing Containers at Scale with CoreOS and Kubernetes" by Kelsey Hightower
• HTTPS on Stack Overflow
• The Million Dollar Engineering Problem
• make tutorial
• Why Microservices Work For Us
• Rebuilding Our Infrastructure with Docker, ECS, and Terraform
• Where Is Our “Package Manager for the Cloud?”
• Dark corners of Unicode
• Testing in production
• Greg Young - The art of destroying software
• OK Log
• Starbucks should really make their APIs public.
• Tyler McMullen - Load Balancing is Impossible
• Is it unethical for me to not tell my employer I’ve automated my job?
• Hyperproductive development
• What can developers learn from being on call?
• The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets
• Ten Rules for Open Source Success
• Network protocols - For everyone who knows a programming language
• Every Server Is A Kind Of Honeypot
• Docs, Docs, Docs!
• Elixir Should Take Over the World by Jessica Kerr
• Lessons From A Lifetime Of Being A Programmer
• Joe Armstrong interviews Alan Kay
• In Pursuit of Production Minimalism
• Linux utils that you might not know
• Surviving In Open-Source
• Reducing test cases for JavaScript tooling
• Good comments explain WHY, not WHAT, and 3 more rules on writing good comments
• Understand Go pointers in less than 800 words or your money back
• Search the git log from the command line
• A Note About Git Commit Messages
• Readability Matters More Than Correctness
• No feigning surprise
• The Silver Bullet Syndrome by Hadi Hariri
• Latency Numbers Every Programmer Should Know
• Promoting reliability in web software companies
• Git in six hundred words
• Three Attitudes that Lead to Maintainable Code
• Why Use Make
• File crash consistency and filesystems are hard
• How many floating-point numbers are in the interval [0,1]?
• A Programmer’s Introduction to Unicode
• Design Better Data Tables
• /usr/bin/time: not the command you think you know
• The mythical 10x programmer
• Normalization of deviance in software: how broken practices become standard
• A case for microservices
• A few drawings about Linux
• What Does an Idle CPU Do?
• 15 Fundamental Laws of Software Development
• The MIT License, Line by Line
• Diving into concurrency: trying out mutexes and atomics
• The Twelve-Factor App
• Applying the Linus Torvalds “Good Taste” Coding Requirement
• Logging v. instrumentation
• Segmenting and refining images with SharpMask
• Unix philosophy
• Hints for writing Unix tools
• How To Become A Hacker
• Writing Less Damn Code
• It's The Future
• Web Design in 4 minutes
• Taking The Robots To Design School
• Joe Armstrong - Erlang and other stuff
• Should you be scared of Unix signals?
• Recovering files using /proc
• Debug your programs like they're closed source!
• What Makes Software Good?
• Teaching Robots to Feel: Emoji & Deep Learning
• How to Fold a Julia Fractal
• Have Software Developers Given Up?
• I/O matters.
• How I got better at debugging
• All I Need To Know To Be A Better Programmer I Learned In Kindergarten
• Programming Is a Dead End Job
• How the Sunk Cost Fallacy Makes You Act Stupid
• My Biggest Regret As A Programmer
• I stayed in a hotel with Android lightswitches and it was just as bad as you'd imagine
• Man Combines Random People’s Photos Using Neural Networks And The Results Are Amazing
• Everything is broken
• The worst part about programming
• Things I’ve Stopped Saying
• You can't parse HTML with RegEx
• Why you should understand a little about TCP
• Effluents influence affluence : Butterick’s Practical Typography
• Why You Should Choose Your Own HTTPS.
• Docker Containers on the Desktop
• Everything Is Broken
• The Humble Programmer
• Instagram's Million Dollar Bug
• The web accessibility basics
• The Website Obesity Crisis
• The Making Of 'In Pieces'
• Unidirectional User Interface Architectures
• 'Inside the Wolfram Language' by Stephen Wolfram
• 'The Mess We're In' by Joe Armstrong
• Alan Kay - Power of Simplicity
• Five Things Old Programmers Should Remember
• A tr Primer
• Graphical thinking - optimisation through functional programming
• The best icon is a text label
• Bash One-Liners Explained - Redirections
• The Value of Values - Rich Hickey
• What is your most productive shortcut with Vim?
• The Story Behind How Pocket Hit 20M Users with 20 People
• Fighting spam with Haskell
• Web Design : The First 100 Years
• Dropdowns Should be the UI of Last Resort
• Pure UI
• Building SVG Icons with React
• You’re Missing the Point of React
• You Might Need Flux
• Not Just Code Monkeys - Martin Fowler
• Rob Pike's 5 Rules of Programming
• 9 Anti-Patterns Every Programmer Should Be Aware Of
• Running A Software Business On 5 Hours A Week
• FizzBuzz In Too Much Detail — Tom Dalling
• The sad state of sysadmin in the age of containers
• The Beauty of Code
• Process substitution
• Reverse Engineering Regular Expressions
• What I’ve learned so far about software development
• Project managers, ducks, and dogs marking territory
• What I Wish I Knew When Starting Out as a Software Developer
• On Being A Senior Engineer
• Is it really 'Complex'? Or did we just make it 'Complicated'?
• Move fast & break nothing
• Pipes and Filters
• How I got a medal from the Army for writing code
• Math For Programmers