Track: Effective design and Clean code

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.