A personal list of useful software engineering resources that may have been lost in my browser's history otherwise.
Note
All the updates are announced as releases. Watch this repository to receive notifications.
Why? What is this?
I share interesting software engineering resources on my Twitter/X as they come. Yet, interesting does not always mean worth revisiting. When somebody asks: Hey Mike, do you have any useful resources about Kafka?, we both would benefit from a single list. Besides, I sometimes forget too...
This list is like a set of selectively filtered bookmarks. My goal is not to add things here regularly but to keep them useful and accurate. New releases act a bit like a newsletter for those who are interested. Also, I don't link my own articles here.
Leave a ⭐ if you found it awesome too!
- The Twelve-Factor App
- A Hitchhiker’s Guide to Caching Patterns
- Microservices Production Readiness Checklist
- Simple systems have less downtime
- Event-Driven Architectures vs. Event-Based Compute in Serverless Applications - using serverless functions (like AWS Lambda) is not enough to call the architecture "event-driven"
- Maintaining a medium-sized Java library in 2022 and beyond
- Modern Best Practices for Testing in Java
- Map.merge() - One method to rule them all
- What is the point of extending a sealed class with a non-sealed class?
- How the JIT compiler boosts Java performance in OpenJDK
- Automatic-Module-Name: Calling all Java Library Maintainers
- Testing in a modular world - an overview of available testing strategies when using Java Platform Module System (JPMS)
- Java Best Practices
- There is no single dependency graph - caveats and misconceptions around resolving application/library dependencies
- Local Variable Type Inference Style Guidelines - when to
use (and when not) the
varkeyword - 📺 Secrets of Performance Tuning Java on Kubernetes - despite the title, it focuses on the most essential parts like selecting the right GC, defining max heap size, and avoiding CPU throttling
- GC Causes - an useful list of various Java garbage collection causes
- The best way to use Testcontainers with Spring Boot - the "best" is always quite subjective, but this one is a really great starting point
- THE BEST WAY TO USE TESTCONTAINERS FROM YOUR SPRING BOOT TESTS! - it's
not a duplicate: this one shows how to use Testcontainers with
@ServiceConnectionin Spring Boot 3.x - How to Effectively Test Time-Dependent Code: Unit and Spring-Based Strategies
- Java 21 is no LTS Version - debunking myths about "LTS" releases
- When Quarkus meets Virtual Threads - great explanation of what Virtual Threads bring to the table, and how they "compare" to the reactive model. Not only for Quarkus users!
- Spring Transaction Management: @Transactional In-Depth
- JFR Event collection
- Best Practices for Unit Testing in Kotlin
- MockK Guidebook - a good addition to the official MockK documentation, especially when it comes to migrating from Mockito
- Kotlin: An Illustrated Guide
- Kotlin and Exceptions - dos and don'ts of using exceptions in Kotlin
- Coding conventions - a set of official language guidelines
- Zalando RESTful API and Event Guidelines
- Your Circuit Breaker is Misconfigured - overview of various Circuit Breaker parameters and their impact on reliability
- The Log: What every software engineer should know about real-time data's unifying abstraction
- Turning the database inside-out with Apache Samza
- Squeezing the firehose: getting the most from Kafka compression - overview and comparison of the available message compression methods
- Optimizing Kafka producers
- Exploring Kafka XYZ's Internals series
- 📺 Kafka: a map of traps for the enlightened dev and op - probably the best Kafka deep dive I've ever seen (from basic concepts, through operations, and complex "what if X fails?" considerations)
- How a Distributed SQL Database Boosts Secondary Index Queries with Index Only Scan - reading data directly from the index (PostgreSQL)
- The Skip Locked feature in Postgres 9.5 - turning PostgreSQL into a simple job queue
- The What, Why, and When of Single-Table Design with DynamoDB
- The Inner Workings of Distributed Databases
- Loose indexscan in PostgreSQL - finding distinct values of the leading columns of a B-tree index in an efficient way
- “Multi-AZ” in Amazon RDS and how it may differ from High Availability
- Challenges and Solutions When Scaling PostgreSQL - including
explanation on how to deal with bloat (
VACUUM) - PostgreSQL and UUID as primary key - short summary of the advantages of using UUID v7 instead of v4 (random)
- Consistency models - a clickable map of relationships between different consistency models
- Replicated Data Consistency Explained Through Baseball
- 10 Tips for Building Resilient Payment Systems - not only for payment systems!
- Prometheus Range Vectors series
- How does a Prometheus XYZ work? series
- Awesome Prometheus alerts - collection of alerting rules for various occasions
- In Kubernetes, what should I use as CPU requests and limits?
- A visual guide on troubleshooting Kubernetes deployments
- How to Write a Git Commit Message
- A better git blame with --ignore-rev - ignoring certain revisions (e.g.
code formatting) from
git blameoutput
- CUPID for joyful coding - an interesting and pragmatic alternative to SOLID (Composable, Unix philosophy, Predictable, Idiomatic, Domain-based)
- Kent Beck's four rules of simple design - passes the tests, reveals intention, no duplication, fewest elements
- Safe to fail vs fail safe - unless building a spacecraft, recovering from failures quickly may be more important than avoiding all possible issues in the first place
- Exploratory refactoring - learning the codebase through the refactoring
- The Best Code Review - tips on how to turn code review into a pleasant, and productive experience
- 20 Things I’ve Learned in my 20 Years as a Software Engineer - a handful of general tips from an experienced software engineer
- The ownership trio - true ownership requires all 3: mandate, knowledge, and responsibility
- 📺 Agility ≠ Speed - what does it really mean to be agile?
- The Ten Commandments of Egoless Programming
- Work on what matters - not every area is worth the same attention!
- The Economics of Engineering Blogs - there are some really good economic reasons to run a company engineering blog
- The documentation system - tutorials, how-to guides, explanations, and references (all serve a different purpose)
- IDEA - A series of nonverbal algorithm assembly instructions (IKEA style)
- Akin's Laws of Spacecraft Design
- The Difference Between a URL, URI, and URN
- Ribbon filter: Practically smaller than Bloom and Xor
- What you need to know to choose an open source license
- Wooledge's Bash Guide
- How Complex Systems Fail