Robin Milner (1934-2010) was a gentle giant of computer science. Among many fundamental contributions, his insights on the role of types in the theory and practice of programming have been perhaps the farthest reaching. This talk combines a historical perspective on Milner’s early work with a look at how these ideas continue to unfold — in particular, the idea that types constrain not only structure but also behavior. Examples will include abstract and object types, types for concurrent and distributed systems (session and choreography types), and new work on type systems for privacy-preserving querying of sensitive databases.
In today’s production environments, tremendous amounts of work can be performed on servers running the JVM with dozens of cores, yet in just a few years we could have machines that have thousands of cores. Parallelizing work in such a “manycore” environment is a hot topic, as is managing concurrency with so many possible threads executing at the same time. Will deterministic results be impossible in such a world? Will the JVM evolve to have more hardware affinity, providing developers with tools to create applications with more specific performance profiles? Join us as we talk with experts Cliff Click, Charlie Hunt, Doug Lea and Mike Pilquist about the challenges facing developers using the JVM on tomorrow’s computing platforms, as well as discuss the future of the JVM itself.
Clojure’s approach to data is significantly different than other popular languages, and somewhat different even than its Lisp heritage. On one hand, Clojure provides a small core set of immutable, persistent data structures. On the other, Clojure uses functional programming to provide a rich set of data manipulation functions. These two pillars of Clojure are fused together through the “sequence” abstraction. Because of sequences, Clojure developers expect that almost any function works with almost any composite data. This is a radically different approach than we see in popular OO languages like Java.
This talk will examine Clojure’s approach to both data and function and explore how sequences are the linchpin abstraction between them. We will consider how Clojure’s approach to data differs from object-oriented programming (particularly Java) and see how this approach changes the nature of your daily programming. We will also consider topics such as mutation, state vs value, and how to customize your primitive and composite data. You should leave this talk with new ways to think about the intersection of data and function in your program.
This talk is based on work in a large Clojure code base (70k+ lines) developed over three years at Revelytix. We have built several products in Clojure and have found the focus on the power of immutable data to be a significant asset in helping us build and evolve our code.
"Creating components based on concurrent and parallel algorithms and data structures often requires more attention to “engineering” issues not seen with most other libraries. Components created in the “obvious” way sometimes turn out to be wrong, to perform poorly, or are unusable in most applications, because the abstractions in which they are expressed are leaky, imprecise, or incorrectly specified.
While many of these issues are encountered in other aspects of concurrent programming, the impact is accentuated when they continue to leak through to APIs provided by library components. This presentation surveys some examples and lessons learned from the design, implementation, and applications of the java.util.concurrent library, including those surrounding memory models, resource management and garbage collection, thread management, optimization, and code generation."
When you are faced with the challenge of tuning JVM, you can find a wide variety information. Yet, almost always the information is rather specific in the type of tuning, or specific to a type of problem. Seldom can you find information that tells abstracts the details into a higher level and simplifies it into a set of fundamentals and principles. This is what you can expect to hear and learn in this session.
The first important thing to do is to understand your application requirements when it comes to the performance metrics of throughput, latency and footprint. From there you can formulate a strategy including choosing an appropriate GC. From there it’s a matter of understanding some fundamentals about what impacts GC behavior and what you can do about it. In addition, you will also learn what a Java developer should understand when it comes to JIT compilation and what he or she can do about it.