The Curious Engineer

All blogs / Software / engineering practice

The Programmer's Paradox

theprogrammersparadox.blogspot.com

A blog about software development and programming.

Software / engineering practiceEssays / personal

’10’15’20’25
Posts
562 from 28 Jul 2007 to 29 Oct 2026
Posting
weekly (52 in the last year)
Kind
personal blog
Feed
http://feeds.feedburner.com/TheProgrammersParadox

2026 44

  1. Little Things
  2. Tactics vs Strategy
  3. Synchronization
  4. Preservation
  5. Bloat
  6. Webapps
  7. Oversimplication
  8. Ordering
  9. Yak Shaving
  10. Setbacks
  11. Flow Design
  12. Uncertaincy
  13. Properties
  14. Methodology
  15. Predictions
  16. Hedging
  17. Data Stitching
  18. Language Ideas
  19. The Craft of Programming
  20. Structureless
  21. Software Systems
  22. Round Holes
  23. Versioning
  24. Feedback
  25. Security
  26. Goodness
  27. Shortcuts and Makework
  28. Users
  29. Strange Loops
  30. The Quality Bars
  31. Outlines
  32. Cogtastic
  33. Interviews
  34. Functions
  35. Stress
  36. When the Bubble Bursts
  37. Data Collection
  38. Blockers
  39. Systems Thinking
  40. Reap What You Sow
  41. Dirty Little Secret
  42. This Week's Turbo Encabulator
  43. Against the Grain
  44. New Year

2025 44

  1. A Manifestation of my Understanding
  2. The Value of Data
  3. Expressive Power
  4. Software Failures
  5. Integrations
  6. Unknown unknowns
  7. Intent
  8. The Structure of Data
  9. Fishbowl
  10. Patience
  11. Experimentation
  12. The Value of Thought
  13. Nexus Point
  14. Codebase Organization
  15. Manifestations
  16. Sophistication
  17. Ordering
  18. Bad Engineering
  19. Static vs Dynamic
  20. Encapsulation vs Fragmentation, Again
  21. Determinism
  22. Anything Goes Style
  23. Assumptions
  24. Industrial Strength
  25. Building Things
  26. Brute Force Style
  27. House of Cards Style
  28. Intrinsic Complexity
  29. Habits
  30. Two Passes
  31. Computations
  32. The Easy Tradeoff
  33. Interface Consistency
  34. Reinventing the Wheel
  35. Herding Cats
  36. Development Automation
  37. Concurrency
  38. The Digital Realm
  39. Mastery
  40. Control
  41. Integrated Documentation
  42. Self Describing
  43. Complexity
  44. Data Collection

2024 51

  1. Datasource Precedents
  2. In Full
  3. The Right Thing
  4. Portability Layer
  5. Wobble
  6. Clarity of Expression
  7. The Value of Technology
  8. Full Speed
  9. The Beauty of Technology
  10. Programming
  11. Avoidance
  12. Time
  13. Complexity
  14. Editing Anxieties
  15. Ambiguities
  16. Value
  17. Learning
  18. Navigation
  19. Nailed It
  20. Coding Style
  21. Massively Parallel Computing
  22. Updating Software
  23. Expression
  24. Effective Management
  25. AI
  26. Guessable
  27. Outside
  28. Dirty Writes
  29. Data Modelling
  30. Identitynet
  31. Data Driven Programming
  32. Megafunctions
  33. Iterative Development
  34. Symmetry
  35. The Origin of Data
  36. Optimizations
  37. Scope
  38. Expression
  39. Over Complicated
  40. Mangled Complexity
  41. Software Development Decisions
  42. Ratcheting
  43. Coding
  44. Self-Inflicted Pain
  45. A Rose by Any Other Name
  46. Natural Decompositions
  47. Anti-patterns
  48. Context
  49. Buy vs Build
  50. Lessons Learned
  51. Time vs Risk

