Programming

CodeCrafters projects are nice. bun is a well designed project I use for inspiration (although it's in Zig). Love the way everything is commented out and the focus on performance.

Notes

• How to write fast code: reduce memory access. All of these tips stem from that: 1. Reduce the size of your data structures so more can fit in CPU cache. 2. Replace strings with numbers. 3. Make use of bit flags. Don’t waste space on booleans. 4. Access memory linearly. 5. Make judicious use of the heap. Inline the most commonly accessed values, move large or less common ones to the heap. 6. Model data like a database. Normalize commonly used structures and pass ids rather than copying them around. 7. Consider using a struct of arrays rather than an array of structs. For example, if you have two types of value, store them in separate arrays instead of a single one with a type field. This reduces memory usage and makes iterating by type linear.
• In software engineering there are two things you are trying to get right:
  • Software Validation - Did we build the right thing?
  • Software Verification - Did we build the thing right?
• Software simplicity is a prerequisite to reliability.
• A small, simple API is usually also a hallmark of a well-understood problem.
• Run/Right/Fast.
  • Make the code work I write is working. Then I can make it fast (if necessary). Solving the “correct/clean/performant code” problem all at once can be overwhelming. Don’t be overwhelmed. Solve one at a time.
• Reducing the maintenance burden is, for most codebases, the biggest optimization I can do.
  • Of course it's all about striking a balance, but 99% of the time there is a choice between performance and readability, readability is the right answer. Performance should only be chosen if it is absolutely necessary.
• If I write ugly code, anyone who intends to fix a bug or add a feature will not enjoy his work and likely avoid it next time.
• Explicit over implicit is almost always better.
• One of my principles is to always strive for simplicity when creating. In retrospect, I've learned many thing that I previously thought too complex to understand. The complexities tend to dissolve when you realize they are mostly just extra distractions emerging from the pressures of engineering the thing... distractions that you probably find yourself inventing all over again once you've assimilated the core idea.
• Readme driven development is pretty neat. Write the README first as a specification. Then write the code for it. Zeit do it often.
• We are about to study the idea of a computational process. Computational processes are abstract beings that inhabit computers. As they evolve, processes manipulate other abstract things called data. The evolution of a process is directed by a pattern of rules called a program. People create programs to direct processes.
• Always be looking for patterns. Abstract them always and only when it simplifies.
• Persevere in getting an abstraction just right. When you find it, everything will magically fall into place.
• The implementation is the design.
• Hide whatever the caller shouldn't care about. In particular, you can remove type parameters with appropriate quantification.
• Declarative configuration means that you write down the desired state of the world in a configuration and then submit that configuration to a service that takes actions to ensure the desired state becomes the actual state.
• Every single feature makes product more complex, makes testing more complex, puts constraints on UI design etc. Controlling feature creep (also by revisiting old features) is very important to keep project healthy. Larger the project, more important it is.
• “Simplicity” often just means that a concept fits cleanly in the maker’s head at a particular point in time. How many times have I returned to a project I thought was simple only to find I had burdened it with spooky magic because I didn’t benefit from critical distance at the time? When was the last time I deemed another person’s work “too complex” because I couldn’t understand it in one sitting and wasn’t aware of the constraints they were operating under? Answers: too often and too recently.
• If we take a look at any given line of code in a method, we can nearly always categorize it as serving one of the following roles: 1. Collecting input. 2. Performing work. 3. Delivering output. 4. Handling failures.
• Code duplication is far cheaper than the wrong abstraction. When the abstraction is wrong, the fastest way forward is back.
• Senior skills: Understanding requirements and knowing when to clarify. Building what's actually needed. Working with others including leadership. Working with customers when needed. Attention to detail. Knowing when to challenge others. Ownership. Innovation. Adaptability to change.
• Write the comments first, then fill in the code.
• If your variable names are good enough you need way fewer comments
• The mindset that has helped me to improve my skills is that you should always just roll up your sleeves and look at the running process and its code rather than wasting more than 5 minutes searching for help or pouring over documentation that’s out of date and never correct. Put a short time cap on the time you spend doing that, and then just put on your explorer hat and pull out your scary toolkit to hunt that thing down.
• Practices you can follow to get 10x results with programming
  • Understand the business reasoning behind the project…look for ways of exploiting that knowledge to minimize the amount of work done.
  • Less code is always easier to debug…or if you can’t debug, throw out and replace.
  • Clearly defined project goals and constraints and milestones make development fast and visible.
  • Throwaway prototypes are faster than big projects and teach you more–and may be good enough for the business.
  • Understanding, deeply, the tools you use and the basic principles of computer science and engineering help you prune solution spaces a lot better.
  • Identify whether or not the framework/third-party app is actually delivering value over just implementing a smaller bespoke solution yourself. Color picker? Almost certainly. Database extension? Probably. Container orchestration for a static blog? Probably not.
  • Pseudocode and stepwise refinement of the solution to a problem. If you can’t explain something with bullet points, you don’t understand it, and if you don’t understand it, you’re slow.
• Code style comments are tiny cuts to someone's confidence and you should weigh that vs the value of the "fixing" it..
• My measure of codebase quality these days is almost entirely "how easy is it to change". So readability is key, and also making sure that changes have to touch as few places in the code as possible.
• 1. You're not clever. 2. Distributed systems rule #1: Do not distribute the system! 3. Do not micro optimize. 4. Measure where your program spends time. 5. Optimization rule #1: Reduce I/O. 6. Should I use a distributed cache? No!
• Top 3 motivation killers for developers: Slow environments to test. Micromanagement. Continuous legacy projects.
• Software should be: Robust. Reliable. Stable. Simple.
• Read, analyze and write lots of code. Don't be too concerned with the latest fads.
• When I update dependencies, I generally try to check each update to see what has changed. This is where using a lot of dependencies becomes expensive, because it takes more work to update them. I don’t really see this process bring automated, unless a web-of-trust like thing got popular. But I’m not holding my breath.
• 99% of what I do in a large codebase is find pre-existing examples, copy-paste structure, fill in the holes and clean up. That's it.
• Don't comment bad code. Rewrite it.
• Universal property of software is that it evolves. And since human beings (us, developers) make it evolve, we need to make sure that making evolve will be as easy as possible, and as little error-prone as possible of course.
• The developers who seem to have all the answers? They aren’t smarter than you. They’ve just seen that before.
• Why do programmers reach for step-based debugging when tracing (print-based debugging) is generally more useful?
• Computers, networking, etc are just an agreed upon spec of which bytes in which location result in which action.
• Mutation at a microscopic level is totally okay. What matters most is avoiding mutation at the macroscopic level, like when the app architecture has many important modules mutating or monkey patching each other.
• My general rule is that mutating off screen is dangerous, not necessarily bad but a red flag. I’ve found if you have to scroll up/down or change file to find a reference to some variable then there is almost certainly an increased chance of fuckery.
• An anti-pattern is just a pattern used in a sub-optmial context. A good practice is just a practice used in the right context. You shouldn't talk about patterns and practice being "good" or "bad" without talking about the context in which they will be used.
• “Change only one thing at a time” should be codified into every software change control process. There should be no implicit changes, ever. Every single bit of config needs to be captured as code.
• Code affects humans, not machines. Think through the consequences of design decisions. Tradeoffs are everywhere, document them. Taking on technical debt should be an informed decision, not the default. All resources are finite. Know your complexity bounds and impossibility results.
• We should have "code walkthrough" meetings, where someone who knows an aspect of the codebase explains how it works to everyone else. No PRs reviewed, no decisions made, just knowledge transfer.
• You should own your core competencies.
• If you write software that shows errors to users (so, software) please, do everyone including yourself a favor and keep some way of figuring out the causal chain that drove a certain decision by your program.
• Don’t build software systems “to last”: we humans are terrible at predicting what changes we’ll need to make in the future. Instead, develop expertise at replacing systems. You know for sure you’ll need to replace it, so replace often, you’ll get better at it!
• Writing a program: 1. Analyze the problem. 2. Build the flow chart. 3. Code the instructions.
• Better direction is to speed up applications by cutting most of the bullshit (JS/HTML) and move workload to the GPU. Seems like a much cleaner total complexity than go for thin client / fat server again.
• Recommendation I give everybody starting up in tech is: read the source. No matter what, read code.
• Function should have one goal. It’s okay for it to do more than a single thing (even without splitting) as long as any codepath taken through it achieves the same goal, and doesn’t do things unrelated to that goal.
• In your comments, write what you did and why, record your level of petulance (REALLY) and the StackOverflow link that made you realize something
• If you want to learn programming better, don't immediately go and search for solution. Try and solve problem yourself given what you know. Then search and compare solutions.

Links

• One Bite At A Time: Partitioning Complexity
• Being A Developer After 40
• What's code?
• Portability matters
• On being an effective developer
• Advice to the newish programmer
• Comment Your Code
• Things You Should Never Do
• Writing good bug reports
• Tips for reading new codebases
• Engineering Principles at Monzo
• Awesome Cold Showers - For when people get too hyped up about things. (HN) (HN)
• Fish Design Principles
• List of resources about programming practices for writing safety-critical software
• In Pursuit of Production Minimalism
• Mostly avoid unit tests
• Software disenchantment
• In search of software perfection - Xavier Leroy (2016)
• Ask HN: What's the largest amount of bad code you have ever seen work? (2018)
• HN: Please do not attempt to simplify this code (2018)
• HN: Minimalism: Practical Guide to Writing Less Code (2018)
• Software Engineering at Google Paper (2017) (HN)
• Software Engineering at Google Book (2020) (Summary)
• Professional Programming - Collection of full-stack resources for programmers.
• Ask HN: What are must-know concepts for back end development? (2019)
• HN: Advice to new programmers (2019)
• Shipping code at N26 (2019)
• Junior and senior engineers (2015)
• Ask HN: How to be productive with big existing code base (2019)
• On Simplicity (2019)
• Programming Dictionary (Russian)
• HowProgrammingWorks courses (Russian)
• Keep a Changelog (Code) (HN)
• Teach Yourself Programming in Ten Years (1998) (HN)
• Rich Hickey on becoming a better developer
• Why programming is difficult
• Abstractions (2019)
• Categorized overview of Programming Principles & Patterns
• Too DRY - The Grep Test (2013)
• Awesome Roadmaps - Curated list of awesome software development roadmaps.
• Awesome EventStorming
• 7 absolute truths I unlearned as junior developer (2019) (HN) (Lobsters)
• Every Programmer Should Know
• Risk-First development book
• Visual Programming Codex - Resources and references for the past and future of visual programming.
• Things I Learnt from a Senior Software Engineer (2019) (HN)
• Writing system software: code comments
• Ask HN: How do you handle logging? (2019)
• Google Engineering Practices Documentation (Code)
• How to do a code review (HN)
• Ask HN: What Have You Learned at Google as a Software Engineer? (2019)
• Software Foundations series - Broad introduction to the mathematical underpinnings of reliable software.
• Software optimization resources
• Simple Made Easy by Rich Hickey (2011)
• "Performance Matters" by Emery Berger (2019)
• Exercises in Programming Style - Comprehensive collection of programming styles using a simple computational task, term frequency.
• Ask HN: What is the most beautiful piece of code you've ever read? (2019)
• Software Engineering for Industry
• Execute program - Programming lessons.
• Cheng Lou - Taming the Meta Language - React Conf 2017
• Programming Across Paradigms • Anjana Vakil (2017)
• TBA: Developer experience stuff? by Ashley Williams (2019)
• Best Practices Checklist - List of awesome idiomatic code resources. Rust, Go, Erlang, Ruby, Pony and more.
• Programming book list
• Programming Talks
• There's No Such Thing as Knowing Your Computer 'All the Way to the Bottom' (2019) (Lobsters)
• Building awesome developer tools - Ines Montani (2019)
• Minimal Viable Programs
• Minimalism in Programming (2018)
• ReactiveConf 2019 - David Nolen: Are we there yet? Remix
• Sourcetrail - Free and open-source cross-platform source explorer. (HN)
• Developer Roadmaps - Community driven roadmaps, articles and resources for developers. (HN) (Code)
• Inversion of Control (2019)
• On porting code (2019)
• Challenging projects every programmer should try (2019) (HN)
• You don't need loops - Avoid The One-off Problem, Infinite Loops, Statefulness and Hidden intent.
• Bret Victor - The Future of Programming (2013)
• Ask HN: What do top engineers you know do that others don't? (2019)
• If you're goal is to learn how to code in 2020, here's a thread of advice for you
• Curated Programming Resources
• Goodbye, Clean Code (2020) (HN) (Lobsters) (HN)
• The Wrong Abstraction (2016) (HN)
• Returning to First Principles (2020)
• On Composition (2019) - Our composition models are poor and don't scale well (HN).
• Simplicity isn't simple (2015) (Lobsters)
• End-user programming (2019)
• Slow Software (2018)
• Noweb - Simple, Extensible Tool for Literate Programming. (Code) (HN)
• verso - New approach to literate programming.
• Program Repair - Community-driven effort to facilitate discovery, access and systematization of data related to automated program repair research.
• Literate Programming notes
• TU Delft Software Engineering Research Group (SERG)
• Ask HN: What change in your programming technique has been most transformative? (2020)
• Curated list of awesome DIY software
• How Big Technical Changes Happen at Slack (2020) (HN)
• Lobsters: What's the best GUI library around? (2020)
• Genetic programming is waiting for better tools - Rakhim Davletkaliyev (2019)
• Computers can be understood (2020)
• Notes on structured programming - Edsger Dijkstra (1970)
• What makes a dependency dependable?
• Defunctionalisation – an underappreciated tool for writing good software (2020) (HN)
• Ultimate Coding Resources List
• libs.garden
• Advice on things to learn for junior dev (2020)
• How I became a better programmer (2017) (HN)
• Ask HN: How to improve code quality while maintaining decent velocity? (2020)
• New Grad vs. Senior Dev (HN)
• Things I’ve learned in 20 years of programming (HN)
• Design Patters for Humans - Ultra-simplified explanation to design patterns.
• Sad state of cross platform GUI frameworks (2020) (Lobsters)
• Lobsters: The happy state of (2020)
• Worse Is Better
• Ask HN: How to rediscover the joy of programming? (2020)
• Malleable Systems: Software must be as easy to change as it is to use it (HN) (Web Code)
• Learn With Jason - Live show streamed where Jason pair programs for 90 min to learn something new.
• How to Design Programs - Introduction to programming and computing. (Book) (Code) (HN)
• JetBrains Academy - Learn to Program by Creating Working Applications.
• Engineering code quality in the Firefox browser: A look at our tools and challenges (2020) (HN)
• Effective Engineer - Notes (HN)
• Complexity Has to Live Somewhere (2020) (Lobsters) (HN)
• Software Folklore – A collection of weird bug stories (HN)
• Floating Point Visually Explained (2017) (HN)
• Ask HN: Do you ever go back and admire a piece of code you wrote? (2020)
• Write Libraries, Not Frameworks (2020) (HN) (Reddit)
• Feedback Ladders: How We Encode Code Reviews at Netlify (2020)
• The find-and-replace Odyssey, a programmer's guide (2020)
• Migrations: the sole scalable fix to tech debt (2018)
• Lobsters: What non-electron cross-platform GUI toolkit do you enjoy using? (2020)
• What Color is Your Function? (2015) (HN) (Tweet)
• So, what does it mean to be a senior developer? (2020)
• The Wet Codebase by Dan Abramov (2019)
• Ask HN: Why isn’t visual programming a bigger thing? (2020)
• The Unreasonable Effectiveness Of Declarative Programming (2020) (HN)
• 7GUIs - GUI Programming Benchmark. (HN)
• Lower Your Guards: A Compositional Pattern-Match Coverage Checker
• Software Engineering Within SpaceX (2020) (HN)
• Ask HN: Are my expectations on code quality and professionalism too high? (2020)
• Literate - Literate programming tool for any language. (Web) (Lobsters)
• Ask HN: What is the ideal developer experience in 2020?
• Lobsters: What's the ideal developer experience in 2020?
• Latency Numbers Every Programmer Should Know (Code) (HN) (HN)
• Annotated Debugger Implementation Bibliography (Code)
• Conversational software development (2020)
• Choose Boring Technology (2015) (HN) (HN 2)
• Software Design for Flexibility by Chris Hanson, Gerald Jay Sussman (2020)
• MIT 6.001 Structure and Interpretation (1986) (HN)
• If you can't delete code then you're stuck with it
• Dynamic linking (2020) (Lobsters) (HN)
• It's probably time to stop recommending Clean Code (2020) (Reddit) (Lobsters) (HN)
• Software reuse is more like an organ transplant than snapping Lego blocks (2011) (HN)
• Programming Questions Quiz
• Ways to explain code when told it doesn't make sense
• The Coding Career Handbook (HN) (Code)
• Awesome Katas - Curated list of code katas.
• Beginner’s Guide To Abstraction (2020) (HN)
• Code Only Says What it Does (2020) (HN)
• Concepts around building software (Code)
• Evidence-based Software Engineering: based on the publicly available data (Code) (HN) (Lobsters) (Code and Data used)
• Code Reviews at REKKI (2020)
• Rise of Worse Is Better (Tweet)
• An introduction to vectorization (2019)
• Introduction to Asynchronous Programming
• Etcd, or, why modern software makes me sad (2020) (HN)
• The golden rule of software quality (2020) (Lobsters)
• Advice to Myself When Starting Out as a Software Developer (Reddit)
• Write code that is easy to delete, not easy to extend (2016) (HN)
• Why GNU grep is fast (2010) (HN)
• What debugging technique did it take you entirely too long to learn? (2020)
• Dialectical Progress in Programming (2017)
• Assessing Abstractions
• Views on Error Handling (2020) (HN)
• What is memoization
• Niklaus Wirth: A Plea for Lean Software (1995) (HN)
• Data-Centric Parallel Programming: Torsten Hoefler (2020)
• DomeCode - Single platform to learn to code.
• How To Make Less Dumb Mistakes When Programming (Lobsters)
• George Hotz | what is programming? (2020)
• Disintegrated Development Environments — How Did We Get Here? (2017)
• GitHub Arctic Code Vault: Tech Tree (HN)
• Tripping over the potholes in too many libraries (2020) (Lobsters)
• 12 Principles for a Diverging Desktop Future (2020) (Lobsters)
• Systemic Software Debugging
• Aspect-oriented programming (JS library implementation) (Paper)
• Rob Pike's Rules of Programming (1989) (HN)
• How we use "ship small" to rapidly build new features at GitHub (2020)
• Digital Design in Architecture: research landscape map 1975-2019 (HN)
• Ask HN: How do you overcome decision fatigue in software development? (2020)
• xkcd: Dependency (HN)
• On Parallel Programming (2020)
• You've only added two lines - why did that take two days! (2020)
• Ask HN: How to do cross platform GUI? (2020)
• How to Write Unmaintainable Code (2003) (HN)
• The Life of a Data Byte (2020)
• Ask HN: As a developer what are your aha moments? (2020)
• Curated list of falsehoods programmers believe (HN) (HN)
• Signals & Threads Podcast
• Decision Table Patterns (Lobsters)
• Ask HN: I'm a terrible developer, what now? (2020)
• Computer Architecture: A Quantitative Approach (1990) (Review)
• Project Oberon - Design for a complete desktop computer system from scratch. (HN) (HN)
• Programming Styles (2008)
• My Principles for Building Software (2020) (Lobsters)
• When feature flags do and don’t make sense (2019) (HN)
• The case for comments in code (2020) (HN)
• Technically - Learn about software.
• Kevin Mahoney: Applying "Make Invalid States Unrepresentable" (2020) (Lobsters) (HN)
• Principles of Data Oriented Programming (2020) (HN)
• Finding memory leaks with Memtrace (2020)
• Ask HN: Essential skill needed to be a programmer? (2020)
• State-Transition Tables (2020) (HN)
• 14,000x Speedup a.k.a. Computer Science for the Win (2020) (HN)
• Computers Are Hard: building software with David Heinemeier Hansson (2020)
• Crafting Functions (HN)
• Handling Bidirectional Control Flow (2020)
• Managing technical quality in a codebase (2020)
• How to Write Good Programs book (2020)
• Computer Science Circles - Teaches computer programming.
• Programming with a Read-Eval-Synth Loop (2020) (HN)
• Poor man's profiler (Lobsters)
• Infer - Static analyzer for Java, C, C++, and Objective-C. (Web) (Facebook's Code Checker)
• What you can do when code is really hard to review
• Discipline Doesn’t Scale (2020) (HN)
• Interfaces generally belong with users (2019)
• Foundations of Software Engineering course (2020) (HN)
• The Self-Improving Developer book
• All About Code Review - Curated collection of articles, tools, checklists and other awesome resources about code reviews.
• Functions That Go Backwards (2020)
• Technical debt as a lack of understanding (2020) (HN)
• The State-Diff Pattern (2020)
• The Tao of Programming (1987) (HN)
• Catalog of code worth reading
• Metaprogramming for madmen (2012) (HN)
• Exotic Programming Ideas: Part 1 (Module Systems) (2020)
• Essays on programming I think about a lot (HN)
• What distinguishes great software engineers? (2019) (HN)
• Exotic Programming Ideas: Part 2 (Term Rewriting) (2020) (HN)
• Production Oriented Development (2019) (HN)
• Bit Twiddling Hacks (HN)
• Programiz - Learn to Code for Free.
• How to Make Your Code Reviewer Fall in Love with You (2020) (HN)
• Software Design for Flexibility (HN)
• Adventures in Advanced Symbolic Programming (2021) (Code)
• State Machines resources
• Code Review Best Practices – Lessons from the Trenches (2020) (HN)
• Frontiers of Performance with Daniel Lemire (2020)
• Metaprogramming (2020)
• "What The Hardware Does" is not What Your Program Does: Uninitialized Memory (2019)
• Awesome Live Coding - Curated list of live coding languages and tools.
• Shitlist Driven Development (2016)
• How Tail Call Optimization Works (2020) (HN)
• On developer metrics - Time to debug (2020) (Tweet)
• My Engineering Axioms (HN) (Lobsters)
• What is a Pedagogic IDE?
• Coding as a tool of thought (2020) (Lobsters)
• Against Essential and Accidental Complexity (HN)
• Compiling Refactors - Benjamin Kovach (2017)
• State machines are wonderful tools (2020) (HN)
• Some of my favorite systems research reads from 2020
• Two Kinds of Code Review (2021) (Lobsters)
• Pyroscope - Continuous profiling platform — find bottlenecks in your code. (Web) (Docs) (Docs Code)
• What I’ve Learned in 45 Years in the Software Industry (2021) (HN)
• Ask HN: What does mastery look like in software engineering? (2021)
• "How does this software work?" by Adrian Cochrane
• Code Review Checklist
• Composition is interpretation (2021) (Lobsters)
• How to join a team and learn a codebase (2020) (HN)
• Naming cheatsheet - Comprehensive language-agnostic guidelines on variables naming.
• Programming.Guide - Articles on Programming.
• Exploiting Mixed Binaries
• That XOR Trick (2020) (HN) (Reddit)
• Diffing (2020)
• Flow-based Programming - Programming paradigm that uses a "data processing factory" metaphor for designing and building applications. (HN)
• Paradigms of Programming (OCaml + Prolog) (2020) (Videos) (Code)
• Why isn't differential dataflow more popular? (Lobsters) (HN)
• Software engineering topics I changed my mind on (2021) (HN) (Lobsters)
• Patterns and Software: Essential Concepts and Terminology (2000)
• Microsoft Customer/Partner Engineering Playbook
• Developers spend most of their time figuring the system out (HN)
• The Elements of Computing Systems, Second Edition (2021) (HN)
• Programming for Cats - Book written specially for cats who want to program. (HN)
• Debugging stories - Collection of debugging stories.
• Teach debugging
• Understanding Computation Book - Fun and interesting book about computation theory, with explanations written in real Ruby code instead of mathematical notation. (Code)
• Applied Compositional Thinking for Engineers
• On navigating a large codebase (2020) (HN)
• Is this a branch? (2021) (Lobsters) (HN)
• All about thread-local storage (2021) (HN)
• "Naming Things" is a Poor Name for Naming Things (2021) (Lobsters)
• The Tech Debt Playbook (2021)
• Approaches to Exploring Codebases
• Software Engineering Laws Everybody Loves to Ignore (2021) (Lobsters) (HN)
• Finite State Machines (2021) (HN)
• Linking - How programs are combined
• Why is it so hard to see code from 5 minutes ago? (2021) (HN) (Lobsters)
• How to write readable code (2021) (Reddit)
• The Complete Guide to Feature Flags (2021)
• Building Better Code Review at Heap (2021)
• Feedback Ladders: How We Encode Code Reviews at Netlify (2020) (HN)
• How to execute an object file (2021)
• Building cool software projects notes
• On Understanding Data Abstraction, Revisited (2009)
• Coding Constructs I Now Avoid (and why) (2021) (Lobsters)
• Write libraries instead of services, where possible (HN)
• The Debugging Book - Tools and Techniques for Automated Software Debugging. (Code)
• Programming Paradigms, Turing Completeness and Computational Thinking (2020) (HN)
• Staying out of TTL hell (2021)
• Why Programmers Should(n't) Learn Theory (2021)
• Principles of Developer Experience (2021)
• Get better at programming by learning how things work
• Fundamentals of Optimal Code Style (Lobsters)
• Is Parallel Programming Hard, And, If So, What Can You Do About It? (HN) (Code)
• StatesML - States Modeling Language.
• Ask HN: I've realized I'm a bad software engineer and I'm over 30, what's next? (2021)
• Modern Code Review: A Case Study at Google (2018)
• Keep It Local (2021) (Talk)
• What problems do people solve with strace? (2021) (Lobsters)
• Awesome Code Review
• My programming setup (2021)
• Recommendations for learning fundamentals of programming
• Examples of real-world, relatable engineering trade-offs (2021)
• On Cache Invalidation: Why Is It Hard? (2018) (HN)
• Programming is hard (2021) (HN)
• Surprisingly Slow (2021) - Collection of various computer and software behaviors that are unexpectedly slow or slow for unexpected reasons. (Tweet)
• Ask HN: What tech job would let me get away with the least real work possible? (2021)
• First-Class I/O (2021) (HN)
• Running code within another process's address space (2021) (HN)
• You might as well timestamp it (2021) (HN)
• Ask HN: What diagrams do you use in software development? (2021)
• How we ship code faster and safer with feature flags (2021)
• What are your favorite codebases to study? (2021)
• Generalizing linear operators in differential dataflow (2021)
• Software qualities: what they are and how can you improve them (2021)
• Lobsters: What's the most mysterious bug you've ever encountered? (2021)
• The Myth of the Genius Programmer (2009)
• Instruction level just-in-time programming (Lobsters)
• "What even is code? Building a non-code coding interface" - Katie Bell (2021)
• Effective Code Review
• How necessary are the programming fundamentals? (2021) (HN)
• Learn the Basics of Programming in 20 Minutes
• Ask HN: Is it better to generalize or specialize as a developer? (2021)
• Drunk Post: Things I've learned as a Sr Engineer (2021) (HN) (Lobsters)
• How to Design Perfect (Software) Products
• Staff archetypes
• Clever vs Insightful Code (2021) (Lobsters) (HN)
• An incomplete list of skills senior engineers need, beyond coding (2021) (HN) (Tweet)
• Why bugs might feel “impossible” (2021) (HN)
• Unreliability at Scale (2021) (HN)
• Ask HN: How to learn proper Systems Programming? (2021)
• Immutability Changes Everything (2016) (HN)
• When To Rewrite (2021) (Lobsters)
• Principles.dev - Software Engineering Principles. (HN)
• Write code that is easy to delete, not easy to extend (2016) (HN)
• Explaining Variable (2021)
• Two Wishes for Dev Tooling (2021) (HN)
• Software Transactional Memory: a stairway to lock-free programming heaven? (2021)
• Our Machinery Design Principles - Principles and guidelines for how to write code and work together at Our Machinery.
• Software Engineering's Greatest Hits (2021) (Lobsters)
• Heuristics for Effective Software Development: A continuously evolving list (HN) (Lobsters)
• Common Systems Programming Optimizations & Tricks (2019)
• The State of Developer Ecosystem in 2021 Infographic (HN)
• Creative Code Management (2021) (HN)
• Reflections on 10,000 Hours of Programming (2021)
• Ask HN: What has improved You as a Developer? (2021)
• A Practical Theory of Programming (PDF)
• Stack Overflow Developer Survey 2021 (Lobsters)
• So you want to write a GUI framework (2021) (HN) (Lobsters)
• The big-load anti-pattern (2021) (Lobsters)
• Ask HN: Do You Use a Debugger? (2021)
• "Programming a 144-computer chip to minimize power" - Chuck Moore (2013)
• Caches, Modes, and Unstable Systems (2021) (HN)
• Making Reasonable Use of Computer Resources: Part 2 (2021)
• The benefit of a dependency is inversely proportional to the amount of effort spent on a project (2021) (Lobsters)
• Systems Conferences 2021
• Hexlet - Больше чем школа программирования. Онлайн курсы, сообщество программистов.
• Fundamentals of programming you learned on the job? (2021)
• Ask HN: Books that teach you programming languages via systems projects? (2021)
• Write code that's easy to delete, and easy to debug too (2021)
• The Case for 'Developer Experience' (2021) (HN)
• On Building Glue Systems (2021) (HN)
• Improve Your Life with Long Error Messages (2021) (HN)
• The Speed of Time (2021)
• Code Review from the Command Line (2018) (HN) (Lobsters)
• Designing Low Upkeep Software (2021) (HN)
• ConE: A Concurrent Edit Detection Tool for Large Scale Software Development (2021)
• Offline first is not about having no internet connection (HN) (Reddit)
• Downsides of Offline First (HN)
• Data, objects, and how we're railroaded into poor design (2018) (Lobsters)
• Things Unlearned (2021) (HN)
• What is a Staff (or Staff-Plus or Principal) Engineer? (2021)
• It takes a PhD to develop that (2021) (HN)
• Deconcentration of Attention: Addressing the Complexity of Software Engineering (Lobsters)
• Offline-First Resources
• Don't write bugs (HN)
• Things I’ve learned in my 20 years as a software engineer (2021) (HN)
• Ask HN: Ever lost your love for coding? How did you get it back? (2021)
• Always Do Extra (2021) (HN) (Reddit)
• Are You Using The Right Cache? (2021)
• How I learned to program (2016) (HN)
• Features of Excellent Code Review Tools (2021)
• Programming Aesthetics: I. The Missing Skill (2021)
• Readability verification (2021)
• Why I Hate Frameworks (2005) (HN)
• Hello, declarative world
• Personal programming guidelines
• Programming as Architecture, Design, and Urban Planning (2021) (Tweet)
• Moving faster (2021) (Lobsters)
• Habits I've Developed for Fast + Efficient Programming (Lobsters)
• How to Report Bugs Effectively
• A word about benchmarking (2021)
• Codeamigo - Byte-sized interactive coding tutorials. (HN)
• Coding guidelines for an easier life (2021)
• Simple Code, High Performance (2021) (HN)
• A developer's guide to programatically overcome fear of failure (2021) (HN)
• Programming projects to work on for skill development
• The tale of a single register value (2021)
• Codecademy Docs - Collection of information for all things code. (Code)
• Responsible and Effective Bugfinding
• Which developer are you most inspired by, and why? (2021)
• Life is too short to depend on unstable software (2021) (HN)
• Software process antipatterns catalogue
• Make your technology sustainable - GOV.UK (Tweet)
• io.livecode.ch - Interactive programming tutorials, powered by Github and Docker. (Code)
• Quality in Software (2021)
• Andreas Fredriksson - Context is Everything (2021) (Lobsters)
• Overengineering can kill a product (2021) (HN)
• Programming as Theory Building Paper by Peter Naur (1985)
• Corey Schafer's Code Snippets
• A Case Study in Incrementally Improving Code (2021) (Tweet)
• What are your "strongly held programming beliefs"? (2021)
• Writing Maintainable Code is a Communication Skill (2021)
• Mindful Code Reviews (2021) (HN)
• The Memory Image Pattern (2021)
• Creating a better flamegraph visualization (2021) (Lobsters)
• What does a Principal Software Engineer do? (2021) (HN)
• Uncomfortable Truths in Software Engineering (2021) (HN) (Lobsters)
• Ask HN: Are most of us developers lying about how much work we do? (2021)
• Awesome Parallel Computing Resources
• Ask HN: Working with large code base for the first time (2021)
• Performance Anti-Patterns (2006) (Lobsters)
• How programmers make sure that their software is correct (2022)
• Programming in 1987 Versus Today (Lobsters)
• My process for building a feature (2022) (HN)
• Messing With The Recipe (2022) - Learn a little about what a program actually is, and learn just enough x86_64 assembly to be dangerous. (Tweet)
• How do you visualize code? (2022) (HN)
• if there would be one software engineering advice you could give to your 10y younger self, what would it be?
• Fixing Performance Regressions Before they Happen (2022)
• There’s No Such Thing as Clean Code (2022) (HN)
• How did I run that code again? Tools to help recall (HN)
• Ask HN: Best books on managing software complexity? (2022)
• What's in a good error message? (2022) (HN)
• An optimization story (2022) (Lobsters)
• five different paths to methods
• Single binary executable packages (2022) (Lobsters) (HN)
• CUPID—for joyful coding (2022)
• How I think when I think about programming (HN)
• Things that used to be hard and are now easy (2022) (HN)
• Things that used to be easy, but are now hard (2022)
• Times are great for programmers now. How does it end? (2022) (HN)
• Data-Oriented Programming
• Awesome profiling
• Programming Books: A Curated Reading List
• What does a 1972 paper have to do with the Single Responsibility Principle? (2022) (HN)
• Pair Programming Antipatterns (HN)
• Awesome Bug Bounty Tools
• Clean Code Notes
• Please Put Units in Names or use strong types (HN)
• Ask HN: I'd like to practice coding GUI from scratch. Any recommendations? (2022)
• Literate programming is much more than just commenting code (2022) (HN)
• Awesome Codemods
• Awesome ELF Resources
• What's in a Good Error Message? (2022) (Lobsters)
• Abstraction: Not What You Think It Is (2022) (Lobsters)
• The shape of data (Lobsters)
• Oil Is Being Implemented "Middle Out" (2022) (Lobsters)
• Awesome Bugs - Collection of bizarre, funny or obscure bugs in our software and hardware.
• Krun - High fidelity benchmark runner.
• Speeding up software with faster hardware: tradeoffs and alternatives (2022)
• Ask HN: How to improve as a struggling junior swe? (2022)
• Write Errors That Don't Make Me Think (2020)
• Errors are constructed, not discovered (2022)
• Programming Study Path
• Complexity and Granularity (2014)
• The USE Method - Methodology for analyzing the performance of any system.
• Computer Systems Learning Resources A Recommended List (2022)
• Stop Using Todo for Everything (HN)
• Ask HN: What helped you get good at programming? (2022)
• Dive into Systems - Free, online textbook that serves as a gentle introduction to computer systems, computer organization, and parallel computing.
• Thorsten Ball - Professional Programming: The First 10 Years (2022) (HN)
• Why Reproductions are Required (2022) (Tweet)
• Search over 2000 manually curated technical deep-dives related to programming
• 1x Engineer (HN) (Code)
• Awesome Research Software Registries
• Stack Overflow Developer Survey 2022 (HN)
• The Grug Brained Developer - Layman's guide to thinking like the self-aware smol brained.
• Ask HN: What tone to use in code review suggestions? (2022)
• What Metric to Use When Benchmarking? (2022)
• Why DRY is the most over-rated programming principle (2022) (HN)
• Maintaining Software Correctness (2022)
• Oxide and Friends | Debugging Methodologies (2022)
• Beej's Guides
• Ask HN: What are the best programming tricks you know? (2022)
• Library Writing Realizations (2015)
• Coding as a greybeard (2022)
• Strict-serializability, but at what cost, for what purpose? (2022)
• The Coding Train - YouTube (Discord)
• Tiny Programs in different languages
• Cut the cutesy errors (2022) (HN)
• Ask HN: What are the ways you go about getting comfortable with a new codebase? (2022)
• Post-Apocalyptic Programming (2022) (HN)
• How floating point works (2022)
• Succintly written (<1000 non-obfuscated loc), fully-functional software in any language
• Fogus's Thunks/Studies - Posts and code related to topics that I care about.
• Demystifying Dependence, Part 1: The Nine Dependency Puzzles (2022) (Lobsters)