The document summarizes the second meeting of a Software Craftsmanship group. The agenda included discussing bad and good code, code smells, tools, and hands-on activities. Examples of code smells like duplicated code, long methods, large classes, and long parameter lists were presented. Attendees participated in demo activities to identify code smells in code samples and refactor code. The goals were to learn how to recognize poor code quality and refactor code to eliminate code smells.

1. Software CraftsmanshipMeeting #2http://www.flickr.com/photos/renfield/17375998/in/set-388814/

2. AgendaBad Code / Good CodeCode SmellsToolsHands OnCode DojoIdentifying Smells *

3. WTF publicstaticbooleanisValidNumber(Integer number) {methodName = "isValidNumber"; Logger logger = LoggingHelper.getLogger(LOGGER);logger.entering (CLASS, methodName); // parse this number. If you get an NFE, then its // not valid, return falsetry {Integer.parseInt(number.toString()); } catch(Exception ex) {logger.fine(methodName + " returns false");logger.fine("Number Format Exception when parsing"); return false; }logger.fine(methodName + " returns true");logger.exiting(CLASS, methodName); return true; }Logging EntryWTF?Logging Exit

4. WTFwhile(true){if(mainType == 7) {subType = 4;break; }if(mainType == 9) {subType = 6;break; }if(mainType == 11) {subType = 9;break; }break;}/*=============checkSizeMake sure the image is a power of 2.=============*/intcheckSize(int x) {if (x == 2 || x == 4 || x == 8 || x == 16 || x == 32 || x == 64 || x == 128 || x == 256 || x == 512)return 1;elsereturn 0;}WTF?WTF?

5. WTFDirectoryInfo dir = new DirectoryInfo(pathToDelete);// subDirsDirectoryInfo[] subDirs = dir.GetDirectories();foreach(DirectoryInfosubDirinsubDirs){ // subSubDirsDirectoryInfo[] subSubDirs = subDir.GetDirectories();foreach(DirectoryInfosubSubDir in subSubDirs) { // subSubSubDirsDirectoryInfo[] subSubSubDirs = subSubDir.GetDirectories();foreach(DirectoryInfosubSubSubDirinsubSubSubDirs) { // subSubSubSubDirsDirectoryInfo[] subSubSubSubDirs = subSubSubDir.GetDirectories();foreach(DirectoryInfosubSubSubSubDirinsubSubSubSubDirs) { // ******************************************** // should be enough; if not, I can add more here // ********************************************WTF?WTF?

6. Code Smellhttp://www.flickr.com/photos/brian-fitzgerald/3334353375/http://www.flickr.com/photos/yomi955/1192827822/Code Smell - In computer programming, code smell is any symptom in the source code of a program that possibly indicates a deeper problemhttp://en.wikipedia.org/wiki/Code_smell

7. Code SmellsDuplicated CodeSame code structure in more than one place:Same expression in two methods of the same classSame expression in two sibling subclassesSame expression in two unrelated classes

8. Code Smells

9. DemoClone Detector

10. Code SmellsLong MethodA good technique is to look for comments. They often signal a semantic distance between the intension of the code and the implementation of the codeThe net effect is that you should be much more aggressive about decomposing methodsThe desired length should be 5-8 lines

11. Code Smells

12. DemoComments, please!

13. Code SmellsLarge ClassMany instance variables indicates that a class tries to do too muchMany instance variables can indicate a duplicate codeToo much code is prime breeding ground for duplicated code, chaos, and death

14. Code Smells

15. DemoHow Many Lines?

16. Code SmellsLong Parameter ListIn the past we passed in as parameters everything needed by a routine. With objects it’s not required; instead enough parameters passed in to the method in order to allow it to get everything rest it needsLong parameter lists are hard to understandLong parameter lists inconsistent and difficult to useLong parameter lists are forever changed as more data is required

17. Code Smells

18. Code SmellsLong Parameter ListAvoid output parameters (ref, out)Avoid boolean argumentsAvoid more than 3 arguments2 is preferable1 is better0 is the bestIntroduce Parameter ObjectRefactoring StepSeparate Query From ModifierRefactoring StepOne return value.

19. DemoTo Query or To Modify?

20. Code SmellsSwitch StatementsThe problem with switch statements is essentially that of duplication i.e. the same switch statement scattered about a program in different placesMost times you see a switch statement you should consider polymorphism

21. Code Smells

22. DemoHow to Process Request

23. Code SmellsSpeculative GeneralityA class that exists to support some future and imaginary feature.“We might need this one day …”If you really do need it later, you can add it easily using Refactoring.It doesn’t mean you don’t need to anticipate requirements and features.

24. Code SmellsCommentsWhen you feel the need to write a comment, first try to refactor the code so that any comment becomes superfluous

25. Code SmellsFeature EnvoyA method that seems more interested in a class other than the one it actually is inData and the behavior that references that data usually change together, but there are exceptions:VisitorStrategy

26. Code Smells

27. Code SmellsMessage ChainsA client asks one object for another object, which the client then asks for yet another object, which the client then asks for yet another another object, and so onCan be seen as a long line of GetThis() methods, or as a sequence of tempsAny change to the intermediate relationships causes the client to have to changeAccount.Owner.OwnerDetails.Address.Zip

28. Hands OnDojoCode Smellshttp://www.flickr.com/photos/renfield/351556388/in/photostream/

29. Roman Numbers: ToString()0NullaNumerals

30. Roman Numbers: ToString()IThe values of each roman letter can be additiveIIThe larger numerals must be placed to the left of the smaller numeralsIIIAt the fourth iteration, a subtractive principle may beemployed, with the base placed before the higher base:IIII or IV The subtracted digit must be at least one tenth of thevalue of the larger numeral. Therefore: 99 isn’t IC butrather XCIX

31. 2nd Meeting of the Software Craftsmanship Grouphttp://www.flickr.com/photos/psd/2086641/