Posts on For my friendgineers

follow: @[email protected]

Posts

Indirection Vs. Abstraction

Testing Is More Than Preventing Breakage

Writing Legacy Code

Who Do You Love?

Practice Makes Perfect?

The Messy Middle

Speed Vs. Quality

Culture: Not Just For Yogurt

Docs First And The Definition Of Done

Superpowers And Optionality

Coding Genies and Code Review

Who Are You Writing To Anyway?

AI Isn’t The Answer

But The Requirements Just Changed

New Code Vs. More Code

Listen to Your Data

What Is Performance Anyway?

Licensed Engineers

Engineers Estimate

Slow is Smooth, Smooth is Fast

Government Digital Services

Best Simple System For Now

Respect The Problem

Dijkstra On Bugs

Emergency Procedures

Careers are Non-Linear

People Over Process

The Power Of Examples

Biases: The Tyranny Of Or

Simple or Easy?

Governing the Commons

More Error Types

Strong Opinions, Loosely Held - Part 2

Comments Are A Smell

Diffusion Of Responsibility

Code Coverage Is Not Enough

The Finish Line Is Just Another Milestone

Home Ownership and Software Updates

Verification First Development

Safety Nets and Guardrails

With Apologies to Uncle Bob

Testing Schedules

Test Classification

That's The Way It Is

The Power Of No

What Are You Waiting For?

You ARE Allowed To Think Before You Type

10 Commandments of Code Review

Review Your Own Code Review

The Tao Of Pooh

Primitive Obsession and Boolean Blindness

Deploying vs. Releasing

Adding Estimates

You Broke What?

The Dude Abides

Skill Vs. Experience

Doing It Well And Truly

Strong opinions, Loosely Held

Break It Down, Even At Small Scale

Radiating Information

Three More Tells

Games And Agency

Lead With the Why, Not the Way

How Buildings Learn

Seeing Like a State

Code Coverage Is NOT useless

Fly Like An Eagle

Milestones Vs. Steppingstones

Complexity And Congitive Load

Monolith Is A Deployment Strategy, Not An Architecture

What You Do Next

What Are You Testing? II

Release Stabilization

Average Practice

Green Fields And Platforms

High Quality Quality

A Problem Vs. The Problem

All Models Are Wrong, But Some Are Useful

Mea Culpa, Mea Maxima Culpa

Permission, Approval, and Feedback

Any fool can write code the computer understands.

Enter The Conversation

Let Me Tell You What I Want

The Audience Is Listening

Incident Response

Engineering Project Risks

E_INSUFFICIENT_CONTEXT

Don't Be Too DRY

Lies, Damn Lies, And Statistics

Autonomy, Alignment, Purpose, and Urgency

The Immutable Past

The Law Of Instruments

Effective Software Engineers

Breaker Breaker Rubber Duck

Forward Compatability

Another Year In Review

Happy Winter Solstice

What Are You Testing?

The More Things Change

Omission vs Commission

More Broken Windows

Readability vs Idioms

The Developer's Journey

One Thing At A Time

What's an Internal Customer?

WIP and Queuing Theory

Built-In Functionality

Consensus vs. Consent

Hey, That's Pretty Clever

Thinking Rocks, Magic, Intent, and TDD

Something Smells ... Primitive

What Is Technical Debt Anyway?

Starting vs. Finishing

What happens when you can't even Tidy First?

Customers vs. Partners

Best Practices and Cargo Cults

Applesauce, Names, and Refactoring

This Is The Way

TDD Anti-patterns

Monitoring vs. Observability

Design Is Iterative

Continuous Delivery

Lint Filters And Testing

Measuring and Managing

Software Development Is A Social Activity

Where do defects come from?

A little housekeeping

Careers Pt 3 - Visualizing Progressions

Action vs. Reaction

Story Splitting

Careers Pt 2 – Breaking Down Scope

Scheduling Time For Maintenance

Error Based Development

The Importance Of (down) Time

Careers Pt 1 - Levels

