In the Ruby community, we have a tendency to sneer at things that are too “enterprisey.”
That tendency has been explained in some uncharitable ways, but mostly by claiming that we “just don’t understand the enterprise.”
But I think there’s a different explanation.
At Relevance, we’ve been doing some work with a large, enterprisey customer (Verizon Business).
We’ve worked together to try to understand what enterprises can learn from smaller, more agile companies like Relevance.
That work has led us to understand some of the real disadvantages of the kinds of big, pricey tools you usually find in large enterprises,and we’ve learned why lightweight tools like Ruby are good fits not just for small, agile teams, but for large enterprises as well.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Why "Enterprise Tools" Are Bad for the Enterprise" for your organization, or view our curriculum if you are interested in a complete course.
Since the Cold War, the secretive Dyadic Society has been stealthily sapping the strength of the software development community. Haven't heard of them? That just proves that they exist! To conceal the truth from programmers, the Dyads promote their ideology through proxies, using content-free blanket terms such as "best practices" and "design patterns."
You can fight the Dyads by avoiding so-called "best practices" such as
- polymorphism via classes and methods
- error handling via throwing and catching exceptions
- thread-safe code via objects and locks
Notice the dyads: throw and catch, class and method, object and lock. In this keynote, you will see what the Dyads fear most: a set of Triadic techniques that break the Dyadic chokehold on developers everywhere:
- polymorphism via structures, functions, and multiple dispatch
- error handling via signals, handlers, and restarts
- thread-safety via immutable data, references, and transactions
Remember: threedom is freedom.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Triadic Programming" for your organization, or view our curriculum if you are interested in a complete course.
Clojure is getting a lot of positive buzz, but what is it like building and shipping a real application? In this talk, we will cover the good, the bad, and the ugly of commercial Clojure development, including:
- BDD meets FP: how we adapted spec and test practices for functional code
- To wrap or not to wrap: working with Java libraries
- The learning curve: training a team of non-Clojurists on Clojure
- What you will wish for: third-party libraries you should know about, plus some that don't exist yet
- Good names or die: living without object context
- Shipping it: how to manage staging and deployment of Clojure code
Experience with Clojure is useful but not a prerequisite; we will introduce the key concepts as we go.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Clojure in the Field" for your organization, or view our curriculum if you are interested in a complete course.
jQuery is a powerful JavaScript library for dealing with HTML, events, animations, and Ajax. Unlike many libraries, jQuery puts the browser object model front-and-center through its ubiquitous wrapped element sets. In this talk, you will learn to progressively enhance your web applications the jQuery way: with unobtrusive, functional JavaScript.
Along the way, you will learn how to:
- select and modify elements with jQuery's powerful selectors
- use jQuery's utility functions
- register event handlers, including dynamic ones that track changes to the page over time
- play nice with other libraries with
noConflict
- create Ajax requests that return HTML, JSON, and other data types
- breathe life into your interface with effects and animations
- unit test your JavaScript code with Screw.Unit, Smoke, and blue-ridge
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Introduction to jQuery" for your organization, or view our curriculum if you are interested in a complete course.
Agile teams manage change and risk by apapting. But to adapt, you must identify opportunities for change and take them. Retrospectives are a fun, cost-effective way for your team to learn and change.
In this talk, we will begin by conducting a mini-retrospective, so that you get a feel for the basic process. Next, we will review the core principles of a retrospective, and use these principles to compare and contrast a variety of retrospective activities from the book Agile Retrospectives.
Next, we will explore a few retrospective activities in greater detail. These are some of the favorites that we use regularly at Relevance:
- team radar
- prioritize with dots
- learning matrix
Finally, we will talk about how to tune retrospectives to the needs of your team at a specific moment in time. No two retrospectives are alike, and an experienced facilitator adds value by adapting a retrospective to meet the current need.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Agile Retrospectives" for your organization, or view our curriculum if you are interested in a complete course.
Clojure is a dynamic language for the Java Virtual Machine with several powerful features for building concurrent applications. In this talk you will learn about:
- Functional programming. Clojure's immutable, persistent data structures encourage side-effect free programming that can easily scales across multiple processor cores.
- Software Transactional Memory (STM). STM provides a mechanism for managing references and updates across threads that is easier to use and less error-prone than lock-based concurrency.
- Agents. Agents provide a thread-safe mechanism for asynchronous, uncoordinated updates.
- Atoms. Atoms provide for synchronous, uncoordinated updates.
- Dynamic Vars. Dynamic Vars support thread-local state.
- Direct access to Java. Clojure calls Java directly, and can emit the same byte code that a handcrafted Java program would. Where it makes sense to do so, you can easily access the java.util.concurrent library.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Concurrent Programming with Clojure" for your organization, or view our curriculum if you are interested in a complete course.
Programming concurrency is hard, but the Java.next languages can make things easier. In this talk (Part 4 of the Java.next series), I will demonstrate how to write concurrent applications in Clojure, Groovy, JRuby, and Scala.
Topics will include
- calling the java.util.concurrent APIs
- why locks are harmful
- using immutable objects
- Scala's actor model
- Clojure's Software Transactional Memory and Agents
For more information, see the following article on the Relevance blog:
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next Presentation #4: Concurrency" for your organization, or view our curriculum if you are interested in a complete course.
Dispatch takes many forms. Single dispatch, switch statements, pattern matching, and multiple dispatch all meet similar needs: Selecting runtime behavior in response to varying runtime conditions.
Flexible dispatch is a key element of Java.next. All of the Java.next languages support dispatch strategies that are far more flexible than Java's single dispatch.
In this talk (Part 3 of the Java.next series), I will explore how the Java.next languages (Clojure, Groovy, JRuby, and Scala) support dispatch. For more information, see the Java.next Dispatch article on the Relevance blog.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next Presentation #3: Dispatch" for your organization, or view our curriculum if you are interested in a complete course.
The nature of application development has swung away from large, tightly integrated (some might say “coupled”) behemoths into loose collections of highly-granular functionality. This is true both within an application, through tools like Ruby’s metaprogramming facilities and flexible typing, and among a suite of applications, enabled by single-sign-on security architectures and widely available robust messaging providers. This talk will demonstrate these techniques and look at the benefits of this application style, from maintainability, testability, to scalability and sanity. This talk is code-heavy, slide-light, and requires the attendee to have a firm grasp of Ruby, Rails, and patterns of application architecture.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Small Things, Loosely Joined, Written Fast" for your organization, or view our curriculum if you are interested in a complete course.
Domain-Specific Languages (DSLs) have hit the sweet spot on the hype cycle. We now hear potential clients say things like:
Our proposed killer app will target (some domain they don't understand). Step 1: Write a DSL. Step 2. ? Step 3. Profit!
DSLs are very useful, but they are no substitute for good domain design... or good code for that matter. In this talk, we will compare DSLs with other analysis and implementation tools, and help you decide when and how they are a good fit. Along the way we will discuss:
- Good API design
- Declarative style
- Mini-DSLs
- Internal DSls
- External DSLs
- User Interfaces
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Do I Really Need a DSL?" for your organization, or view our curriculum if you are interested in a complete course.
In recent years, the Java community has embraced a variety of new languages that target the JVM, but also offer productivity advantages over traditional Java coding.
One of the most interesting of these languages is Clojure, a "Lisp unconstrained by backward compatibility." In this talk, you will see why Clojure deserves serious consideration as the next big JVM language:
- Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python.
- Clojure's sequence library turns the tables on OO, providing a powerful set of verbs that can work with a small, standard set of nouns.
- Clojure includes Lisp's signature feature: Treating code as data through macros.
- Clojure's emphasis on immutability and support for software transactional memory make it a viable option for taking advantage of massively parallel hardware.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Clojure" for your organization, or view our curriculum if you are interested in a complete course.
The rise of Ajax and Rich Web Applications, plus the success of dynamic languages, has caused people to revisit the JavaScript language. Now that we take JavaScript seriously as a language, it is time to get serious about the quality of JavaScript code, through refactoring. In this talk, we will approach refactoring JavaScript in three phases:
- Test first, then refactor. Bring JavaScript code under test, so that you can refactor with confidence.
- Refactoring 101. Explore some important refactorings: composed method, extract method, introduce named parameter, and extract object
- Common problems. Work through three problems endemic to legacy JavaScript code: making JavaScript unobtrusive, refactoring to prototype-based inheritance, and refactoring to functional style.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Refactoring JavaScript" for your organization, or view our curriculum if you are interested in a complete course.
Prototype and Scriptaculous provide great functionality out of the box, but once you use them for a while you will probably want a little more. In this talk, we will look at tips and tricks for getting the most out of Prototaculous, plus some other libraries that can play nicely. You will see how to
- test your JavaScript code
- write unobtrusive JavaScript with Low Pro
- perform client-side form validation
- reach scripts across sites (for good, not evil!)
- create charts with the Google Chart API
- use UI components beyond the basics of Scriptaculous
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Prototaculous Tips and Tricks" for your organization, or view our curriculum if you are interested in a complete course.
As we reach the middle of our second decade of Java experience, the community has learned a lot about software development. Many of our best ideas on how to use a Java Virtual Machine (JVM) are now being baked into more advanced languages for the JVM. These languages tend to provide two significant advantages:
- They reduce the amount of ceremony in your code, allowing you to focus on the essence of the problem you are solving.
- They enable some degree of functional programming style. Think of it as a dash of verb-oriented programming to spice up your noun-oriented programming.
In this talk, we will explore and compare four of the most interesting new JVM languages: Clojure, Groovy, JRuby, and Scala. Each of these languages aims to greatly simplify writing code for the JVM, and all of them succeed in this mission. However, these languages have very different design goals. We will explore these differences, and help you decide when and where these languages might fit into your development toolkit.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Java.next #1: Clojure, Groovy, JRuby, and Scala" for your organization, or view our curriculum if you are interested in a complete course.
You have probably heard about Git by now, perhaps something along these lines: "Git is a version control system, and it is more powerful than Subversion in every way. You don't even have to be online to commit!"
This is true, but it undersells Git. Git is not the next step in the evolution of centralized source control, following in the footsteps of CVS, SVN, etc. These tools provide centralized history of deltas, where Git provides distributed history of trees of content. In this talk, you will see the advantages of the Git approach:
- Incredible speed.
- Local, disconnected operation.
- Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with Git.
- Cheap and easy branching, tagging, and merging.
- Editing and refactoring your commits.
The Git community prefers power to ease-of-use, and so Git's user interface and documentation can be intimidating. You will learn the straight and narrow path for common, day-to-day Git operations. You will also learn Git's underlying data model, and get a quick introduction to more advanced concepts like submodules, cherry-picking, and bisection.
As a final bonus, you will see how to use Git on an existing SVN project. You can use Git as your SVN client, and the rest of the team can stay on SVN and not even care.
Relevance staff deliver technical talks at events around the world. Contact us to schedule "Git Control of Your Source" for your organization, or view our curriculum if you are interested in a complete course.
