1. Effective Groovy
Hamlet D'Arcy
Canoo Engineering AG
@HamletDRC
www.canoo.com

2. Agenda
Effective Java Reconsidered
Effective Groovy
www.canoo.com

3. Groovy & Grails
Java
Rich Business Applications
Usability
Refactoring

4. @HamletDRC
http://hamletdarcy.blogspot.com
http://www.manning.com/koenig2/
Groovy, CodeNarc, JConch Committer
GPars, Griffon, Gradle, etc. Contributor
GroovyMag, NFJS magazine author
JetBrains Academy Member
www.canoo.com

5. Effective Groovy
www.canoo.com

6. Effective Groovy
www.canoo.com

7. Effective Java #2
Consider a builder when faced with
many constructor parameters
www.canoo.com

8. Person p = new Person(1, "David", "Villa");
www.canoo.com

9. Person p = new Person(1, "David", "Villa");
Person p = new PersonBuilder().
withID(1).
withFirstName("David").
withLastName("Villa").
build();
www.canoo.com

10. public class PersonBuilder {
private String firstName
private String lastName
private Integer id
public PersonBuilder withID(int id) {
this.id = id; return this;
}
public PersonBuilder withFirstName(String firstName) {
this.firstName = firstName; return this;
}
public PersonBuilder withLastName(String lastName) {
this.lastName = lastName; return this;
}
public Person build() {
return new Person(id, firstName, lastName);
}
}
www.canoo.com

11. def p = new Person(
id: 1,
firstName: 'David',
lastName: 'Villa'
)
www.canoo.com

12. def p = new Person().with {
id = 1
firstName = 'David'
lastName = 'Villa'
delegate
}
www.canoo.com

13. Effective Java #3
Enforce the singleton property
with a private constructor
www.canoo.com

14. @Singleton
class Zeus {
}
www.canoo.com

15. Effective Java #5
Avoid creating unnecessary objects
www.canoo.com

16. assert 12345G instanceof BigInteger
assert 123.45G instanceof BigDecimal
www.canoo.com

17. assert 12345G instanceof BigInteger
assert 123.45G instanceof BigDecimal
assert [] instanceof ArrayList
assert [:] instanceof LinkedHashMap
assert ([] as Set) instanceof HashSet
assert ([] as Stack) instanceof Stack
www.canoo.com

18. assert 12345G instanceof BigInteger
assert 123.45G instanceof BigDecimal
assert [] instanceof ArrayList
assert [:] instanceof LinkedHashMap
assert ([] as Set) instanceof HashSet
assert ([] as Stack) instanceof Stack
CaseInsensitiveList list = [] as CaseInsensitiveList
assert list instanceof CaseInsensitiveList
www.canoo.com

19. Effective Java #7
Avoid Finalizers
www.canoo.com

20. Effective Java #7
Avoid Finalizers
www.canoo.com

21. Effective Java #8
Obey the general contract
when overriding equals
www.canoo.com

22. @EqualsAndHashCode
class Person {
String firstName
String lastName
int id
}
www.canoo.com

23. Effective Java #9
Always override hashCode
when your override equals
www.canoo.com

24. Effective Java #9
Always override hashCode
when your override equals
www.canoo.com

25. Effective Java #10
Always override toString
www.canoo.com

26. @ToString
class Person {
String firstName
String lastName
int id
}
www.canoo.com

27. Effective Java #12
Consider implementing Comparable
www.canoo.com

28. def p1 = new Person(
id: 1, firstName: 'Hamlet', lastName: "D'Arcy"
)
def p2 = new Person(
id: 2, firstName: 'Bro', lastName: "D'Arcy"
)
assert p1 > p2
assert p2 < p1
assert (p1 <=> p2) == 1
www.canoo.com

29. Effective Java #15
Minimize Mutability
www.canoo.com

30. @Immutable
class Person {
String firstName
String lastName
int id
}
www.canoo.com

31. Effective Java #16
Favor composition over inheritance
www.canoo.com

32. class NoisySet extends HashSet {
@Override
boolean add(i) {
println "adding $i"
super.add(i)
}
@Override
boolean addAll(Collection i) {
for(def x : i) { println "adding $x" }
super.addAll(i)
}
}
www.canoo.com

