What are the top three components of being a Software Craftsman?

[Melodie Rice]

What are the top three components of being a Software Craftsman?

Thank you!

Melodie Rice

[Junilu Lacar]

I can tell you two things that are mentioned in the book, although not explicitly labeled as "components" of being a Software Craftsman. Sandro mentions them in Appendix A, in the section "Software Craftsman versus Software Developers".

The first is Attitude - to be a craftsman, you need to have a certain attitude towards your work and the level of attention to detail and care you put into it.
The second is Action - obviously, you have to walk the walk, not just talk the talk.

I think the third one for me would be Achievements/Accomplishments - if you never accomplish anything or make anything that's useful to someone besides yourself, then what's the point? I don't make beautiful software just for the sake of it. I want to make beautiful software because it helps make the world better for others who use that software. That's what it's all about for me.

Edit: Actually, that might not be entirely true. To be honest, I have some selfish reasons for wanting to write good code. I know what it's like to work with crappy code. I know what the consequences are of letting code just rot and fester. It's not pretty and it sucks the joy out of development work. So, I have resolved to not put other developers through the kind of hell I have to go through on a regular basis, cleaning up other people's crappy code. If by doing so I can influence a few people and help them see that there's a better way of doing things, then I hope someday to be able to land in a code base where I have a comprehensive set of unit tests to refer to so I can understand the design, good clean code and relevant documentation, and software that works and is a joy to maintain and extend. Until then, I will fight the good fight against nasty code and bad designs.

[Junilu Lacar]

As an example of attitude and action, consider this code from a unit test class:

@Test
public void check_davids_implementation() throws Exception {
    RadixSort radix = new RadixSort();
    List<Integer> unsorted = new ArrayList<>(); 
    addRandom(unsorted, 5, 99999);
    addRandom(unsorted, 5, 9999);
    addRandom(unsorted, 5, 999);
    addRandom(unsorted, 5, 99);
     
    List<Integer> sorted = new ArrayList<>(unsorted);
    Collections.sort(sorted);
    Collections.shuffle(unsorted);
     
    System.out.println("Unsorted:" + unsorted);
     
    List<Integer> result = radix.davidsSort(unsorted);
     
    System.out.println("Expected:" + sorted);
    System.out.println("Result:" + result);
     
    assertEquals(sorted, result);
}
 
private void addRandom(List<Integer> unsorted, int times, int max) {
    for (int i = 0; i < times; i++) {
        unsorted.add(generator.nextInt(max));
    }
}

What would you do if you came across this code? Would you think "Ugh. What a mess!" or would you just buckle down and try to understand what it does? Or would you simply just scan it, run it, and move on?

I normally would not walk past this "broken window" (something discussed in "The Pragmatic Programmer, " another book about craftsmanship) -- BTW, this is some code that I wrote yesterday to test another rancher's solution to a programming problem, hence the name check_davids_implementation.

If this were actual code for work, I would be compelled to refactor it to something like this:

@Test
public void check_davids_implementation() throws Exception {
    RadixSort radix = new RadixSort();
    List<Integer> unsorted = randomTestData();
    List<Integer> expected = sortWithStandardAPI(unsorted);
     
    console("Unsorted:" + unsorted);
     
    List<Integer> result = radix.davidsSort(unsorted);
     
    console("Expected:\t" + expected);
    console("Actual:\t" + result);
     
    assertEquals(expected, result);
}
 
private void console(String s) {
    System.out.println(s);
}

private void addRandom(List<Integer> unsorted, int times, int max) {
    for (int i = 0; i < times; i++) {
        unsorted.add(generator.nextInt(max));
    }
}

private List<Integer> randomTestData() {
    List<Integer> testData = new ArrayList<>(); 

    addRandom(testData, 5, 99999);
    addRandom(testData, 5, 9999);
    addRandom(testData, 5, 999);
    addRandom(testData, 5, 99);

    Collections.shuffle(testData);

    return testData;
}

private List<Integer> sortWithStandardAPI(List<Integer> unsorted) {
    List<Integer> sorted = new ArrayList<>(unsorted);
    Collections.sort(sorted);

    return sorted;
}

That's the kind of attention to detail you'd expect from someone who is really serious about their craft. Sure, it seems almost obsessive, but anything less would just be the work of a POSD (Plain Old Software Developer).

[Sandro Mancuso]

Melodie Rice wrote:
What are the top three components of being a Software Craftsman?

I'm not sure I can list "three components". For me, being a craftsman is a lifestyle. It's not only about code. It's about always striving to do things in a better way. It's the eternal journey to mastery.

Being a craftsman is not about how good you currently are on something or the amount of technical knowledge you have in a certain area. It's about your attitude towards your career. It's about caring about what you do. It's about helping other people to get better. Learning and Sharing. Being a positive influence wherever you go.