Dick Wall


Dick Wall is a software engineer and has been a Java developer for over 15 years, more recently gaining an interest in the Scala language and now working primarily in Scala as well as teaching it as a part of his enterprise with Bill Venners: Escalate Software - http://www.escalatesoft.com

In addition Dick works for Locus Development, a company doing genetic risk research, and finds time to co-host the Java Posse podcast -http://www.javaposse.com - and run the local Scala developer’s group BASE (the Bay Area Scala Enthusiasts - http://svscala.org).

Dick also enjoys road and mountain biking, riding his motorcycle, hiking, and lots, and lots, of music.

Courage in Software Development

As software practitioners, and as human beings, we experience the desire to better ourselves. As corporate developers however, that desire has sometimes been difficult to sate in the past few years.

Deadlines, accountability, mixed ability teams, and a level of maturity in Object Oriented Development, and more specifically in the Java language, have led to a conservative approach to software development where risks are largely frowned upon, engineers and managers tend to stick with what they know, and bettering oneself often means arguing over best practices or concentrating on the details of our trade, the software craftsmanship movement is an example of this.

Unfortunately another example of this is waste - wasted effort, wasted engineers and wasted opportunities. Writing a new web or app framework is predictable time-wise, and often easily justified. It’s also often a misguided effort, and we will discuss why.

In this talk I hope to present a different viewpoint, one based on careful courage as opposed to risk aversion at all costs, one aimed at successfully moving the world forward rather than avoiding failure to meet a deadline. It’s a topic dear to my heart after experiencing the waste inside of many companies, both large and small.

Tail Recursion, Trampolines and Continuations - taking functions to the max

This is a fairly advanced talk about some of the more ambitious things you can do in a functional language (closures are just the beginning). It deals with the quite tricky subject of continuations by sneaking up on it by incremental steps building on single function tail recursion, multiple function tail recursion with trampolines, and then on to the continuations compiler plugin and support libraries in Scala.