33. class NoisySet implements Set {
@Delegate
Set delegate = new HashSet()
@Override
boolean add(i) {
println "adding $i"
delegate.add(i)
}
@Override
boolean addAll(Collection i) {
for(def x : i) { println "adding $x" }
delegate.addAll(i)
}
}
www.canoo.com

34. Effective Java #19
Use interfaces only to define types
www.canoo.com

35. Effective Java #19
Use interfaces only to define types
www.canoo.com

36. Effective Java #41
Use Overloading Judiciously
www.canoo.com

37. def function(Collection c) {
println 'received collection'
}
def function(ArrayList a) {
println 'received arraylist'
}
function((Collection) [])
www.canoo.com

38. Effective Java Groovy #41
Prefer default parameters to overloading
www.canoo.com

39. @Log class Calculator {
def log(method, parm1, parm2) {
log.info(
"Method Called: $method" +
(parm1 ? ", p1: $parm1" : '') +
(parm2 ? ", p2: $parm2" : '')
)
}
def log(methodName, parm1) {
log(methodName, parm1, null)
}
def log(methodName) {
log(methodName, null, null)
}
def add(x, y) {
log('add', x, y); x+y
}
def increment(x) {
log('increment', x); x++
}
}
www.canoo.com

40. @Log class Calculator {
def log(method, parm1 = null, parm2 = null) {
log.info(
"Method Called: $method" +
(parm1 ? ", p1: $parm1" : '') +
(parm2 ? ", p2: $parm2" : '')
)
}
def add(x, y) {
log('add', x, y); x+y
}
def increment(x) {
log('increment', x); x++
}
}
www.canoo.com

41. Effective Java #43
Return empty arrays or collections,
not nulls
www.canoo.com

42. Effective Java #43
Return empty arrays or collections,
not nulls
www.canoo.com

43. Effective Java #54
Use native methods judiciously
www.canoo.com

44. Effective Java #54
Use native methods judiciously
www.canoo.com

45. Effective Java #56
Adhere to generally accepted
naming conventions
www.canoo.com

46. Effective Java #56
Adhere to generally accepted
naming conventions
www.canoo.com

47. Effective Java #57 – #61
Use exceptions only for exceptional conditions
Avoid unnecessary use of checked exceptions
Use checked exceptions for recoverable conditions
...
www.canoo.com

48. Effective Java #57 – #61
Use exceptions only for exceptional conditions
Avoid unnecessary use of checked exceptions
Use checked exceptions for recoverable conditions
… and more
www.canoo.com

49. Effective Java #65
Don't ignore exceptions
www.canoo.com

50. Effective Java #65
Don't ignore exceptions
www.canoo.com

51. def b
new SwingBuilder().frame(
size: [300, 300],
show: true,
defaultCloseOperation: EXIT_ON_CLOSE) {
b = button(text: 'Click Me')
}
b.addMouseListener(
[ mouseClicked: { println 'clicked!' }
] as MouseListener)
www.canoo.com

52. Effective Groovy #7
Implement interfaces as maps judiciously
www.canoo.com

53. Effective Java #47
Know and use the libraries
www.canoo.com

54. Effective Groovy #2
Know and use the Collection methods
www.canoo.com

55. List<Person> people = Person.findAll();
List<Integer> ids = new ArrayList<Integer>();
for (Person p : people) {
ids.add(p.getId());
}
www.canoo.com

56. def people = Person.findAll()
def ids = people.collect { it.id }
www.canoo.com

57. def people = Person.findAll()
def ids = people*.id
www.canoo.com

58. Effective Groovy #2a
Use collect for List transformations
www.canoo.com

59. List<Person> people = Person.findAll();
Person joe = null;
for (Person p : people) {
if ("Joe".equals(p.getFirstName())) {
joe = p;
break;
}
}
www.canoo.com

60. def people = Person.findAll()
def joe = people.find { it.firstName == 'Joe' }
www.canoo.com

61. List<Person> people = Person.findAll();
List<Person> bucks = new ArrayList<Person>();
for (Person p : people) {
if ("Buck".equals(p.getLastName())) {
bucks.add(p);
}
}
www.canoo.com

