Use your type system; write less code

UseYour Type System;
Write Less Code
13th October 2015
@SamirTalwar

It’s got a lot of code.
But a little while ago, I started to think it’s not as good
as I thought when we were ﬁrst getting started.
So I got to work.
Here’s what I found.

Readability
Tell me what’s more readable.

public Stream<Integer> searchForProperties( 
boolean renting, 
int monthlyBudget, 
double latitude, 
double longitude, 
double distanceFromCentre) { ... }
public Stream<PropertyId> abc( 
PurchasingType def, 
Budget ghi, 
Coordinate jkl, 
Radius mno) { ... }
Readability

ﬁrst second
name searchForProperties
buying or
renting?
boolean renting PurchasingType
monthly budget int monthlyBudget Budget
centre
coordinates
double latitude, 
double longitude
Coordinate
maximum
distance
double
distanceFromCentre
Radius
return type Stream<Integer> Stream<PropertyId>
Readability

Readabilityreadable 
/ˈriːdəb(ə)l/ 
adjective
1. able to be read or deciphered; legible. 
“a code which is readable by a computer” 
 
synonyms: 
legible, easy to read, decipherable, easily deciphered,
clear, intelligible, understandable, comprehensible, easy to
understand 
“the inscription is still perfectly readable” 
antonyms: 
illegible, indecipherable 
 
2. easy or enjoyable to read. 
“a marvellously readable book”

Stream<Integer> searchResults = 
searchForProperties( 
true, 500, 51.525094, -0.127305, 2);
Stream<PropertyId> searchResults = 
PropertyType.RENTAL, 
MonthlyBudget.of(500, GBP), 
Coordinate.of(51.525094, -0.127305), 
Radius.of(2, MILES));
Readability

Coordinate.of(51.525094, -0.127305), 
Radius.of(2, MILES));
CircularArea.around(Coordinate.of( 
51.525094, -0.127305)) 
.with(Radius.of(2, MILES)));
Readability

Stream<PropertyId> searchForProperties( 
PurchasingType purchasingType, 
Budget budget, 
Area area) { ... }
SearchQuery<PropertyId> searchForProperties( 
Budget budget, 
Area area) { ... }
Readability

public interface SearchQuery<T> { 
public Stream<T> fetch(); 
 
public T fetchOne(); 
}
Readability

Readability
OK, the inputs make sense. But the output?
Why bother with a PropertyId?

public final class PropertyId { 
private final int value; 
 
public PropertyId(int value) { 
this.value = value; 
} 
 
public SearchQuery<Property> query( 
DatabaseConnection connection) { ... } 
 
public void renderTo(Somewhere else) { ... } 
 
// equals, hashCode and toString 
}
Readability

Readability
What does PropertyId do?
SearchQuery<Property> query 
(DatabaseConnection connection)
void renderTo(Somewhere else)
new PropertyId(int value)
String toString()
boolean equals(Object other) 
 
int hashCode()

Readabilityaddition
multiplication
subtraction
division
modulus
negation
bit manipulation operations such as &, |, ^ and ~
further bit manipulation functionality from java.lang.Integer (I count 9 separate methods)
equality
hashing
comparison with other integers
treatment as an unsigned integer
treatment as a sign (the Integer.signum function returns a value representing negative, positive or zero)
conversion to and from other number types (such as double)
conversion to and from strings in decimal, hexadecimal, octal and binary
all of the other methods on java.lang.Integer
What does int do?

 
} 
 
 
public void renderTo(Somewhere else) { ... } 
 
}
Searchability

Searchability
⇧F6
⌥⇧R
⌃R, ⌃R
F2

 
} 
 
 
public void writeTo(Somewhere else) { ... } 
 
}
Searchability

Searchability
⌥F7
⌃G
⌃K, ⌃T
⇧⌥F7

public final class Templating { 
public void render(PropertyId propertyId) { 
propertyId.writeTo(output); 
} 
 
... 
}
Searchability

public SearchQuery<PropertyId> searchForProperties( 
PurchasingType purchasingType, Budget budget, Area area)
{ 
Area rectangle = area.asRectangle(); 
return connection 
.query(“SELECT * FROM property” 
+ “ WHERE purchasing_type = ?” 
+ “ AND budget <= ?” 
+ “ AND longitude BETWEEN ? AND ?” 
+ “ AND latitude BETWEEN ? AND ?”, 
purchasingType.name(), budget.inGBP(), 
rectangle.minX(), rectangle.maxX(), 
rectangle.minY(), rectangle.maxY()) 
.filter(row -> 
area.contains(row.getDouble(“latitude”), 
row.getDouble(“longitude”))) 
.map(row -> new PropertyId(row.getInt(“id”))); 
}
Flexibility

 
... 
}
Flexibility

Flexibility
But our website was slow, so we decided to switch to
Cassandra.

 
... 
}
private final UUID value; 
private final int humanRepresentation; 
 
... 
}
Flexibility