Faster or Slower?

Planning vs Scheduling

Do You See What I See?

Don't just take notes

Hangers and Optimization

Loops and Ratios

Weird Person #2 or First Joiner?

Remediation Surprise

Raspberry vs. Strawberry Jam

Planning and Time Sinks

Are Your KRs Really Tasks?

Are we there yet?

Chesterton's Fence

Reading Roadmaps

More Perspective

Write Your Unit Tests FIRST

Sooner, not Faster

Decisions 2 (if ... elseif ... elseif ... elseif ...)

Is That a Choice or a Decision

Roller Coasters

Getting Feedback

Back It Up There

Language Matters

Constraints and Creativity

OODA and Systems Thinking

Scrape To Taste

Walking Through The Code

Ignorance As A Service

Plans and Planning

Continuous Education

The Tyranny of Or

Prioritization vs. Categorization

Problem Solving

Experience -> Expertise -> Wisdom

Is That An Error?

Engineering Excellence

Context Matters

Architecture Isn't Everything

Architecture vs. Engineering

Mutators and Accessors

Another 4 Questions

Autonomy != Anarchy

Inspect And Adapt

Keeping Your Balance

Testing And Failure

Global Data(base)

Lone Wolf - Hard Nope

Design By Example

Design By Counter-Example

Complex Vs. Complicated

More Than Cruft

Blink Estimation

Tacit Knowledge

Multiple Projects

Things We Know (or think we know)

Proverbially Speaking

When You Have A Hammer

Empirical Software Engineering

Rice and Garlic

Pointers and Errors

Best Practices?

Leading Vs. Trailing

Flow vs. Utilization

While You're In There ...

Additive Vs. Subtractive

Monolith to Microservice

Technical Debt and Agility

Not Just About Crows

Managing Expectations

Lessons From Buckaroo Banzai

Tell Me About A Time When ...

Artificial Stupidity

Single Responsibility Principle

A Question Of Balance

Experimental Results

Lumpers and Splitters

Functional Options

A 'Just' Culture

Optimizing Tests

Discoverability vs. Findability

I've got you covered

Ch-ch-ch-ch-changes

Strict Product Liability

Charting A Path

Precision vs. Accuracy

Poor Man’s Polymorphism

The Scouting Rule

Moving Day, Part 2

Moving Day, Part 1

Discoverability

Adapters, Facades, and Decorators - Oh My

Big Bang Theory

Another Year In Review

Unhappy Customers

Java Isn't Dying

This Would Never Occur To Me

Long Live The CLI

Another 'Just No.'

Real World Patterns

Don't Cross The Streams

Forward Looking

Is 2020 Over Yet?

Owning Your Code

List Comprehension

Outputs vs. Outcomes

Input Validation

Abstractions vs. Interfaces

Decisions, Decisions, Decisions

Implicit vs. Explicit

Hofstadter’s Law

Feedback Please

Thinking Like An Engineer

Ubiquitous Language

Just One More Thing

A Little Architecture

Thesaurus In Use

Commits vs. PRs

To Float Or Not To Float

Your Personal Board

Stories vs. Tasks

A Fiddler On The Roof

Silos vs. Ownership

Agile, 3X, And 4X

Now You Have Two Problems

It's All Around Scope

Git Bisect and Fruit

Interviewing Up

How Big Is That File Anyway?

Excuses, Excuses

Visualizing Code

Multiple Oopsies

What Would You Say... Ya Do Here?

Github And VSCode

To Rewrite Or To Not Rewrite

In Defense Of Agile

Dependency Injection - NOT

Ideas In The Shower

What I'm NOT Doing

Planting A Tree

Situational Awareness

DDD and Microservices

C Shell, Z Shell ...

Hello. Who Are You?

A Scrolling We Will Go

Data, Information, Knowledge, And Wisdom

Don't Always Minimize WIP

Natural Science

Why Are We Doing This

Unintended Consequences

Target Fixation

Inconsistent Consistencies

Vorlons vs. Shadows

