Comments on: Bending Java: More readable code with methods that do nothing?

By: Dobes

Dobes — Mon, 23 Jun 2008 08:02:01 +0000

I like Nick’s solution, I don’t think that renaming is that big of a deal in practice, even if it looks bad in theory.

I couldn’t help but wonder whether Java 5 annotations would work for this somehow.

By: stephan

stephan — Mon, 12 May 2008 05:49:44 +0000

@Andrea: As written before, the comments don’t work with refactorings (yes I know some IDEs do refactor comments but this is very error prone). Changing the methods when changing the types probably is a good idea, because changing one information without the other makes code unreadable over time.

By: Andrea Francia

Andrea Francia — Sun, 11 May 2008 22:33:18 +0000

I don’t see the convenience of introducing methods (that should be maintained later) to achieve something that can be already achieved using the standard documentation tool of every language: comments.

Customer c = new Customer( “John” /*firstname*/,
“Smith” /*lastname*/,
87 /*age*/);

Introducing a method called firstname() or lastname() is so necessary?
When the type or the name of a property change you have to change also the method.

And what about the method name resolution? Using your method technique you have to import static all the methods do use it.

However I see a good thing of this idea. It can stimulate thinking about Java syntax and possible improvements to it.

By: stephan

stephan — Sun, 11 May 2008 18:21:12 +0000

@Jan, raveman: Yes, see my post about fluent interface builders

@James: Yes, I like named parmeters

@Nick: Yes, this does work for small parameter lists, but breaks down for longer ones. It also doesn’t help with larger code bases where developers start to rename parameters. The difference between renaming String name and name() is that the first renaming is only local, the second is global and does therefor scale much better.

@Uri: Hmm, need to try that.

@Casper: Looks nice too.

I was using names parameters the first time during the 80 I guess with a programming language called E on the Amiga (or was it the 90s?). I like the idea since then, but Java regretfully doesn’t have them.

By: James Hughes

James Hughes — Sun, 11 May 2008 08:45:06 +0000

Ammmm The naming convention is very similar to how Groovy would do - named arguments.

def cust = new Customer(name:”James”)

By: Uri

Uri — Sun, 11 May 2008 04:06:19 +0000

I dig your intent but I don’t really like the solutions (for all obvious reasons that were already mentioned). I think the problem lies in Java itself in the lack of named arguments for methods. how about having the following more generic solution (I’m still not a big fan of it though…)

class Utils {
$(”name”, name)
public static T $(String name, T value) {
return value;
}
}

then:

Customer c = new Customer($(”name”, “Stephan”));

I guess it’s the closest you can get to: new Customer (name: “Stephan”);

cheers,
Uri

By: Nick Westgate

Nick Westgate — Sun, 11 May 2008 01:26:59 +0000

While it’s always good to try new ways of improving readability, there are “better” (at least less controversial) existing solutions to the trivial example you provide - e.g. raveman’s above.

Here’s another traditional solution that doesn’t need methods:

String name = “Stephan”;
Customer customer = new Customer(name);

Some parameters might be deserving of an object type, like the OrderId in your previous post on this topic, but you should carefully consider how methods will look _when they are actually used_.

For instance, the following is common, and makes the method signature less relevant since context is provided in other ways.

Customer customer = new Customer(htmlForm.name);

Cheers,
Nick.

By: Casper Bang

Casper Bang — Sun, 11 May 2008 01:03:56 +0000

Points for originality but…. that’s about it. How about we get object initializes, like in C#?

Customer customer = new Customer(){ name=”Stephan”, salary=65.000};

…then again, a little easier to do in C# than Java since it has native properties rather than mundane manual set/get mechanics.

By: jan

jan — Sat, 10 May 2008 22:53:30 +0000

Having classes like Name, PhoneNumber… can really become maintainability nightmare. But I also like to increase readability of the code. My favorite would be:

Customer customer = Customer.name(”Stephan”).phoneNumber(”12345″)

Customer customer = Customer.withName(”Stephan”).withPhoneNumber(”12345″)

By: raveman

raveman — Sat, 10 May 2008 21:00:37 +0000

i dont like that idea, how about only non-arg contructors and builder pattern ?
Customer customer = new Customer().setName(”Stephan”);

i think it looks better