Slides from talk given at SDEC2013.

1. Stop That! Questioning Dogmatic Programming
or Things I Wish My Coworkers Would Stop Doing
Doug Hiebert
Thank you to our Sponsors

2. About Me
Doug Sparling / Doug Hiebert
Software Dev - Protegra
Twitter: @doughiebert
Email: doug.hiebert@protegra.com

3. Dogmatism
noun
1. The tendency to lay down principles as undeniably true,
without consideration of evidence or the opinions of
others.

4. Programming Dogma
•
•
•
•
“A, B and C are best practices”
“X considered harmful”
“Y is evil”
“language/technology/tool Z is the best”

5. Programming Dogma
“Break any of these rules sooner than [code] anything
outright barbarous.”
-- George Orwell, "Politics and the English Language,"
1946

6. Good Programming Dogma
•
•
•
•
•
Format your code
Have a coding standard
Prefer simplicity
Refactor continuously
Use modular design

7. Bad Programming Dogma
•
•
•
•
Comment your code
Don’t waste cycles
Decide with conditionals
Handle all errors

8. Comment Your Code
/**
* @return Always returns true.
*/
public boolean isAvailable() {
return false; // FIXME: temporary testing
}

9. Comment Your Code
• Communicates programmer intent
- The “why” to the code’s “what”
• Explains tricky/clever code
• Explains how to use APIs/interfaces

10. Communicating Intent
for (Person person : people) {
if (person.getAge() >= 65) {
sendCheque(person.getAddress());
}
}

11. Communicating Intent
for (Person person : people) {
// send cheque to persons old enough
// to qualify for pension payout
if (person.getAge() >= 65) {
sendCheque(person.getAddress());
}
}

13. Communicating Intent
for (Person person : people) {
// send cheque to persons old enough
// to qualify for pension payout
if (person.getAge() >= 65 ||
person.getYearsOfService() > 30) {
sendCheque(person.getAddress());
}
}

14. Communicating Intent
•
•
•
•
Skipped by refactoring tools
Not essential for program function
Poorly written or misleading
Some people ignore them (like me!)

15. Comment-Eliminating Refactorings
• Comment as Method
• Comment as Local Variable
• Comment as Constant

16. Comment as Method
for (Person person : people) {
if (oldEnoughForPensionPayout(person)) {
sendCheque(person.getAddress());
}
}
...
boolean oldEnoughForPensionPayout(Person p) {
return p.getAge() >= 65;
}

17. Comment as Local Variable
for (Person person : people) {
boolean oldEnoughForPensionPayout =
person.getAge() >= 65;
if (oldEnoughForPensionPayout) {
sendCheque(person.getAddress());
}
}

18. Comment as Constant
private static final int
MIN_AGE_FOR_PENSION_PAYOUT = 65;
for (Person person : people) {
if (person.getAge() >=
MIN_AGE_FOR_PENSION_PAYOUT) {
sendCheque(person.getAddress());
}
}

19. Explain Tricky/Clever Code
# calculates the average
a = vals.inject(0.0) { |s, v| s + v } /
vals.size

21. Explain Tricky/Clever Code
sum = vals.inject(0.0) { |total, val|
total + val }
average = sum / vals.size

22. Explain APIs/Interfaces
• Code intended for re-use by others
• Library of classes, methods, utilities, etc.
• RDoc, Javadoc, etc.

23. Explain APIs/Interfaces
interface PersonRepository {
Set<Person> findPeople(String text);
...
}

24. Explain APIs/Interfaces
/**
* <p><b>Usage:</b></p>
*
* <pre>
* PersonRepository exampleRepo = makeRepository(bobJones, joelStevens,
shirleySmith);
*
* List<Person> persons = exampleRepo.findPeople("jo");
*
* persons.get(0); // bobJones
* persons.get(1); // joelStevens
* </pre>
*
* @author Doug
*/
interface PersonRepository {
List<Person> findPeople(String text);
...
}