Under Construction

One Step At A Time

Inheriting Code

How Severe Is Severe

What's Old Is New Again

Getting Started

Know Your Tools

Why Are An Elephant's Ears So Big?

Crawl, Walk, Run

Eventual Consistency

Abstract vs Interface

Toward A Better PM

Avoiding The Wat

6 Stages Of Debugging

Just Keep Learning

In Defense Of Laziness

Solving Problem Solving

Velocity Is Internal

Everything Can't Be P1

Swallowing The Fish

Pictures Or It Didn't Happen

Cost Of Control

The Art Of Computer Programming

Scale Out, Not Up

IP Tables To The Rescue

How Much Config Is Enough?

Your Bug, Your Customer's Feature

Star Wars Security

What's In A URI?

Else, Switch, And Map

Fear, Courage, and Professionalism

Real Engineering

Murder Mystery Theater - Acting All Roles

Test It Again Sam

Rubber Ducky, You're The One

Remote Extreme Programming

Bob The Builder

Alles Ist In Ordnung

Time For A Walk

Staying In Sync

Sharding Shouldn't Be Hard

To Test Or Not To Test

Go Big, Go Blue

Concurrency And Parallelism

Overcommunicating

Shiny Happy People

Keeping It Clean

Naming Is Still Hard

Intro To Architecture

Write It Down 2

Dates Are Hard Too

For Want Of A Nail

Generally Speaking

Gazinta's and Gazouta's

Cycles Of History

Architect's Newsletter

Incompatible Markdown

Scope Of Influence

Breaking New Ground

Improve The Daily Work

Dev Ops Book Club

Good Fences Make Good Neighbors

The More Things Change

FI/RI, Flag, Merge, Rebase, Trunk

Architecture vs Design

Engineer vs Technician

Innovative Data Transfer

GeoStatisticians vs Default Values

Owning Your Comments

Managing Your Inbox

From BeyondCorp to BeyondProd

Technical Debt And Inflation

Panzer Is NOT German For Tank

Quality Is Job #1

Mini-Maxing Your Java

Shift-Left Is Silly

The Wisdom Of James Mickens

Hofstadter's Law

Surprise And Delight

Always Learning

Compatibility Mode

Blameless Post-Incident-Review

Counting From Zero

APIs Are For Life

The Paper Of Record

The Year In Review

Programming In The Dark

Lessons From Ancient Rome

That's The British Spelling Of ...

Distributed System Superpowers

How Do I Use This Thing?

What's Your Charter

I'll Tell You Later

You Are Not Paid To Write Code

Kilobytes, Megabytes, Gigabytes and Copy-Pasta

Cautionary Tales

Kissenger, Schmidt, and Huttenlocher, and AI

Engineering Principles

PM Is More Than Provider Of Meals

Imposter Syndrome, Dunning–Kruger, or Just Do It

Hello vs. NoHello

Asking For Help

Talking To Customers

What Are You Reading?

Software As A Service

GOLANG Oddities

The Gift Of Feedback

Language Security

SLOs, SLIs, SLAs

One On One Meetings

Writing It Down

Pattern Matching

In The Beginning Was The Command Line

Monoliths vs Microservices

Software Architecture

Following The Vision

Architecture is just software design at scale

You Get What You Inspect, Not What You Expect

Gosling On Open Source

Strlen Is Surprisingly Hard

Work/Life Balance

Design Paradigms

Campus Recruiting

What's In A Name?

Asking Good Questions

Lego Design Sprints

Things You Should Never Do

Python Vs. Go Vs. Rust

Building And Scaling A High Performing Culture

Metaprogramming

Beyond Accidental Architecture

Won't You Be My Neighbor

Interface Driven

Imperative vs. Declarative Programming

Worse is Better

Errors Vs. Exceptions

Bounded Chocolate Contexts

Limiting Cognitive Load

Who Does Architecture

Learning From Others

Linux Containers

Obscuring Complexity

The Old New Thing

Correctness Vs. Change