Ted Neward

Presentations

The Busy Java Developer's Guide to Java Platform Security

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

The Busy Java Developer's Guide to Concurrency (Part 2: Concurrency)

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

The Busy Java Developer's Guide to Scala: Objects

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we focus on the parts of Scala that feel comfortable to the traditional object-oriented developer, and the various ways that Scala improves the object-oriented experience.

The Busy Java Developer's Guide to Scala: Actors

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we focus on the Actors library in Scala: what it is, how it works, and why it offers a concurrency model that's strikingly easier to understand than the traditional Java "synchronized" approach.

The Busy Java Developer's Guide to Scala: Scala + Services

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we take the Scala language, its support for XML, it's immutable and functional approaches, and build a simple XML service with it, no JAX-WS needed (or wanted). Deploying the service as a simple servlet, we show it being consumed from a traditional JAX-WS service client, and from a more "hip" REST approach.

The Busy Java Developer's Guide to Java7 Closures

Since 2006, the Java community has been abuzz with the idea of new language extensions to the Java compiler, nicknamed "closures", though more formally they should be called "anonymous method (with full transitive closure semantics)". What is this new proposal, why is it being floated forward now, what are the benefits of closures, what are the drawbacks, and what could Sun possibly be thinking after the debacle that generics became?

In this presentation, we'll look at the three major closures proposals, write some code with all three, with an eye towards not trying to pick which one is "better", but to understand how anonymous methods (closures) will change how we write Java code.

The Busy Java Developer's Guide to Collections

For so many Java developers, the java.util.* package consists of List, ArrayList, and maybe Map and HashMap. But the Collections classes are so much more powerful than many of us are led to believe, and all it requires is a small amount of digging and some simple exploration to begin to "get" the real power of the Collection classes.

In this presentation, Java developers will see the basic breakdown of the Collection API designs, the relationship of the interfaces to the implementations, how to create a new Collection implementation, and how the new Collections introduced as part of JSR-166 (the concurrency JSR) and Java6 make their programming lives easier.

The Busy Java Developer's Guide to Advanced Platform Security

So you know the platform security model, and now you want to use it in new and interesting ways, like creating a custom Policy implementation, a custom Permission, or create a custom security context in which code will execute. Perhaps you even wish to make certain objects accessible only to those with the right permissions, or cryptographic key. Nothing could be easier, despite Java security's reputation as a dark and arcane place.

In this presentation, we'll pick up where the "Platform Security" talk leaves off, and demonstrate how to engage the security model of the JVM at a much deeper level, regardless of your favorite programming language: Java, JRuby, Groovy, Scala, ....

The Busy Java Developer's Guide to Functional Java

Much noise has been made in recent years about functional languages, like Scala or Haskell, and their benefits relative to object-oriented languages, most notably Java. Unfortunately, as wonderful as many of those benefits are, the fact remains that most Java developers will either not want or not be able to adopt those languages for writing day-to-day code. Which leaves us with a basic question: if I can't use these functional languages to write production code, is there any advantage to learning about them? The short answer is yes, for the fundamental premise--"I can't use functional code on my Java project"--is flawed. Java developers can, in fact, make use of functional ideas, and what's better, they don't even have to reinvent them for Java--thanks to the FunctionalJava library, many of the core primitives--interfaces that serve as base types for creating function values, for example--already exist, ready to be used.

In this presentation, we'll go over some basic functional concepts, then start seeing how they apply in the FJ library, and show how to use FJ and functional ideas on common Java programming tasks. Let the excuse "I can only use Java" finally be consigned to the rubbish bin, once and for all.

The Busy Java Developer's Guide to Advanced Collections

Once you've learned the core Collections clases, you're done, right? You know everything there is to know about Collections, and you can "check that off" your list of Java packages you have to learn and know, right?

In this presentation, we'll go over what's missing from the Java Collections library, what is provided via other sources (Google and Apache, among others), and what you can provide for yourself, including a brief foray into the world of functional programing, and how it can make your Java code more elegant.