public SearchQuery<PropertyId> searchForProperties( 
PurchasingType purchasingType, Budget budget, Area area)
{ 
Area rectangle = area.asRectangle(); 
return connection 
.query(select().from(“property”) 
.where(eq(“purchasing_type”, purchasingType.name())) 
.and(lte(“budget”, budget.inGBP())) 
.and(gte(“longitude”, rectangle.minX())) 
.and(lte(“longitude”, rectangle.maxX())) 
.and(gte(“latitude”, rectangle.minY())) 
.and(lte(“latitude”, rectangle.maxY()))) 
.filter(row -> 
area.contains(row.getDouble(“latitude”), 
row.getDouble(“longitude”))) 
.map(row -> new PropertyId( 
row.getUUID(“id”), 
row.getInt(“human_representation”))); 
}
Flexibility

Correctness
In his book, Understanding the Four Rules of Simple
Design, Corey Haines talks about a really important
concept in software design.
He calls things that embody this concept, 
behaviour attractors.

boolean renting, 
double latitude, 
double distanceFromCentre) { 
 
if (distanceFromCentre <= 0) { 
throw new IllegalArgumentException( 
“The distance from centre must be positive.” 
+ “ The value was ” + distanceFromCentre); 
} 
... 
}
Correctness

boolean renting, 
double latitude, 
 
check(“distance from centre”, 
distanceFromCentre, 
is(greaterThan(0))); 
... 
}
Correctness

public final class Radius { 
public static Radius of( 
@NotNull double magnitude, 
@NotNull DistanceUnit unit) { 
 
check(“magnitude”, 
magnitude, is(greaterThan(0))); 
return new Radius(magnitude, unit); 
} 
 
private Radius( 
@NotNull double magnitude, 
@NotNull DistanceUnit unit) { ... } 
 
... 
}
Correctness

Correctness
I haven’t been totally honest with you.
There’s more code than you thought.
Except it’s not really code.

/** 
* Searches for properties in the database 
* matching the specified parameters. 
* 
* @param renting True if renting, false if buying. 
* ... 
* @return A stream of property IDs. 
* @throws DatabaseQueryException if there is a connection error. 
*/ 
boolean renting, 
double latitude, 
 
check(distanceFromCentre, 
is(greaterThan(0))); 
... 
}
Correctness

/** 
* Searches for properties in the database 
* matching the specified parameters. 
* 
* @throws DatabaseQueryException 
* if there is a connection error. 
*/ 
Stream<PropertyId> searchForProperties( 
Budget budget, 
Area area) { ... }
Correctness

/** 
*/ 
public Stream<T> fetch(); 
 
/** 
*/ 
public T fetchOne(); 
}
Correctness

public Stream<T> fetch() 
throws DatabaseQueryException; 
 
public T fetchOne() 
throws DatabaseQueryException; 
}
Correctness

@Path("/properties") 
public final class PropertiesResource { 
private final Template PropertyTemplate = 
Template.inClassPath("/com/buymoarflats/website/property-details.html"); 
 
@GET 
@Path("/{propertyId}") 
public Response propertyDetails(@PathParam("propertyId") int id) { 
try { 
return propertyResponse(new PropertyId(id)); 
} catch (DatabaseQueryException e) { 
return Response.serverError().entity(e).build(); 
} 
} 
 
private Response propertyResponse(PropertyId id) throws DatabaseQueryException { 
Output output = formattedProperty(id); 
if (output == null) { 
return Response.notFound().entity(id).build(); 
} 
return Response.ok(output).build(); 
} 
 
private Output formattedProperty(PropertyId id) throws DatabaseQueryException { 
Property property = retrieveProperty(id); 
if (property == null) { 
return null; 
} 
return PropertyTemplate.format(property); 
} 
 
private Property retrieveProperty(PropertyId id) throws DatabaseQueryException { 
return id.query(connection).fetchOne(); 
} 
}
Correctness

try { 
return propertyResponse(new PropertyId(id)); 
} 
} 
 
private Response propertyResponse(PropertyId id) 
throws DatabaseQueryException { 
Output output = formattedProperty(id); ... 
} 
 
private Output formattedProperty(PropertyId id) 
Property property = retrieveProperty(id); ... 
} 
 
private Property retrieveProperty(PropertyId id) 
}
Correctness

Correctness
To paraphrase Nat Pryce and Steve Freeman:
Your types are trying to tell you something.
You should listen to them.

public Response propertyDetails(@PathParam("propertyId") PropertyId id) { 
try { 
return propertyResponse( 
id, formattedProperty(retrieveProperty(id))); 
} 
} 
 
private Response propertyResponse(PropertyId id, Output output) { 
... 
} 
 
private Output formattedProperty(Property property) { 
... 
} 
 
}
Correctness

@Path("/properties") 
public final class PropertiesResource { 
private final Template PropertyTemplate = 
Template.inClassPath("/com/buymoarflats/website/property-details.html"); 
 
@GET 
try { 
id, formattedProperty(retrieveProperty(id))); 
} 
} 
 
private Response propertyResponse(PropertyId id, Output output) { 
if (output == null) { 
return Response.notFound().entity(id).build(); 
} 
return Response.ok(output).build(); 
} 
 
