My blog is relocating to http://andypalmer.com
If you are currently subscribed directly to this blog, please update your feed url to http://feeds.feedburner.com/andypalmer/blog
I have let the aggregators know the new feed, but it may take some time for this to filter through. Articles will be cross posted for a short changeover period.
See you all at the new place
Friday, 24 October 2008
Saturday, 6 September 2008
(I can't get no) Satisfaction
I can't get no satisfaction, I can't get no satisfaction
'Cause I try and I try and I try and I try
(I Can't Get No) Satisfaction - The Rolling Stones
Checked vs. Unchecked Exceptions
It's a controversial subject; searching Google for checked versus unchecked exceptions reveals a lot of heated discussions both for and against Checked Exceptions.
Charles Lowell has a particularly succinct (and possibly NSFW) view
My view is similar. I can almost see a situation where I would like to ensure that exceptions are dealt with in a certain way, but it doesn't quite reach as far as using checked exceptions.
Noisy IDEs
I think my issue is largely to do with the way that the IDEs (and compilers) deal with checked exceptions.
In Eclipse, if a method throws a checked exception, then auto-fix suggests two options; "Surround with try/catch" and "Add throws declaration to method"
I particularly have a problem with the second one. The further you get away from the source of the exception, the less likely you are to deal with it in a useful way. Not dealing with the exception is a reasonable option, but why does everyone in the call chain need to know about an exception that someone in the lower levels didn't care enough about to handle?
Using unchecked exceptions gives us the choice to handle or propagate the exception, without polluting the higher levels with knowledge of unhandled exceptions.
The default Eclipse template for try / catch is to catch the exception and print the stack trace. This isn't really handling the exception, it's ignoring it (even if we've logged it). There is no way to know if this is an acceptable default without understanding the underlying code. Unfortunately, if we are leaving it as the default we probably don't understand the underlying code (yet).
An alternative to Checked Exceptions
One of the nice things about checked exceptions is that they let you know the types of exception you can get. You get the IDE auto-completion and compiler checking.
A checked exception is essentially saying, "You might get this exception, and I insist that you deal with it in the way that you feel is most appropriate"
How can we continue to do this, and at the same time prevent boiler-plate or unnecessary pollution?
Something that I'm thinking about (but haven't had the need to implement yet), is the concept of an ExceptionHandler class. This is an ideal place for Java Generics to come into play.
For example:
public void someCodeThatMayThrowAFileNotFoundException(String fileName, ExceptionHandler<FileNotFoundException> exceptionHandler) {
try {
open(fileName); // throws FileNotFoundException
}
catch (FileNotFoundException e) {
exceptionHandler.handleException(e);
}
}
By coding in this way, we can provide sensible default actions, such as:
// The Generic stuff has not been checked and is for illustration purposes.
// Let me know if I need to correct it :-)
public class PropagatingExceptionHandler extends ExceptionHandler<T extends Exception> {
public void handleException(T exception) {
throw(exception);
}
}
public class LogAndIgnoreExceptionHandler extends ExceptionHandler<T extends Exception> {
public void handleException(T exception) {
exception.printStackTrace(); // or log4j equivalent
}
}
This reduces the try / catch noise, gives us the compiler checking and type completion, and explicitly details the strategy that we are using for handling the exceptions for this part of code.
I'm open to someone showing me a really good use of checked exceptions, but for the time being, I won't be using them.
Saturday, 30 August 2008
What should my code tell me?
When I'm reading code, there are a number of things that make my job much easier.
The most important (in my opinion) is good naming, but how can we choose suitable names?
This is the pattern that I am starting to see (and recommend), and I think it is pretty effective.
If we think of the code as a medium of communication, what questions should the code be able to answer?
What are we trying to achieve?
The method name should be a summary of what we are trying to achieve. For example,
It is (hopefully) clear from the method name what will happen when we call it, and what we need to pass in in order for the code to work.
How do we do this?
The body of the method should be the steps needed to achieve what it is we said we would do in the method name. The steps should be at the same level of abstraction. (See Composed Method)
Who is doing the work?
In the example above, by naming the receiver of the messages after the actor who is likely to perform these steps, it helps focus the mind, and can help with appropriate method naming. For example, we can ask ourselves "What does theUser need to do next?"
Why are we doing this?
At one time or another, you will probably come across a comment like this:
This kind of comment is irrelevant at best, it is telling us what the next line is doing. If the methods are well named, or the code is idiomatic, this is unnecessary. One negative consequence may be a kind of "comment blindness" where your mind filters the majority of comments as "noise".
A better use of comments is to explain why we are doing things in a certain way, especially if it seems unusual. Martin Fowler briefly mentions this in the "Code Smells" chapter in Refactoring.
An example of this type of comment is shown below. This represents a hard-won piece of knowledge, and will hopefully prevent a well-meaning programmer from replacing the code with the
JavaDoc can also be used to tell your users why they might need to pay special attention. If the code is well named, you are unlikely to need JavaDoc for all classes.
Here are some examples of where you might like to use JavaDoc:
This is still a work in progress, but the results that I have seen so far have been encouraging. Please let me know in the comments if you have any suggestions for refinements or improvements.
The most important (in my opinion) is good naming, but how can we choose suitable names?
This is the pattern that I am starting to see (and recommend), and I think it is pretty effective.
What? How? Who? Why?
If we think of the code as a medium of communication, what questions should the code be able to answer?
What are we trying to achieve?
The method name should be a summary of what we are trying to achieve. For example,
public void selectTheCustomerNamed(String customerName) {...}
It is (hopefully) clear from the method name what will happen when we call it, and what we need to pass in in order for the code to work.
How do we do this?
The body of the method should be the steps needed to achieve what it is we said we would do in the method name. The steps should be at the same level of abstraction. (See Composed Method)
public void selectTheCustomerNamed(String customerName) {
theUser.clicksOn(Application.SEARCH_BUTTON);
theUser.types(customerName,into(SearchPage.CUSTOMER_NAME));
theUser.clicks(SearchPage.BEGIN_SEARCH);
theUser.clicks(ResultsPage.FIRST_RESULT);
}
Who is doing the work?
In the example above, by naming the receiver of the messages after the actor who is likely to perform these steps, it helps focus the mind, and can help with appropriate method naming. For example, we can ask ourselves "What does theUser need to do next?"
Why are we doing this?
At one time or another, you will probably come across a comment like this:
// Add one to foo
foo++;
This kind of comment is irrelevant at best, it is telling us what the next line is doing. If the methods are well named, or the code is idiomatic, this is unnecessary. One negative consequence may be a kind of "comment blindness" where your mind filters the majority of comments as "noise".
A better use of comments is to explain why we are doing things in a certain way, especially if it seems unusual. Martin Fowler briefly mentions this in the "Code Smells" chapter in Refactoring.
An example of this type of comment is shown below. This represents a hard-won piece of knowledge, and will hopefully prevent a well-meaning programmer from replacing the code with the
getFooByQuery
variant without checking the caching behaviour.
// We query the id first before trying to retrieve the object, because if we try to
// retrieve the object directly (with getFooByQuery), it always bypasses
// the cache (see @link{...})
Integer fooId = findFooIdByQuery(query);
return getFooById(fooId);
JavaDoc can also be used to tell your users why they might need to pay special attention. If the code is well named, you are unlikely to need JavaDoc for all classes.
Here are some examples of where you might like to use JavaDoc:
- If you have a number of pluggable modules, why would you want to use this module
- Reasons why a user might want to provide their own implementation of this class
- Reasons why this code throws exceptions, and why a user might want to handle them
This is still a work in progress, but the results that I have seen so far have been encouraging. Please let me know in the comments if you have any suggestions for refinements or improvements.
Monday, 25 August 2008
Well, how did I get here?
And you may find yourself living in a shotgun shack
And you may find yourself in another part of the world
And you may find yourself behind the wheel of a large automobile
And you may find yourself in a beautiful house, with a beautiful wife
And you may ask yourself, "Well… how did I get here?"
Once in a Lifetime - Talking Heads
Logging a Stack Trace in log4j
A while ago, I was trying to replace a number of hard coded strings with an appropriate Enum. Unfortunately, the design of the code I was working on meant that it was difficult to find all the possible values for the strings.
I decided that the behaviour that I wanted was:
- If the string method was called with a new value, log that value, so that I can make a decision about whether I wish to add it to the Enum
- If the string method was called with a value that matched a value in the Enum, I wanted a stack trace, so I could replace that call with the appropriate Enum call
The code I ended up with was something like this:
public void doSomething(String theDestination) {
if(weKnowAbout(theDestination)) {
logger.debug("doSomething called with a known destination of " + theDestination, new Throwable());
}
else {
logger.debug("doSomething called with unknown destination of " + theDestination);
}
doWhatWeNeedToDoWith(theDestination);
}
Passing the
new Throwable()
into log4j creates a stack trace in the log output. I've found a number of places that tell you how to do this (now that I know how to do it), but it took me quite a bit of searching when I was first looking.
Monday, 11 August 2008
Sunday, 10 August 2008
Returning 'null' Considered Dishonest
Background
Antony Marcano and I have just started running a coding design workshop. Most of the audience are new to coding and we are trying to focus on good habits that are applicable across all programming languages.
In our first session, we created a vending machine. By the end of 90 minutes, it was able to dispense a drink as long as it had sufficient money and stock available.
One of the questions that we asked was "What do we do when the customer has not inserted enough money and we press the button for the drink?"
Some of the people who had some programming background said "Return null", which is what brings us to this post.
Good Citizen
In the wiki for the PicoContainer project, there is a page titled "Good Citizen", which details a number of good practices that all Java classes would benefit from trying to adhere to.
The practices make a lot of sense when you think about them, but they aren't really explained. I'm going to try and address that issue as we cover them in the workshop.
The practice that we are looking at today is "Never expect or return null", with a dash of "Fail Fast" for flavour.
What's so bad about null?
In the Java world, when we declare a method signature, we specify a return type. In the case of our vending machine we had:
public Drink giveMeADrink() {...}
By declaring that the return type is
Drink
, we are signing up to return something that "is-a" drink.We could also return
null
, which is a nothing value. We could use this to represent that you did not get a drink.The client code may look something like this:
myVendingMachine.giveMeADrink().downInOne();
If we return
null
, this code will fail with a NullPointerException
. Not particularly useful, but at least we are using the result straight away. The problems become much worse if we store the returned Drink
for use later.When we said we will always return a
Drink
, we lied.Programming Defensively
The sample client code above makes the assumption that the result of
giveMeADrink
will be a Drink
. Given that we've actually signed up to that contract, that doesn't seem to be unreasonable. But now the client code is broken and they have an angry customer, they are going to have to work around the issue. It would probably look like this:
Drink myDrink = myVendingMachine.giveMeADrink();
if(myDrink != null) {
myDrink.downInOne();
}
This code is actually saying "I've asked you to give me a drink, but I don't trust you, so I will check first".
Why isn't this working? An Exceptional Approach
If we rely on our client to check that they received a valid result, we lose out on an opportunity to let the client know why the call was unsuccessful.
In the Programming Defensively example, we can recover from being returned a
null
, but we don't know why it was null
. Was it because we hadn't inserted the money? Was it because the machine was out of stock? Was it because the stars were out of alignment?Do we handle the scenarios differently? If we haven't inserted enough money, that's something we can deal with, but if the machine is empty, we need to look for another machine.
What if our code looked like this?
public Drink giveMeADrink() {
if(weDontHaveEnoughMoney()) {throw new NotEnoughMoneyException();}
if(weDontHaveEnoughStock()) {throw new DrinkOutOfStockException();}
return new Drink();
}
What we have said is "We will always give you a drink or tell you why we couldn't"
Now when we attempt to call
giveMeADrink
, it lets us know straight away if it can't proceed. It also gives us a good indication of why it is having problems.The client code calls:
myVendingMachine.giveMeADrink().downInOne();
and gets told "Sorry, I'd give you a drink, but you didn't insert enough money".
Our code is being honest, polite and giving the client an opportunity to remedy the situation. The customer is still angry, but now he's angry with himself for not putting in enough money.
In Summary
- Programming defensively is programming distrustfully
- Returning null is dishonest. It requires others to check that we've upheld our side of the bargain
- Throwing a meaningful exception allows us to let the caller know why their call did not succeed
Thursday, 22 May 2008
Singletons
I've been playing about with a code base that has a large number of singletons, for what appears to be no apparent reason.
Something about singletons doesn't sit quite right with me, but in the most part, if they're not misbehaving, I'll probably leave them be.
The thing that bothers me a lot more though, is the fact that everyone else is forced to know about your singleton-ness..
*shivers*
If you have to store global state, it would be nice if we could hide that from the clients. Why do we have a single instance with instance variables accessed through a static getInstance method, when we could hide (ooh, encapsulation) the implementation behind multiple instances with private static variables?
By using instance methods, we also get all the interface / testing / mocking goodness.
OK, I'm rambling... am I missing something? (please rant below)
Something about singletons doesn't sit quite right with me, but in the most part, if they're not misbehaving, I'll probably leave them be.
The thing that bothers me a lot more though, is the fact that everyone else is forced to know about your singleton-ness..
ImASingleton.getInstance().doSomething();
*shivers*
If you have to store global state, it would be nice if we could hide that from the clients. Why do we have a single instance with instance variables accessed through a static getInstance method, when we could hide (ooh, encapsulation) the implementation behind multiple instances with private static variables?
By using instance methods, we also get all the interface / testing / mocking goodness.
new ImASingletonButYouCantTell().doSomething();
OK, I'm rambling... am I missing something? (please rant below)
Subscribe to:
Posts (Atom)