Go back

The Principles of Software Craftsmanship - Building Excellence in Code

Published:

Software Craftsmanship is more than just writing code.

It’s a mindset, a philosophy, and a commitment to excellence that transforms developers into true artisans of their craft. In an industry where “just make it work” often takes precedence, Software Craftsmanship reminds us that how we build software matters as much as what we build.

This movement, crystallized in the Software Craftsmanship Manifesto, builds upon the Agile principles while emphasizing the human aspect of software development and the pursuit of mastery.

Table of Contents

Open Table of Contents

The Software Craftsmanship Manifesto

In 2009, a group of software developers created the Software Craftsmanship Manifesto as an extension to the Agile Manifesto. It states:

As aspiring Software Craftsmen we are raising the bar of professional software development by practicing it and helping others learn the craft. Through this work we have come to value:

  • Not only working software, but also well-crafted software
  • Not only responding to change, but also steadily adding value
  • Not only individuals and interactions, but also a community of professionals
  • Not only customer collaboration, but also productive partnerships

That is, in pursuit of the items on the left we have found the items on the right to be indispensable.

Core Principles of Software Craftsmanship

1. Well-Crafted Software Over Working Software

While working software is essential, craftsmen understand that how software works is equally important. Well-crafted software is:

// Instead of this:
public void ProcessOrder(int id, string status, double amount)
{
    // Complex logic mixed with data access
    var order = db.Orders.Find(id);
    if (status == "approved" && amount > 0)
    {
        order.Status = status;
        order.Amount = amount;
        db.SaveChanges();
        SendEmail(order.CustomerEmail, "Order processed");
    }
}

// Craftsmen write this:
public class OrderProcessor
{
    private readonly IOrderRepository _orderRepository;
    private readonly IEmailService _emailService;
    private readonly IOrderValidator _validator;

    public async Task<OrderResult> ProcessOrderAsync(ProcessOrderCommand command)
    {
        var validationResult = await _validator.ValidateAsync(command);
        if (!validationResult.IsValid)
            return OrderResult.Failure(validationResult.Errors);

        var order = await _orderRepository.GetByIdAsync(command.OrderId);
        if (order == null)
            return OrderResult.NotFound();

        order.Process(command.Status, command.Amount);
        
        await _orderRepository.SaveAsync(order);
        await _emailService.SendOrderProcessedNotificationAsync(order);
        
        return OrderResult.Success(order);
    }
}

2. Steadily Adding Value

Software Craftsmen don’t just respond to change, they anticipate it and build systems that can evolve gracefully. This involves:

3. Community of Professionals

Craftsmanship thrives in a community where knowledge is shared freely and standards are maintained collectively:

4. Productive Partnerships

Beyond customer collaboration, craftsmen build partnerships that create mutual value:

Practices That Define Software Craftsmanship

Test-Driven Development (TDD)

TDD is not just about testing, it’s about design. By writing tests first, craftsmen:

// Example TDD cycle for a validation service
[Test]
public void Should_Return_Invalid_When_Email_Is_Empty()
{
    // Arrange
    var validator = new EmailValidator();
    var email = "";
    
    // Act
    var result = validator.Validate(email);
    
    // Assert
    Assert.IsFalse(result.IsValid);
    Assert.Contains("Email is required", result.Errors);
}

Clean Code Principles

Craftsmen follow Robert C. Martin’s Clean Code principles:

Continuous Learning

The craft demands constant improvement:

Design Patterns and Architecture

Understanding when and how to apply:

The Craftsman’s Mindset

Pride in Work

Craftsmen take personal responsibility for the quality of their work. They:

Continuous Improvement

The Japanese concept of Kaizen (continuous improvement) is central to craftsmanship:

Teaching and Learning

Craftsmen understand that teaching is one of the best ways to learn:

Benefits of Software Craftsmanship

For Developers

For Organizations

For Customers

Common Misconceptions

”Craftsmanship Slows Down Delivery”

Reality: While craftsmanship may slow initial delivery slightly, it dramatically speeds up long-term development by reducing technical debt and making changes easier.

”It’s Just About Perfect Code”

Reality: Craftsmanship is about appropriate quality for the context. Sometimes “good enough” is the right choice, but that choice should be conscious and deliberate.

”Only Senior Developers Can Be Craftsmen”

Reality: Craftsmanship is a mindset that can be adopted at any experience level. Junior developers who embrace these principles often grow faster than those who don’t.

Building a Craftsmanship Culture

Start with Yourself

Team Practices

Organizational Support

Measuring Craftsmanship

While craftsmanship can seem subjective, there are measurable indicators:

Code Quality Metrics

Team Metrics

The Future of Software Craftsmanship

As software becomes increasingly central to business and society, the principles of craftsmanship become more important:

Getting Started

If you’re inspired to embrace Software Craftsmanship:

  1. Read: Start with “Clean Code” by Robert C. Martin and “The Software Craftsman” by Sandro Mancuso.
  2. Practice: Try coding katas and practice TDD.
  3. Connect: Join local user groups and online communities.
  4. Contribute: Participate in open source projects.
  5. Teach: Share what you learn with others.

Conclusion

Software Craftsmanship is not about perfection, it’s about caring. It’s about taking pride in your work, continuously improving your skills, and building software that makes a positive impact on the world.

In an industry that often prioritizes speed over quality, craftsmen remind us that the two are not mutually exclusive. By building well-crafted software, we create systems that are not only functional today but will continue to serve users effectively long into the future.

The journey of craftsmanship is never complete. There’s always more to learn, better ways to solve problems, and new challenges to tackle. But that’s what makes it exciting and that’s what makes it a craft worth pursuing.

The only way to make the deadline (the only way to go fast) is to keep the code as clean as possible at all times. — Robert C. Martin

As software continues to shape our world, the principles of Software Craftsmanship become not just professional aspirations but ethical imperatives. We owe it to our users, our colleagues, and ourselves to treat software development as the craft it truly is.

Share this post on:
Share this post via WhatsApp Share this post on Facebook Share this post on X Share this post via Telegram Share this post on Pinterest Share this post via email
Previous Post
KISS
Next Post
Orchard community member