62. def people = Person.findAll()
def bucks = people.findAll {
it.lastName == 'Buck'
}
www.canoo.com

63. Effective Groovy #2b
Use find and findAll to search lists
www.canoo.com

64. List<Person> people = Person.findAll()
Map<String, List<Person>> frequencies =
new HashMap<String, List<Person>>()
for (Person p : people) {
if (frequencies.containsKey(p.getLastName())) {
frequencies.get(p.getLastName()).add(p)
} else {
frequencies.put(p.getLastName(), [p])
}
}
www.canoo.com

65. def people = Person.findAll()
def frequencies = people.inject([:]) { acc, p ->
acc[p.lastName] ?
acc[p.lastName].add(p) :
(acc[p.lastName] = [p])
acc
}
www.canoo.com

66. Effective Groovy #2c
Use inject to accumulate data
(when collect isn't enough)
www.canoo.com

67. def people = Person.findAll()
def families = people.unique() { it.lastName }
www.canoo.com

68. Effective Groovy #2d
Use unique to filter results
www.canoo.com

69. @Field Map cache = new HashMap<Integer, Integer>()
int fib(int seed) {
if (seed == 0) return seed
if (seed == 1) return seed
int minus2 = cache.get(seed - 2) ?: fib(seed – 2)
int minus1 = cache.get(seed - 1) ?: fib(seed – 1)
cache.put(seed-2, minus2)
cache.put(seed-1, minus1)
minus2 + minus1
}
www.canoo.com

70. def fib
fib = { seed ->
if (seed == 0) return seed
if (seed == 1) return seed
fib(seed - 2) + fib(seed – 1)
}.memoize()
www.canoo.com

71. Effective Groovy #2d
Use memoize to cache
idempotent method results
www.canoo.com

72. def fact
fact = {int n, BigInteger acc ->
n > 1 ?
fact.trampoline(n - 1, n * acc) :
acc
}.trampoline()
www.canoo.com

73. Effective Groovy #2e
Use trampoline for recursive functions
www.canoo.com

74. Effective Groovy #2f
Use join for converting Lists to Strings
www.canoo.com

75. def people = Person.findAll()
assert people.any { it.firstName == 'Joe' }
www.canoo.com

76. def people = Person.findAll()
def b = people.every { it.firstName == 'Joe' }
assert !b
www.canoo.com

77. Effective Groovy #2g
Use any and every for logical
operations on Lists
www.canoo.com

78. def people = Person.findAll()
for (Person p : people) {
println p.firstName
}
www.canoo.com

79. Effective Groovy #2h
Prefer Java for-each to Collections.each
www.canoo.com

80. Effective Groovy #3
Know and use the File methods
www.canoo.com

81. FileReader reader = new FileReader("./01.groovy");
BufferedReader input = new BufferedReader(reader);
String str;
while ((str = input.readLine()) != null) {
System.out.println(str);
}
try {input.close();} catch (IOException ex) {}
www.canoo.com

82. def file = new File('./01.groovy')
println file.text
www.canoo.com

83. def file = new File('./02.groovy')
file.eachLine { println it }
www.canoo.com

84. def file = new File('./03.groovy')
file.text = file.text + 'n // hello! '
www.canoo.com

85. def file = new File('./04.groovy')
file.append 'n // better hello! '
www.canoo.com

86. Effective Java #66 – #74
Concurrency
www.canoo.com

87. class MyDataStore {
private final map = [:]
def add(key, value) {
map.put(key, value)
}
def getAt(key) {
map[key]
}
}
www.canoo.com

88. class MyDataStore {
private final map = [:]
def synchronized add(key, value) {
map.put(key, value)
}
def synchronized getAt(key) {
map[key]
}
}
www.canoo.com

89. class MyDataStore {
private final map = [:]
private final lock = new Object()
def add(key, value) {
synchronized(lock) {
map.put(key, value)
}
}
def getAt(key) {
synchronized(lock) {
map[key]
}
}
}
www.canoo.com

90. class MyDataStore {
private final map = [:]
@Synchronized
def add(key, value) {
map.put(key, value)
}
@Synchronized
def getAt(key) {
map[key]
}
}
www.canoo.com

91. Effective Groovy #4a
Prefer Declarative Synchronization
www.canoo.com

92. class MyDataStore {
private final map = [:]
private final lock = new ReentrantReadWriteLock()
def add(key, value) {
lock.writeLock().lock()
try {
map.put(key, value)
} finally {
lock.writeLock().unlock()
}
}
def getAt(key) {
lock.readLock().lock()
try {
map[key]
} finally {
lock.readLock().unlock()
}
}
}
www.canoo.com

93. class MyDataStore {
private final map = [:]
private final lock = new ReentrantReadWriteLock()
def add(key, value) {
withWriteLock(lock) {
map.put(key, value)
}
}
def getAt(key) {
withReadLock(lock) { map[key] }
}
private static withWriteLock(def lock, Closure f) {
lock.writeLock().lock()
try { f() }
finally { lock.writeLock().unlock() }
}
private static withReadLock(def lock, Closure f) {
lock.readLock().lock()
try { f() }
finally { lock.readLock().unlock() }
}
}
www.canoo.com

94. Effective Groovy #8
Prefer ARM blocks to try-finally
www.canoo.com

95. class MyDataStore {
private final map = [:]
@WithWriteLock
def add(key, value) {
map.put(key, value)
}
@WithReadLock
def getAt(key) {
map[key]
}
}
www.canoo.com

96. Effective Groovy #4b
Prefer Declarative Locking
www.canoo.com

97. def count
def t = Thread.start {
count = Person.findAll()?.size()
}
t.join()
println count
www.canoo.com

98. def exe = Executors.newSingleThreadExecutor()
def future = exe.submit({
Person.findAll()?.size()
} as Callable)
println future.get()
exe.shutdown()
www.canoo.com

99. Effective Java #69
Prefer Concurrency Utilities
www.canoo.com

100. Effective Java #68
Prefer executors and tasks to threads
www.canoo.com

101. @Grab( group = 'org.codehaus.gpars',
module = 'gpars',
version = '0.11')
import static groovyx.gpars.dataflow.DataFlow.task
import groovyx.gpars.dataflow.DataFlowVariable
final count = new DataFlowVariable()
task {
count << Person.findAll().size()
}
println count.val
www.canoo.com

102. task {
total << personCount.val + personCount.val
}
task {
personCount << Person.findAll().size()
}
task {
addressCount << Address.findAll().size()
}
println "Total: $total.val"
www.canoo.com

103. Effective Groovy #5
Prefer Declarative Coordination
www.canoo.com

104. Effective Groovy #5½
Learn to Use @Grab
www.canoo.com

105. More Effective Java
#21: Use function objects to represent strategies
#36: Consistently use @Override
#71: Use Lazy Initialization judiciously – See Groovy's @Lazy
#47: Know & use the libraries – Read the GDK Docs and Release Notes
#63: Include Failure-capture information in detailed messages
#11: Override Clone Judiciously – See @AutoClone, @Canonical
www.canoo.com

106. More Effective Groovy
#9: Learn to Write a Builder
#10: XMLSlurper/Parser - Do not mix with business logic/layers/etc
#11: Effective Java #21: Use Function Objects to represent strategies
#12: Threading: Avoid Busy Wait
#13: Threading: Avoid Double Checked Locking
#14: Threading: Avoid Inconsistent Property Locking
#15: Threading: Avoid Inconsistent Property Synchronization
#16: Threading: Avoid Synchronizing On Boxed Primitive
#17: Know and use Elvis operator ?:
#18: Excessively use the null-safe dereference operator
#19: Understand Operator Overloading
www.canoo.com

107. More Effective Groovy (with static analysis)
www.canoo.com

108. Thanks!
http://canoo.com/blog
http://hamletdarcy.blogspot.com
@HamletDRC
http://tv.jetbrains.net/tags/hamlet
http://www.youtube.com/hamletdrc
Groovy, Grails, Griffon, and Agile Consulting
info@canoo.com or
www.canoo.com
hamlet.darcy@canoo.com