<<< Previous speaker next speaker >>>

Dean Wampler, ObjectMentor

 Dean  Wampler

Dean Wampler, Ph.D., is a Consultant at Object Mentor, Inc., where he helps clients improve their code using Agile methods like Test-Driven Development, Refactoring, and the best combinations of languages and modularity paradigms (so called "polyglot programming"), like Object-Oriented, Aspect-Oriented, and Functional Programming.

Dean is the founder of the advocacy sites http://polyglotprogramming.com and http://aspectprogramming.com. He created the open-source projects "Aquarium", an AOP library for Ruby (http://aquarium.rubyforge.org) and "Contract4J", a Design by Contract library for Java ( http://contract4j.org). He has also contributed to "FitNesse", an acceptance-testing tool for many languages (http://fitnesse.org).

Dean speaks frequently at industry and academic conferences on polyglot programming, AOP, Ruby, and other topics.

Presentation: "Radical Simplification Through Polyglot and Poly-paradigm Programming"

Time: Wednesday 17:15 - 18:15

Location: Olympic

Abstract: Complexity is one of the most pervasive problems in software. This talk explores how different modularity "paradigms" - object-oriented programming (OOP), functional programming (FP), and aspect-oriented programming (AOP) - simplify complexity and help separate concerns. We will examine the design problems where these paradigms are most applicable and extract rules of thumb for when to use them. We will also look at language support for these paradigms, how to use different paradigms in languages that don't support them, and how language features can promote simplicity (or fail to do so). In particular, after a short introduction to functional programming, we will discuss why FP is an effective tool for building robust, highly-concurrent applications. We will discuss how aspect-oriented programming retains modularity and removes duplication when orthogonal concerns must interact in a fine-grained way, e.g., persisting an object's state changes. We will see examples of one of the most successful polyglot architectures; "components + scripts = applications". The components provide access to system services and are optimized for performance. They are usually written in compiled, statically-typed languages, like C++, Java, or C#. The components are "glued" together to implement features using higher-level "scripts", usually written in easy-to-use, interpreted, dynamically-typed languages, like Ruby and Python. A classic example of this architecture is Emacs (a C kernel and elisp scripts). More recent examples include Adobe Lightroom (C++ kernel and Lua scripts). When we consider languages, we will investigate the relative merits of poly-paradigm languages (e.g., Scala) vs. using several, single-paradigm languages (e.g., Java or Ruby plus Erlang). Finally, we will discuss how domain-specific languages (DSL's) are one particular class of "scripting languages", which simplify code by aligning it more closely with the problem domain and by encapsulating implementation complexity. We will discuss a few examples from the Ruby libraries and we will notes the similarities between DSL's and functional languages.