Closures for Java

Closures for Java
…and other thoughts on language evolution

Neal Gafter
Google
1680

2

Goals for Language Change

> Simplify programs
– More concise
– Don’t Repeat Yourself (DRY)
– Make reading, writing easier

> Fewer bugs

> Adapt to changing requirements
– Multicore and concurrency
– Enable programmer flexibility (expressiveness)

3

What is a Closure

> A closure is an anonymous function expression

> Like
– Block in Smalltalk, Ruby, Scala
– Lambda in Lisp
– Anonymous function in Javascript

4

DRY (Don’t Repeat Yourself)

InputStream s = openStream();
try {
doSomething(s);
} finally {
where
try { s.close(); }
catch(IOException ex) {
<T extends Closeable>
LOGGER.log(…);
void with(T s, {T => void} block) {
} try {
} block.invoke(s);
} finally {
becomes try ( s.close(); }
catch(IOException ex) {
LOGGER.log(…);
with (InputStream s : openStream()) {
}
doSomething(s);
}
} }

5


long t0 = System.nanoTime();
boolean success = false;
try {
doSomething();
where
success = true;
} finally { void time(String key, Block block) {
recordTime(“doSomething”, success, long t0 = System.nanoTime();
System.nanoTime() – t0); boolean success = false;
try {
}
block.invoke();
success = true;
becomes } finally {
recordTime(
time (“doSomething”) { key, success,
System.nanoTime() – t0);
doSomething();
}
}
}

6


for (Map.Entry<String,Thing> e : myMap.entrySet()) {
String name = e.getKey();
Thing thing = e.getValue();
doSomething(key, value);
}

becomes

for each(String name, Thing thing : myMap) {
doSomething(name, thing);
}

<K,V> void for each(Map<K,V> map, {K,V => void} block) {
for (Map.Entry<K,V> e : myMap.entrySet()) {
where
block.invoke(e.getKey(), e.getValue());
}
}

7

Make reading, writing easier

void addListener(final ItemSelectable is) {
is.addItemListener(
new ItemListener() {
public void itemStateChanged(ItemEvent e)
{ doSomething(e, is); }
}
);
}
becomes

void addListener(ItemSelectable is) {
is.addItemListener(
{ ItemEvent e => doSomething(e, is); }
);
}

8

Make reading, writing easier

void launch(Executor ex) {
ex.execute(new Runnable() {
public void run() {
doSomething();
}
});
}
becomes

void launch(Executor ex) {
ex.execute({ =>
doSomething();
});
}

9

Benefits of being DRY

> Less boilerplate

– Programs easier to read

– Fewer bugs

> Hard things become easy
– Fork- join concurrency

10

Multicore and Concurrency

> Need concurrency to exploit Moore’s Law

11



> Thread- based concurrency is hard

12




> Fork- Join concurrency is easier
– Concurrent Loops

13




> Fork- Join concurrency is easier
– Concurrent Loops

> But more will be needed in the future
– Actors
– Functional Programming
– Software Transactional Memory

14

Enable Programmer Flexibility
(expressiveness)
> Programmers “grow” a language by adding APIs

> See Guy Steele’s “Growing a Language”
If you give a person a fish, he can eat for a day.
If you teach a person to fish, he can eat his whole life long.

15

Enable Programmer Flexibility
(expressiveness)
> Programmers “grow” a language by adding APIs

> See Guy Steele’s “Growing a Language”

> Support more flexible “language extension” by API

> Reduce the need for future language change

16

There is more to Java (SE) than Java (PL)

> The VM

> Deployment

> Other languages

>…

Neal Gafter http:/ / www.javac.info/
Google neal@gafter.com

Closures for Java

Related slideshows

More Related Content

Closures for Java