Blog Posts tagged with: training

Oct 10 2008

Comments

Concurrent Programming with Clojure

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.

Sep 09 2008

Comments

Java.next Presentation #4: Concurrency

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:

Aug 26 2008

Comments

Java.next Presentation #3: Dispatch

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.

Jul 30 2008

Comments

Clojure

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.

Jun 13 2008

Comments

Java.next #1: Clojure, Groovy, JRuby, and Scala

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.

Popular Tags