if (property == null) { 
return null; 
} 
} 
 
} 
}
Correctness

Correctness
Now, what about all that duplication?

Output process(Input thing) { 
if (thing == null) { 
return null; 
} 
// process thing and return 
}
Correctness

return null; 
} else { 
// process thing and return 
} 
}
Correctness

Function<Input, Output> processor = 
value -> { 
// process value and return 
}; 
 
return null; 
} else { 
return processor.apply(thing); 
} 
}
Correctness

Output process( 
Function<Input, Output> processor, 
Input thing) { 
 
return null; 
} else { 
return processor.apply(thing); 
} 
}
Correctness

public final class Optional<T> { 
private final T value; 
 
public <U> Optional<U> map( 
Function<? super T, ? extends U> mapper) { 
if (value == null) { 
return empty(); 
} else { 
return Optional.ofNullable(mapper.apply(value)); 
} 
} 
}
Optional<Output> process( 
Function<Input, Output> processor, 
Optional<Input> thing) { 
 
return thing.map(processor); 
}
Correctness

public Response propertyDetails(@PathParam("propertyId") PropertyId id) { 
try { 
id, retrieveProperty(id).map(this::formattedProperty)); 
} 
} 
 
private Response propertyResponse(PropertyId id, Optional<Output> maybeOutput) { 
return maybeOutput 
.map(output -> Response.ok(output).build()) 
.orElse(Response.notFound().entity(id).build()); 
} 
 
}
private Optional<Property> retrieveProperty(PropertyId id) 
}
Correctness

@GET 
public Response propertyDetails( 
@PathParam("propertyId") PropertyId id) { 
 
try { 
return id.query(connection).fetchOne() 
.map(PropertyTemplate::format) 
.map(Response::ok) 
.orElse(Response.notFound().entity(id)) 
.build(); 
return Response.serverError() 
.entity(e).build(); 
} 
}
Correctness

Efﬁciency
On BuyMoarFlats.com, we let you short-list properties.

Set<ShortListedProperty> shortList = 
connection 
.query(“SELECT * FROM short_list” 
+ “ JOIN property” 
+ “ ON short_list.property_id = property.id” 
+ “ WHERE short_list.user_id = ?”, 
user.id()) 
.map(row -> propertyFrom(row)) 
.fetch() 
.collect(toSet());
Efﬁciency

List<ShortListedProperty> sortedShortList = 
shortList.stream() 
.sorted(comparing(dateTimeAdded)) 
.collect(toList());
Efﬁciency

Map<City, List<ShortListedProperty>> 
shortListsByCity = 
sortedShortList.stream() 
.collect(groupingBy(city));
Efﬁciency

Set<City> cities = shortListByCity.keySet();
Efﬁciency

List<ShortListedProperty> upForAuctionSoon = 
shortListsByCity.values().stream() 
.flatMap(Collection::stream) 
.filter(property -> 
property.isUpForAuctionInLessThan( 
1, WEEK)) 
.collect(toList());
Efﬁciency

Stream<Property> randomPromotedAuction = 
connection 
.query(“SELECT * FROM property” 
+ “ WHERE sale_type = ?” 
+ “ AND promoted = true” 
+ “ LIMIT 1”, 
PropertySaleType.AUCTION.name()) 
.fetch(); 
 
List<Property> highlighted = 
Stream.concat(randomPromotedAuction, 
upForAuctionSoon.stream()) 
.collect(toList());
Efﬁciency

Efﬁciency
And we’ve got more features coming every week!

public final class ShortList { 
Set<ShortListedProperty> shortList; 
List<ShortListedProperty> sortedShortList; 
Map<City, List<ShortListedProperty>> byCity; 
Set<City> cities; 
List<ShortListedProperty> upForAuctionSoon; 
Optional<Property> randomPromotedAuction; 
List<Property> highlighted; 
 
... 
}
Efﬁciency

Efﬁciency
But we process the original list ﬁve times.

Efﬁciency
Here’s the magic bullet.
We don’t need to optimise our algorithms.
The database author already did that.
We just need to write code that does less.

public final class ShortList { 
Map<City, List<ShortListedProperty>> byCity; 
Set<City> cities; 
List<Property> highlighted; 
 
... 
}
Efﬁciency

We tackled ﬁve discrete problems, but the solution was
always the same.
Make a new type.

public class CircularArea implements Area { 
... 
}

public final class Optional<T> { 
... 
}

Quoting @jbrains (who was paraphrasing Kent Beck),
“I deﬁne simple design this way.
A design is simple to the extent that it:
1. Passes its tests
2. Minimizes duplication
3. Maximizes clarity
4. Has fewer elements”
http://www.jbrains.ca/permalink/the-four-elements-of-simple-design

1. Passes its tests
2. Minimizes duplication
3. Maximizes clarity
4. Has fewer elements

Jackpot.
Go wrap some data in types.

talks.samirtalwar.com
Heckling starts now.
13th October 2015
@SamirTalwar

Use your type system; write less code

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Use your type system; write less code

Similar to Use your type system; write less code (20)

Recently uploaded

Recently uploaded (20)

Use your type system; write less code