Monday, October 16, 2023

Good talks/podcasts (Oct 2023 I)

These are the best podcasts/talks I've seen/listened to recently:
  • The Elegant Solution: Toyota's Formula for Mastering Innovation (Matthew May) [Lean, Lean Manufacturing] [Duration: 1:15:00] Interesting presentation on how Toyota incorporates continuous learning and innovation into the company's daily operations.
  • "Simple Made Easy" (12-minute redux) by Rich Hickey (2011) (Rich Hickey) [Architecture, Inspirational, Scalability, Software Design] [Duration: 0:12:00] (⭐⭐⭐⭐⭐) This is a 12-minute redux of the 1-hour talk by Rich Hickey, for really impatient people. Original:
  • Infrastructure as actual Code • YOW! 2022 (Gregor Hohpe) [Architecture, Architecture patterns, Infrastructure, Serverless] [Duration: 0:59:00] This talk shares recent trends in infrastructure automation, debunks some common misconceptions, and shows you how you can combine AWS’ serverless ecosystem and AWS CDK to rethink application development, deployment, and integration.
  • Lean Turned Up to 10 (Chris Lucian, Austin Chadwick) [Lean Software Development, MobProgramming, Technical Practices] [Duration: 0:58:00] (⭐⭐⭐⭐⭐) Chris and Austin explain why mob programming could be a way to implement lean software development in current teams. Very interesting.
  • LKUK13: Cynefin in Action - Liz Keogh (Liz Keogh) [Culture, Engineering Culture, Inspirational] [Duration: 0:51:00] In this talk Liz explains the Cynefin framework and other concepts as Real Options, Deliberate Discovery, Feature Injection, etc.
Reminder: All of these talks are interesting, even just listening to them.


Sunday, October 15, 2023

The Art of Small Steps in Software Development: A Lean Vision

Have you ever played Tetris? If so, you know that every decision, every piece, and every move counts. The same applies to software development. Every choice, every line of code, and every interaction influences the final outcome. This post will explore how Lean software development and the "safe small steps" approach can simplify complexity and create efficient systems.

Small Steps: The Simplicity of Tetris

Just like in Tetris, where we choose where to place small pieces to complete lines, in software development, we continuously make decisions about how to build our product. These decisions, when made in small increments, allow us to:

  • Iterate quickly: Fixes and adjustments are simpler.
  • Reduce risks: We limit potential errors at each stage.
  • Understand better: Each step is understood and analyzed more clearly.

Principles of Lean Software Development

Based on Lean philosophy, Lean software development focuses on maximizing customer value and minimizing waste. Some of the key principles include:

  • Reduce waste: Eliminate the unnecessary and focus on the essentials. Every step must add value or increase the internal or external quality of the product.
  • Decide as late as possible: Be flexible and adapt to changes. See Lean Software development: The art of postponing decisions.
  • Deliver quickly: Allows for feedback and adaptation to customer needs.
  • Build with integrity and quality: Ensures a reliable and long-lasting product. This is key to maintaining speed sustainably over time.
  • Proactively simplify: Avoid unnecessary complexity and keep the system manageable. Simplification also adds value, protecting the current value and avoiding future costs.

Small Steps: The Simplicity and Continuity of Tetris

Tetris, one of the most iconic video games in history, presents us with a continuous and infinite challenge. In it, pieces of different shapes fall from the top of the screen at an increasing speed. Our task is to accommodate these pieces efficiently at the bottom, trying to fit them so that they complete horizontal lines. Completing these lines eliminates them, granting us points and, more importantly, space to continue playing.

In Tetris, value accumulates by adding points, piece by piece, line by line. However, the real challenge and essence of the game lie in balancing the accumulation of that value (points) while managing increasing complexity (the accumulated pieces). If we allow the pieces to pile up and reach the top of the screen, we lose the game.

Similarly, in software development, we continuously decide how to build our product. Like in Tetris, we must accumulate value (features and characteristics) while managing and keeping complexity at bay. These decisions, when made in small increments or "steps," allow us to:

  • Iterate quickly: Fixes and adjustments are simpler.
  • Reduce risks: We limit potential errors at each stage.
  • Understand better: Each step is understood and analyzed more clearly.

Tetris / Larger vs Smaller pieces

Just like playing with large pieces in Tetris, working with large steps in software development makes the game/work much more difficult and stressful.


Software development is not just about writing code; it's about making informed and continuous decisions to create valuable products. Just like in Tetris, every piece, every step, counts. Embrace the Lean philosophy and focus on safe small steps to simplify, adapt, and deliver with quality.

If this approach has intrigued you, I invite you to delve deeper into Lean software development and experience how it can transform your development process.


Friday, October 06, 2023

DevOpsDays Madrid: The Complexity Trap Reevaluating our incentives

 I've had the pleasure of being invited to give a Keynote at the DevOpsDays Madrid event.

I'm leaving the slides and some interesting related references here.

The Complexity Trap Reevaluating our incentives

Video (Spanish):

Youtube video

Thanks to Autentia for the recording of the session.
You can watch the sessions of the conference and other conferences on their channel 


Original document

Related Quotes:

  • "Art is the elimination of the unnecessary." Pablo Picasso
  • "Code is cost, and production code is by far the higher cost.  If you can write more support code (tests, automation, developer tooling) in order to write less&better production code more smoothly, Win!" @jessitron
  • "Code is liability. To build something is to be responsible for its existence, forever. Write more software only as a last resort." @mipsytipsy
  • "Complexity is what makes software hard to change. That, and duplication." Ralph Johnson
  • "Fools ignore complexity. Pragmatists suffer it. Some can avoid it. Geniuses remove it." - Alan Perlis
  • "If you don’t actively fight for simplicity in software, complexity will win…and it will suck." Henrik Joreteg
  • "irreversibility was one of the prime drivers of complexity" Enrico Zaninotto
  • "Keep it simple, make it valuable, build it piece by piece" Ron Jeffries
  • "My position is that code, pretty much exclusively, is cost. It’s all liability. The asset is what it does. So, if I can get simpler code that does the same thing, I’ll take the simpler code. If I can have no code and get the same capability, I’ll take no code. No code is better than some code, some code is better than lots of code!" Dan North @tastapod
  • "Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better." Edsger W. Dijkstra
  • "Simplicity is the ultimate sophistication"  Leonardo da Vinci
  • "Simplicity--the art of maximizing the amount  of work not done--is essential." Principles behind the Agile Manifesto
  • "Software maintenance is not "keep it working like before." It is "keep being useful in a changing world"" Jessitron
  • "The art of programming is the art of organizing complexity." Edsger W. Dijkstra
  • "The biggest cause of failure in software-intensive systems is not technical failure; it’s building the wrong thing." Mary Poppendieck
  • "The faster you build crap the more crap you get" Jeff Patton
  • "The old truths: Keep it simple, Make it small, Make it correct, Fight complexity" Joe Armstrong

Related / References:

  • The art of destroying software (Greg Young)
  • Simplicidad para desarrolladores (Spanish)
  • Basal Cost of Software
  • 8 lines of code
  • Complexity Is Outside the Code 
  • Simplicity, The Way of the Unusual Architect 
  • Simple-Made-Easy/