Stop that!

Stop That! Questioning Dogmatic Programming
or Things I Wish My Coworkers Would Stop Doing

Doug Hiebert

Thank you to our Sponsors

About Me

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

Dogmatism

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

Programming Dogma

•
•
•
•

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

Programming Dogma

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

Good Programming Dogma

•
•
•
•
•

Format your code
Have a coding standard
Prefer simplicity
Refactor continuously
Use modular design

Bad Programming Dogma

•
•
•
•

Comment your code
Don’t waste cycles
Decide with conditionals
Handle all errors

Comment Your Code

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

Comment Your Code

• Communicates programmer intent
- The “why” to the code’s “what”

• Explains tricky/clever code
• Explains how to use APIs/interfaces

Communicating Intent

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


// send cheque to persons old enough
// to qualify for pension payout
if (person.getAge() >= 65) {
}
}


// send cheque to persons old enough
// to qualify for pension payout
if (person.getAge() >= 65 ||
person.getYearsOfService() > 30) {
}
}


•
•
•
•

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

Comment-Eliminating Refactorings

• Comment as Method
• Comment as Local Variable
• Comment as Constant

Comment as Method

if (oldEnoughForPensionPayout(person)) {
}
}
...
boolean oldEnoughForPensionPayout(Person p) {
return p.getAge() >= 65;
}

Comment as Local Variable

boolean oldEnoughForPensionPayout =
person.getAge() >= 65;

if (oldEnoughForPensionPayout) {
}
}

Comment as Constant

private static final int
MIN_AGE_FOR_PENSION_PAYOUT = 65;
if (person.getAge() >=
MIN_AGE_FOR_PENSION_PAYOUT) {
}
}

Explain Tricky/Clever Code

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

Explain Tricky/Clever Code

sum = vals.inject(0.0) { |total, val|
total + val }
average = sum / vals.size

Explain APIs/Interfaces

• Code intended for re-use by others
• Library of classes, methods, utilities, etc.
• RDoc, Javadoc, etc.


interface PersonRepository {
Set<Person> findPeople(String text);
...
}


/**
* <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);
...
}


@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);
}

Documentation

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

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;
}

Don’t Waste Cycles

• Improve UI response
• Speed up long-running batch jobs
• Satisfaction of “eliminating waste”

void calcAverages1(List<Person> people) {
double averageAge = averageAge(people);
double averageHeight = averageHeight(people);
...
}
double averageAge(List<Person> people) {
long ageSum = 0;
ageSum += person.getAge();
}
return (double) (ageSum / people.size());
}
double averageHeight(List<Person> people) { /* as above */ }


void calcAverages2() {
long ageSum = 0;
long heightSum = 0;
ageSum += person.getAge();
heightSum += person.getHeight();
}
double averageAge = ageSum / people.size();
double averageHeight = heightSum / people.size();
...
}


• 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)


“Premature optimization is the root of all evil”
-- Donald Knuth

Decide with Conditionals

• if, unless, else, ?:, etc.
- Implement conditional logic
- Handle errors
- Null checking

• switch, case, etc.
- exhaustively handle different cases


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) {
// ...
}
}
}

Null Object Pattern

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

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
}
}
}

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

Option<T> Type

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


interface SensorPackage {
int getTemperature();
int getHumidity();
int getPressure();
}


enum SensorType {
TEMPERATURE, HUMIDITY, PRESSURE;
}


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("...");
}
}

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();

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("...");
}
}
}


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 (...) {

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);
}

Anti-If Campaign

•
•
•
•

Cyclomatic complexity
if-else chains invite trouble
Polymorphism more appropriate
Testing is tedious

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
}

Handle All Errors

High
Level
main(...)
{
try {
...
} catch {
...
}
}

...
...

...

Low
Level
throw e;

...
...

...

...

Wrap Exception

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

Wrap Checked Exception

private Map<String, File> imagesMap = ...
...
File imageFile =
imagesMap.get("expectedImage");
Image image = null;
if (imageFile != null) {
image = ImageUtil.read(imageFile);
}

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);
}

Push Error Handling Down

File imageFile = getImageFile("expectedImage");
Image image = ImageUtil.read(imageFile);

In Conclusion

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

More Information / Next Steps

• Clean Code (free!)
• Pragmatic Programmer (classic!)
• Code Complete 2nd Edition (thick?)

Thank You!
@doughiebert
doug.hiebert@protegra.com

Thank you to our Sponsors

Stop that!

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Stop that! (20)

Recently uploaded (20)

Stop that!

Editor's Notes