26. Explain APIs/Interfaces
@Test
public void testFindPeopleByFirstAndLastName() {
Person bobJones = testPerson("Bob Jones");
Person joelStevens = testPerson("Joel Stevens");
Person shirleySmith = testPerson("Shirley Smith");
PersonRepository exampleRepo = makeRepository(
bobJones, joelStevens, shirleySmith);
List<Person> persons = exampleRepo.findPeople("jo");
assertEquals(bobJones, persons.get(0));
assertEquals(joelStevens, persons.get(1);
}

27. Documentation
• Comments are a type of documentation
• Good examples of documentation:
- User’s guide/manual
- Architecture diagrams
- Decision log

28. A Final Note About Comments
/**
* The person's name.
*/
private String name;
...
/**
* Returns the person's name.
*
* @return the person’s name
*/
public String getName() {
return name;
}

31. Don’t Waste Cycles
• Improve UI response
• Speed up long-running batch jobs
• Satisfaction of “eliminating waste”

32. Don’t Waste Cycles
void calcAverages1(List<Person> people) {
double averageAge = averageAge(people);
double averageHeight = averageHeight(people);
...
}
double averageAge(List<Person> people) {
long ageSum = 0;
for (Person person : people) {
ageSum += person.getAge();
}
return (double) (ageSum / people.size());
}
double averageHeight(List<Person> people) { /* as above */ }

33. Don’t Waste Cycles
void calcAverages2() {
long ageSum = 0;
long heightSum = 0;
for (Person person : people) {
ageSum += person.getAge();
heightSum += person.getHeight();
}
double averageAge = ageSum / people.size();
double averageHeight = heightSum / people.size();
...
}

35. Don’t Waste Cycles
• Microbenchmark parameters:
- 1,000,000 people
- 1500 iteration warm-up
- 10 runs (averaged)
• calcAverages1: 7237μs
• calcAverages2: 3640μs
• Roughly 100% slower (as expected)
• Only 3.6ms (imperceptible)

36. Don’t Waste Cycles
“Premature optimization is the root of all evil”
-- Donald Knuth

38. Decide with Conditionals
• if, unless, else, ?:, etc.
- Implement conditional logic
- Handle errors
- Null checking
• switch, case, etc.
- exhaustively handle different cases

39. Decide with Conditionals
public List<String> parseNames(String names) {
if (names == null) {
return null;
}
return Arrays.asList(names.split(","));
}
void readNames() {
String line = System.console().readLine();
List<String> names = parseNames(line);
if (names != null) {
for (String name : names) {
// ...
}
}
}

41. Null Object Pattern
public List<String> parseNames2(String names) {
if (names == null) {
return Collections.emptyList();
}
return Arrays.asList(names.split(","));
}

42. Null Object Pattern
public class CommandLookup {
public Command findCommand(String command) {
if (validCommand(command)) {
// ...
} else {
return new NullCommand();
}
}
public class NullCommand implements Command {
public void execute() {
// do nothing
}
}
}

43. Option Type
Option<String> aString = Option.some("string");
Option<String> noString = Option.none();
F<...> length = new F<String, Integer>() {
public Integer f(String str) {
return str.length();
}
};
aString.map(length).orSome(42); // 6
noString.map(length).orSome(0); // 0

44. Option<T> Type
public List<String> parseNames3(
Option<String> names) {
return Arrays.asList(
names.orSome("").split(","));
}

45. Decide with Conditionals
interface SensorPackage {
int getTemperature();
int getHumidity();
int getPressure();
}

46. Decide with Conditionals
enum SensorType {
TEMPERATURE, HUMIDITY, PRESSURE;
}

47. Decide with Conditionals
public int readSensor(SensorType sensorType) {
switch (sensorType) {
case TEMPERATURE:
return weatherSensor.getTemperature();
case HUMIDITY:
return weatherSensor.getHumidity();
case PRESSURE:
return weatherSensor.getPressure();
default:
throw new IllegalArgumentException("...");
}
}

49. Replace Conditional with
Polymorphism
enum SensorType {
abstract int getReading(SensorPackage sensors);
TEMPERATURE {
public int
return
}
}, HUMIDITY {
public int
return
}
}, PRESSURE {
...
};
}
getReading(SensorPackage sensors) {
sensors.getTemperature();
getReading(SensorPackage sensors) {
sensors.getHumidity();

50. Replace Conditional with
Polymorphism
abstract class SensorWrapper {
abstract int getReading();
static class TemperatureSensorWrapper extends SensorWrapper {
private SensorPackage sensorPackage;
public TemperatureSensorWrapper(SensorPackage sensorPackage) { /*...*/ }
int getReading() { return sensorPackage.getTemperature(); }
}
static SensorWrapper create(
SensorType sensorType, SensorPackage sensorPackage) {
switch (sensorType) {
case TEMPERATURE: return new TemperatureSensorWrapper(sensorPackage);
case ...
default: throw new IllegalArgumentException("...");
}
}
}

51. Decide with Conditionals
if (province == Province.MB
&& productType == ProductType.WIDGET) {
tax = 0.05; // no PST on widgets in MB
} else if (province == Province.MB) {
tax = 0.13;
} else if (province == Province.AB) {
tax = 0.05;
} else if (...) {
// and so on
} else if (...) {

52. Replace Conditional with Map
static {
taxByProvince.put(Province.MB, 0.13);
taxByProvince.put(Province.AB, 0.05);
// ... etc.
}
if (province == Province.MB
&& productType == ProductType.WIDGET) {
tax = 0.05; // no PST on widgets in MB
} else {
tax = taxByProvince.get(province);
}

53. Anti-If Campaign

54. Anti-If Campaign
•
•
•
•
Cyclomatic complexity
if-else chains invite trouble
Polymorphism more appropriate
Testing is tedious

56. Handle All Errors
private Map<String, File> imagesMap = ...
...
Image image = null;
File imageFile = imagesMap.get("expectedImage");
try {
if (imageFile != null) {
image = ImageIO.read(imageFile);
}
} catch (IOException e) {
// image could not be read
}
if (image != null) {
// do something with image
}

58. Handle All Errors
High
Level
main(...)
{
try {
...
} catch {
...
}
}
...
...
...
Low
Level
throw e;
...
...
...
...

59. Wrap Exception
static class ImageUtil {
static BufferedImage read(File imageFile) {
try {
return ImageIO.read(imageFile);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

60. Wrap Checked Exception
private Map<String, File> imagesMap = ...
...
File imageFile =
imagesMap.get("expectedImage");
Image image = null;
if (imageFile != null) {
image = ImageUtil.read(imageFile);
}
// do something with image

61. Push Error Handling Down
public class ImageKeyNotFoundException extends
RuntimeException { ... }
public File getImageFile(String imageKey) {
if (imagesMap.get(imageKey) == null) {
throw new ImageKeyNotFoundException(
"image key not found: " + imageKey);
}
return imagesMap.get(imageKey);
}

62. Push Error Handling Down
File imageFile = getImageFile("expectedImage");
Image image = ImageUtil.read(imageFile);
// do something with image

63. In Conclusion

64. In Conclusion
“The only „best practice‟ you should be using all
the time is „Use Your Brain‟”
-- Steven Robbins, StackExchange

65. More Information / Next Steps
• Clean Code (free!)
• Pragmatic Programmer (classic!)
• Code Complete 2nd Edition (thick?)

66. Thank You!
@doughiebert
doug.hiebert@protegra.com
Thank you to our Sponsors