The Busy Java Developer's Guide to JMS

The Java Message Service API provides a unified programming interface to a variety of different messaging systems, and provides a necessary and important supplement to distributed communications.

In this presentation, we'll go over the basics of messaging systems, the core JMS APIs, some configuration tips for popular JMS implementations, and the various message types that can be sent.

The Busy Java Developer's Guide to Advanced JMS

Once you've mastered the basics of JMS, a whole new world of interesting capability opens up. Understanding all of the possible permutative capabilities in the JMS API is another story, however--when do you use transactions? When do you use acknowledgement? When do you use persistent message queues, and when are simpler Topics acceptable instead? Message selectors?

In this presentation, we'll go over the JMS API in deeper detail, going over all of the above topics, and giving the Java developer a deeper insight into JMS and how it can make your applications more reliable and interoperable.

The Busy Developer's Guide to Iconoclasm

History is littered with the stories of iconoclasts--people who truly stood out as pioneers, lateral thinkers, and in some cases, outright heroes--and their successes and failures. From the baseball management vision of Branch Hickey to the glassblowing vision of Dale Chihuly to the engineering design vision of Steve Jobs, iconoclasts have changed our world in subtle and profound ways, sometimes loudly, sometimes quietly.

For an industry that seems so ripe and so rife with "special personalities", it would seem that programming is tied up deeply with iconoclasm. But what defines the iconoclast, what demarcates the "true" iconoclast from the mere pretender, and how can we use the characteristics of the iconoclast to change our own immediate surroundings for the better?

The Busy Java Developer's Guide to Patterns in ECMAScript

ECMAScript, better known by its original name, Javascript, remains one of the most popular--and misunderstood--programming languages in use today. While most developers see Javascript as a crippled form of its namesake (Java), it turns out that ECMAScript represents a powerful dynamically-typed language, easily equal to the other popular dynamic languages of the day (Python or Ruby).

In this presentation, we'll start looking at some of the O-O community's favorite design patterns (from the Gang-of-Four book as well as others) and examine their applicability to ECMAScript, including those patterns that work well here, those that don't, and a few new ones that wouldn't work well anywhere but here.

The Busy Java Developer's Guide to Java on Mac OS X

Developing and running Java was supposed to be a "Write Once, Run Anywhere" experience, but....

In this presentation, we'll take a look at how Apple implemented Java on the Mac OS X platform, and talk about how this changes (or doesn't) the Java development experience, with an eye towards the platform-specific things that Java developers may run into.

The Busy Java Developer's Guide to Scala: Patterns

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we'll start looking at some of the O-O community's favorite design patterns (from the Gang-of-Four book as well as others) and examine their applicability to Scala, including those patterns that work well here, those that don't, and a few new ones that wouldn't work well anywhere but here.

The Busy Java Developer's Guide to Scala: Basics

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we begin by looking at the Scala type system and flow-control primitives, such as if/else, pattern-matching, tuples, lists, and more. Despite the name, "basics" in Scala can get the newcomer Scala developer quite some distance.

The Busy Java Developer's Guide to Scala: Thinking

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files. Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more. Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

In this presentation, we try to graduate "beyond" the syntax by tackling the hardest problem of learning a new language--thinking in that new language. After a brief high-level discussion of some of functional concepts and design ideas/idioms, we'll take a programming challenge, collectively examine how we can implement it in Scala, but instead of just trying to use the O-O approach, we'll try to "think functionally" as well and use all of Scala's features to come up with the most succinct, reusable code we can imagine. It's a deliberately open-ended group-oriented discussion, looking to bring everybody into a different mindset.

MongoDB

MongoDB is designed for problems without heavy transactional requirements that aren't easily solved by traditional RDBMSs, including problems which require the database to span many servers.

Like other document-oriented database systems such as CouchDB, MongoDB is not a relational database management system. The database manages collections of JSON-like documents which are stored in a binary format referred to as BSON.

Come learn all about MongoDB!