Apprenticeship Retro
Reflecting on my 8th Light apprenticeship journey - books read, blogs written, projects completed, and lessons learned.
Archive
-
-
What the hell is CORS
Demystifying Cross-Origin Resource Sharing (CORS) and the Same-origin Policy that protects web browsers from malicious sites.
-
Cross-site Tracing
Understanding Cross-site Tracing (XST) attacks and how the HTTP TRACE method can bypass HttpOnly cookie protection.
-
Some Pairing Patterns
Social and behavioral patterns observed during intensive pair programming - checking ego, pulling out information, and stepping up.
-
Learning Testing Tools First
Why learning testing tools before diving into a new language or framework can accelerate learning and improve TDD practice.
-
Breaking Down Vim Registers
A comprehensive guide to Vim registers - unnamed, numbered, named, and read-only registers for storing and retrieving text.
-
The Circuit Breaker
Implementing the Circuit Breaker stability pattern to protect against failures from unavailable services or resources.
-
Text Editing Outside of Vim
Realizing the importance of text editing fluency outside your favorite editor - being a generalist with tools too.
-
Don't override built-ins
Learning why overriding built-in function names can cause confusion and how to make better naming decisions.
-
What is Technical Debt?
Exploring Ward Cunningham's original debt metaphor - it's about incomplete understanding, not sloppy code.
-
Project Specific Vim Configuration
Using Vim's built-in exrc setting to enable project-specific configurations without plugins.
-
The Principles of Package Coupling
Understanding the Acyclic-Dependencies, Stable-Dependencies, and Stable-Abstractions principles for reducing package coupling.
-
The Principles of Package Cohesion
Exploring the three principles of package cohesion - REP, CRP, and CCP - for allocating classes to packages effectively.
-
Describe Your Data Transformation
Using Clojure's thread macro to create readable data transformations that clearly describe the flow of operations.
-
The Visitor Pattern
The Visitor pattern - extending object structure behavior without modifying classes through double dispatch.
-
The Spectrum of the Observer Pattern
Understanding the Observer pattern spectrum - comparing push and pull models for notifying observers of changes.
-
From Workflow Inefficiency to an Ad Hoc Autotest
Creating an ad-hoc test runner in Vim using tmux send-keys to eliminate workflow friction when running tests.
-
tmux: send-keys
Using tmux send-keys to emulate keyboard input and automate workflows across panes and windows.
-
Command-line Mode
Exploring Vim's Command-line mode - one of the lesser-known modes that enables powerful command history features.
-
Parallel Change with Multimethods
Applying the expand-contract refactoring pattern in Clojure using multimethods to safely migrate function interfaces.
-
Deliberate Programming with Autotests
Using auto-test runners more deliberately with Vim settings to improve TDD workflow and avoid programming by coincidence.
-
Clients Own the Interface
A deeper look at the Dependency Inversion Principle - understanding that clients should own the interfaces they depend on.
-
Hygienic Macros
Understanding hygienic macro systems and why they matter - preventing unintended variable capture and binding issues.
-
Defining Named Functions with a List Comprehension
A cool pattern in Elixir - using list comprehensions to generate multiple named function definitions at compile time.
-
Mocking Sockets in Clojure
Creating test doubles for Java Socket objects in Clojure using proxy and closures for testing socket-based applications.
-
Homoiconicity
Exploring homoiconicity in programming languages - when code structure matches its internal representation, enabling "code as data".
-
Referential Transparency
Understanding referential transparency - when expressions can be replaced with their evaluated values without changing program behavior.
-
Closures
Explaining closures and free variables - how functions capture and retain access to variables from their enclosing scope.
-
Lexical & Dynamic Scope
Understanding the difference between lexical and dynamic scoping - how variable resolution differs based on code structure versus call stack.
-
Statements & Expressions
Clarifying the difference between statements and expressions in programming languages - actions versus values.
-
Thread Safety with Inner Classes
Understanding how implicit "this" references can escape inner classes and cause thread safety issues in Java.
-
Creating Event Listeners in Java
Demystifying event listeners in Java by building a custom event system for publishing notifications.
-
Briefly Exploring the Similarities Between LSP and DIP
Exploring the relationship between the Liskov Substitution Principle and Dependency Inversion Principle - both encourage flexibility in dependencies.
-
Rethinking Find and Till
Why Vim's find and till motions are hard to adopt, and how rethinking their use can make them more practical and less about precision.
-
Liskov Substitution Principle: An Overview
Introduction to the Liskov Substitution Principle - subtypes must be substitutable for their base types to maintain expected behavior.
-
What does it mean to be small?
Exploring the relationship between the Single Responsibility Principle and small classes - they may actually be the same thing.
-
Benefits of The Single Responsibility Principle
Three key benefits of the Single Responsibility Principle - reduced coupling, increased testability, and reduced mental energy.
-
Where do interfaces come from?
Two patterns for introducing interfaces - replacing subclasses with injection and creating dependencies that don't exist yet.
-
NoClassDefFoundError
Understanding Android's Java compilation process and debugging a NoClassDefFoundError caused by missing runtime dependencies.
-
SRP & ISP - Part 2
How the Interface Segregation Principle applies SRP to dependencies - limiting coupling and improving cohesion.
-
SRP & ISP - Part 1
Exploring how the Interface Segregation Principle applies SRP to interfaces - making them smaller and more cohesive.
-
Prose in Vim
Useful Vim features for writing prose - sentence motions, spell checking, and display line navigation.
-
The Single Responsibility Principle: Identifying Violators
Techniques for identifying Single Responsibility Principle violations - summaries, method prefixes, and abstraction levels.
-
The Single Responsibility Principle: Overview
Introduction to the Single Responsibility Principle - a class should have only one reason to change.
-
The Three Rules and red/green/refactor
Understanding the difference between Uncle Bob's Three Rules of TDD and the red/green/refactor cycle - they're not the same thing.
-
1 Test, 1 Assertion?
Exploring when to use single versus multiple assertions in tests - being pragmatic about testing stateful behavior.
-
import *
Why wildcard imports are problematic - they hide design flaws and obfuscate module dependencies that could reveal code smells.
-
breaking-down-minimax
Breaking down the minimax algorithm for creating an unbeatable Tic-Tac-Toe computer player by minimizing maximum loss.
-
TDD Patterns: Triangulation
Using triangulation to drive out behavior by adding more assertions to tests, preventing naive implementations from passing.
-
TDD Patterns: Child Test
Exploring the Child Test pattern from Kent Beck - knowing when to back out of a test and write supporting tests first.
-
How Not to Kata: Part 2
Understanding the distinction between rehearsing and practicing katas, and the benefits of preparing for a kata performance.
-
How Not to Kata
Learning the difference between doing a kata once and truly practicing through repetition - the key to unlocking the potential of code katas.
-
Tic-Tac-Toe: The Beginning
Starting my first apprenticeship project: building an unbeatable Tic-Tac-Toe game using TDD and the minimax algorithm.
-
"First Post"
Beginning my apprenticeship journey at 8th Light, documenting the ideas, principles, and techniques I encounter along the way.