2023 52

  1. Identity
  2. Software Knowledge
  3. Fragmentation
  4. Solving Hard Problems
  5. Observable on Steriods
  6. Bottom Up
  7. The Power of Abstractions
  8. Time Ranges
  9. Special Cases
  10. Two Generals
  11. Impermanence
  12. Curiosity
  13. Feedback
  14. Trifecta
  15. Historic Artifacts with Data
  16. Modelling Complex Data
  17. The Groove
  18. Patching is not Programming
  19. Cache Invalidation Problem
  20. Development Workstations
  21. Complexity and Principles
  22. Usablity Tradeoff
  23. Unknowns
  24. Git Outta Here
  25. 10x Developers
  26. Amnesia
  27. Variants
  28. Control
  29. Take the Long way Home
  30. Fix the Real Problem
  31. Clever and Over-engineered
  32. Nothing beats Experience
  33. Documentation as Blueprints
  34. Engineering over Process
  35. Complexity Blowout
  36. Transactional Integrity
  37. Software Development Ethics
  38. Devops
  39. Waterloo Style
  40. Strong Coding Habits
  41. Connectors
  42. Agile, Stand-ups, TDD and Code Reviews
  43. Scaling Methodologies
  44. Refactoring
  45. Expectations
  46. Velimus Insitum Spectare Futurum
  47. Finding Friction
  48. Finding Intrinsic Complexity
  49. Difficult Choices
  50. Once
  51. Software Evolution
  52. Dependencies

2022 37

  1. Et cetera
  2. Split Level
  3. Determinism
  4. Definitions
  5. Problem and Solution Spaces
  6. Orientation
  7. Software Development Power Tools
  8. Identity
  9. Lost
  10. Informality
  11. Follow Suit
  12. Knowable
  13. Bugs
  14. Naming
  15. Operational Issues
  16. Data Engineering
  17. Dynamic Systems
  18. Phone vs Cable
  19. Helpers or Encapsulation
  20. Reinvention
  21. Software Factories
  22. Would you like Fries with that?
  23. End-points and Computations
  24. The Code
  25. Architecture
  26. Basic Rules of Coding
  27. Twisted
  28. Encapsulation vs Fragmentation
  29. Agility
  30. Clarity
  31. Vertical and Horizontal
  32. Functions
  33. Paradigms, Patterns and Idioms
  34. Piecewise Construction
  35. Principals of Software Development
  36. Good vs. Bad
  37. Readability

2021 26

  1. Upside Down
  2. Non-destructive Refactoring
  3. It’s Slow, We Should Rewrite it
  4. Self-describing Names
  5. Idempotent
  6. Time Consuming
  7. Priorities
  8. Managing
  9. Friction
  10. Data Flow
  11. What Should Have Happened ...
  12. Irrational Mappings
  13. System Inventory
  14. Redundancies
  15. Quality Categories
  16. Knowing How Things Work
  17. Gyrations
  18. Multi-tasking
  19. Theory and Practice
  20. Plumbing
  21. Newbie Mistakes
  22. Machinery
  23. Default Requirements
  24. Analysis
  25. Structuring Code
  26. Quality

2020 36

  1. Bugs and Weaknesses
  2. Enhancements
  3. Habits
  4. Keep Your Eye on the Ball
  5. Software Development Workflow
  6. Programming
  7. The Good, the Bad, and the Ugly
  8. Laws of Software Development
  9. Debugging
  10. Defensive Coding: Minimal Code
  11. Defensive Coding: KISS
  12. Integrity and Professionalism
  13. Developer Management
  14. Duality
  15. Puzzles
  16. Defensive Coding: Names and Order
  17. Defensive Coding: Locality
  18. Normalization Revisited
  19. Defensive Coding: Direction
  20. Defensive Coding: Cleanup
  21. Opaque Boxes
  22. Innovation
  23. Defensive Coding
  24. Comments...
  25. Naturally Encapsulated Coding
  26. Common Questions
  27. Disorganization
  28. Basic Expectations
  29. Development and Operations
  30. Bullet Specs
  31. Universal Truth
  32. Organizing Complexity
  33. Testing for Oversimplification
  34. Globals
  35. How to Shoot Yourself in The Foot
  36. Artificial Complexity

2019 7

  1. Development Speed
  2. Bugs as a Reflection of Coding Issues
  3. Breaking it Down
  4. Cooperation, Competition and Control
  5. Software Optimizations
  6. Model-based Systems Design
  7. Implementing Sophistication

2018 2

  1. Scaling Development
  2. The Value of Software

2017 13

  1. Visualizing Code
  2. Immutability
  3. Sophistication
  4. Bombproof Data Entry
  5. Freedom
  6. Efficiency and Quality
  7. Rainy Days
  8. Decisions
  9. Some Rules
  10. Data Modeling
  11. Stress Free Programming
  12. Stores of Value
  13. Navigation

2016 7

  1. Partial Knowledge
  2. Backwards
  3. Meta-methodology
  4. Analysis
  5. Quality
  6. Factual
  7. Thinking Problems

2015 22

  1. Routine Software
  2. Requirements and Specifications
  3. Containers, Collections and Null
  4. Software Engineering
  5. Organization
  6. Abstraction
  7. Data Modelling
  8. Just Managing
  9. Digital Discussions
  10. Intelligence
  11. Privacy
  12. Sweatshops
  13. Encapsulation
  14. Get Serious
  15. Flashlights
  16. Special Case Considered Harmful
  17. Shades of Grey
  18. Types of Data
  19. The Data
  20. Static vs. Dynamic
  21. Scale and Organization
  22. Reactive vs. Proactive

2014 23

  1. Thinking About What You Don't Know
  2. Definitions
  3. Bad Process
  4. Error Handling
  5. The Necessity of Consistency
  6. The Depth of Knowledge
  7. Estimation
  8. Tuesday
  9. Mathematics and Software Development
  10. Software Development
  11. Technology
  12. Recycling
  13. Requirements
  14. Predictions
  15. Architecture
  16. What and How
  17. Collective Protection
  18. Unwinding Complexity
  19. Levels of Code
  20. Principles
  21. Rights of the Modern Age
  22. Controlling Complexity
  23. The Quality of Code

2013 12

  1. Out of Control
  2. Form Factor Free
  3. Time and Shortcuts
  4. Relationships
  5. Process
  6. Death by Code
  7. Monitoring
  8. Organization
  9. Deep Underground
  10. Systemic Breakdown
  11. Quality and Scale
  12. Potential

2012 26

  1. State of the New Machines
  2. Theory and Practice
  3. Best Practices
  4. Work Smarter...Not Harder
  5. Setting Up Development
  6. Programming Style
  7. Knowledge Bases
  8. Serializations
  9. Cooperation vs. Competition
  10. Smart
  11. Architecture
  12. Five Years
  13. What is Complexity?
  14. Globals and State
  15. Micromanaging Software Development
  16. Another Stinkin’ Analogy
  17. How do you design software?
  18. New Layout
  19. Bag O'Tricks
  20. Structured Questioning
  21. Organization
  22. Lost in Thought
  23. Working Environments
  24. Complexity and Decomposition
  25. Software Clearing Houses
  26. The First Principle of Software

2011 34

  1. An Informal Ramble
  2. The Engineering of Software
  3. Getting to the Truth
  4. Problems and Solutions
  5. The Big Idea
  6. Thinking About It
  7. Problem Solving
  8. Layering, Architecture and Convergence
  9. Contradictions
  10. Know your Limits
  11. Styles, Standards and Conventions
  12. Prototype or System
  13. The Customer is Always Right
  14. Roles and Responsibilities
  15. Following the Path
  16. The Boundary Between
  17. Focus
  18. Deep Refactoring II
  19. Deep Refactoring
  20. Software Virgin
  21. Risk and Inexperience
  22. Acting on My Behalf
  23. Getting Things Done
  24. Resilience
  25. Industrial Strength Requirements
  26. How Many Programmers are there?
  27. Economy of Expression
  28. How to Waste Your Time While Programming
  29. Greed and the Ownership of Data
  30. Patents and Routine Engineering
  31. Failure
  32. One Eye Open
  33. Big Data from Small Source Code
  34. Top-down and Bottom-up

2010 30

  1. Facts, Opinion and Context
  2. The Effects of Computers
  3. Random Acts of Madness
  4. The Myth of Code Reuse
  5. Reducing Test Effort
  6. Code Validation
  7. Software that Annoys Me
  8. Rock Hopping
  9. Construction Metaphors
  10. Micro vs. Macro
  11. Intellectual Leverage
  12. Design by Committee
  13. Syntactic Noise
  14. Paragraphs and Functions
  15. Feedback
  16. Truth and its Consequences
  17. The Different Phases of Development
  18. The Personality Effect
  19. Why
  20. Insane Complexity
  21. Data Vaults
  22. Development Ideas
  23. Future Considerations
  24. The Edit Loop
  25. The Value Proposition
  26. 97 Things Every Programmer Should Know
  27. Data, Data, Data
  28. Big and small experiences
  29. Privacy Concerns
  30. The Generation of Complexity

2009 30

  1. Quickie: Let it be Free
  2. Transformers
  3. Spaghetti Code
  4. Prime Perspectives
  5. Programming Structure
  6. Fundamental Laws
  7. The Value of Code
  8. Not Interested
  9. Bxml
  10. Tightly Bound
  11. Halting a Problem
  12. Dynamic Ramblings
  13. Bugs and Misfortune
  14. In Our Dependence
  15. Programming Knowledge
  16. Programming is Simple!
  17. Chinese Plumbers
  18. Architectural Ramblings
  19. Driven by Work
  20. The End of Coding as We Know It
  21. My PC Crashed (Again)
  22. About, Next and Garbage
  23. Faux Stylin'
  24. In Framing Work
  25. 97 Things Every Software Architect Should Know
  26. Building in Quality
  27. Maneuverability and Sales
  28. In Expression
  29. Good Thing Going
  30. Digging into Data

2008 37

  1. My Stack Overfloweth
  2. The Best of The Programmer's Paradox
  3. The Lines of Progress
  4. Code Normal Forms
  5. Revisiting the Structure of Elegance
  6. Less Than Best Practices
  7. The Structure of Elegance
  8. The Necessity of Determinism
  9. 7 Fabulous Ways to Great Programming
  10. A Dependency Too Far
  11. Some Lessons from Experience
  12. 97 Things -- The Strength of Communication
  13. Social Disorder Revisited
  14. Social Disorder
  15. Pattern for Pattern
  16. The Art of Our Understanding
  17. Meta Blogging Madness or Mania
  18. Resources for Software Development
  19. Readability
  20. Structuring Noun & Verb Data
  21. The Essence of Software
  22. Jurassic Office Park
  23. Hard Code'n
  24. Software Blueprints
  25. Creatively Speaking
  26. The Essence of Analysis
  27. Controlling Development Chaos
  28. Testing for Battleships
  29. The Science of Information
  30. In Object-Orientation
  31. Testing Perspectives
  32. Fundamental Coding Issues
  33. The Power of Expression
  34. The Age of Clarity
  35. Essential Development Problems
  36. The Construction of Primitives
  37. Abstraction and Encapsulation

2007 29

  1. A Silly Little Storm
  2. The Nature of Simple
  3. Fixing your Development Environment
  4. Pedantically Speaking
  5. From Our Inner Depths
  6. Mind the Gap
  7. Acts of Madness
  8. Is Open Source hurting Consulting?
  9. The Art of Encapsulation
  10. Repeated Expressions
  11. Goto The Next Goto
  12. First Principles and Beyond
  13. Wasted my Time
  14. Lost in Processing
  15. Architectural Blueprints
  16. Turbulent Waters
  17. Paddling Upstream
  18. Patterns of Misdirection
  19. Underlying Issues
  20. 4 Easy Ways to Design Better Software
  21. Is Open Source hurting Computer Science?
  22. Few Technological Conveniences
  23. Driving Design
  24. In the Still of the Night
  25. Return to the Dreaded M...
  26. With Cat-like Dignity and Grace...
  27. As Written
  28. Two Great Problems
  29. Altered States