vendredi 29 juillet 2011

Veille technologique semaine 30

Pour le bulletin de cette semaine, je vous propose les sujets suivants :
  • Sortie du JDK 7, comme prévu, le 28 juillet 2011 : articles sur le contenu avec les détails de la documentation.
  • Un article sur le pattern "Disruptor".
  • OSGi et la gestion des modules partagés.
  • Java et la réflexivité des génériques.
  • La définition des classes non mutables
  • La déclaration des variables : la forme dépends du langage de programmation.
  • La taille des objets en Java.
  • La taille des tableaux en Java.

Bonne lecture.

Java SE 7 Released: First Major Update Since December 2006
Java 7 is generally available from today, the first release of the Java platform since Oracle's acquisition of Sun. The release includes a number of small but welcome changes to the language, incorporates a new file API and the Fork/Join Framework, and improves dynamic language support on the JVM.

For Java 7 language changes have been managed as part of Project Coin (JSR 334), a successor to JSR 201, designed to enhance the Java language with an assortment of small changes to improve productivity. Of particular note is the introduction of "try-with-resources". This is analogous to C#'s using statement but based on a form of the try statement. As a result, whilst the using statement only takes a single resource, try-with-resources is able to handle multiple resources within the scope of a given block. Two changes have been made to exception handling. First, multiple exception types can be named as being handled by a single catch block. The grammar of a catch clause of a try statement is extended to allow a series of exception types, separated by the "OR" operator symbol, "|", to be used in the declaration of the exception parameter. Second, if an exception parameter is not modified and if it is rethrown inside the catch block, you don't now have to add the exception to the method signature.

Java SE 7 Downloads
This release includes new features such as small language changes for improved developer productivity, a new Filesystem API, support for asynchronous I/O, a new fork/join framework for multicore performance, improved support for dynamic and script languages, updates to security, internationalization and web standards and much more.

Java Platform Standard Edition 7 Documentation
Oracle has two products that implement Java Platform Standard Edition (Java SE) 7: Java SE Development Kit (JDK) 7 and Java SE Runtime Environment (JRE) 7.
JDK 7 is a superset of JRE 7, and contains everything that is in JRE 7, plus tools such as the compilers and debuggers necessary for developing applets and applications. JRE 7 provides the libraries, the Java Virtual Machine (JVM), and other components to run applets and applications written in the Java programming language.

What's New in Documentation
Documentation is regularly updated to provide developers with in-depth information about new features in the Java platform.

Java as a platform and a language
Welcome to Java 7. Things around here are a little different than you may be used to. This is a really good thing—we have a lot to explore now that the dust has settled and Java 7 has been unleashed. By the time we finish our journey, you'll have taken your first steps into a larger world—a world of new features, of software craftsmanship, and other languages on the JVM.
We're going to warm you up with a gentle introduction to Java 7, but one that still acquaints you with its powerful features. We'll showcase Project Coin, a collection of small yet effective new features. You'll learn new syntax, such as an improved way of handling exceptions (multi-catch). You'll also learn about Automatic Resource Management and how it helps you to avoid bugs in the code that deals with files or other resources. By the end of this paper, you'll be writing Java in a new way and you'll be fully primed and ready for bigger topics.
Let's get going! We'll first dive into a critically important duality that lies at the heart of modern Java. This is a point that we'll come back to again throughout the book, so it's an absolutely essential one to grasp.

Dissecting the Disruptor: Why it's so fast (part one) - Locks Are Bad
Martin Fowler has written a really good article describing not only the Disruptor, but also how it fits into the architecture at LMAX. This gives some of the context that has been missing so far, but the most frequently asked question is still "What is the Disruptor?". I'm working up to answering that. I'm currently on question number two: "Why is it so fast?". These questions do go hand in hand, however, because I can't talk about why it's fast without saying what it does, and I can't talk about what it is without saying why it is that way. So I'm trapped in a circular dependency. A circular dependency of blogging.

OSGi: Because Sharing Shouldn't Be Painful
At the dawn of Windows, applications were statically linked and life was simple; applications carried their own dependencies so there was never confusion. However, this simplicity had its costs.

Java Reflection: Generics
I have often read in articles and forums that all Java Generics information is erased at compile time so that you cannot access any of that information at runtime. This is not entirely true though. It is possible to access generics information at runtime in a handful of cases. These cases actually cover several of our needs for Java Generics information. This text explains these cases.

Here is a list of the topics covered in this text:
1. The Generics Reflection Rule of Thumb
2. Generic Field Types
3. Generic Method Return Type
4. Generic Method Parameter Types

Defining immutable classes
To make a Java class immutable, you must:
  • Make all fields final.
When you define fields as final in Java, you must either initialize them at declaration time or in the constructor. Don't panic if your IDE complains that you don't initialize them at the declaration site. It'll realize that you've come back to your senses when you write the appropriate code in the constructor.
  • Make the class final so that it cannot be overridden.
If the class can be overridden, its methods' behaviors can be overridden as well, so your safest bet is to disallow subclassing. Notice that this is the strategy used by Java's String class.
  • Do not provide a no-argument constructor.
If you have an immutable object, you must set whatever state it will contain in the constructor. If you have no state to set, why do you have an object? Static methods on a stateless class would work just as well. Thus, you should never have a no-argument constructor for an immutable class. If you're using a framework that requires this for some reason, see if you can satisfy it by providing a private no-argument constructor (which is visible via reflection).
Notice that the lack of a no-argument constructor violates the JavaBeans standard, which insists on a default constructor. But JavaBeans cannot be immutable anyway, because of the way the setXXX methods work.
  • Provide at least one constructor.
If you haven't provided a no-argument one, this is your last chance to add some state to the object!
  • Do not provide any mutating methods other than the constructor.
Not only must you avoid typical JavaBeans-inspired setXXX methods, but you must also be careful not to return mutable object references. The fact that the object reference is final doesn't mean that you can't change what it points to. Thus, you need to make sure you defensively copy any object references you return from getXXX methods.

Reversed type declarations
I can't write about Kotlin without first talking about the folly of "reversed" type declarations. Sadly this disease has afflicted Scala, Gosu and now Kotlin (but perhaps its not yet too late for Kotlin ;-).

Java: Getting the size of an Object
Java was designed with the principle that you shouldn't need to know the size of an object. There are times when you really would like to know and want to avoid the guess work. Measuring how much memory an object uses

Java: How much memory do different arrays consume
Arrays can be large and consume a significant amount of memory. It can me worth choosing the most memory efficient array/collection. Comparing array sizes.

vendredi 22 juillet 2011

Veille technologique semaine 29

Pour le bulletin de cette semaine, je vous propose les sujets suivants :
  • Un bilan six semaine après le jour de l'IPV6 : avez-vous vérifié votre connectivité IPV6 ?
  • Le JDK 7 est toujours prévu pour fin juillet 2011 : quelques vidéos de présentations sur le web.
  • Un article sur le code mal conçus et mal écrit : c'est un problème de qualité non fonctionnel qui se traduit par une bombe à retardement. Il faut être très vigilant sur la qualité de conception, pour éviter une dégénérescence de l'application.
  • Un article d'Oracle au sujet de la programmation concurrente (multi-thread) et du fork / join du JDK 7.
  • Un nouvel article (en français) sur les principes SOLID : Single responsibility principle, Open close principle,  Liskov principle, Interface segregation principle, Dependency inversion principle.
  • Une synthèse du principe d'injection de dépendance.
  • La modularité avec OSGi : l'injection de dépendance avec et sans OSGi.
  • Le primitifs Java sont plus performants que les wrappeurs correspondants : réfléchir à deux fois avant d'avoir des problèmes de performances.
  • Les dépendances cycliques dans un logiciel sont interdites : comment les supprimer.
  • Le JDK 5 et le toString() des tableaux.
Bonne lecture.

Six weeks after World IPv6 Day, what have we learned?
Last month's World IPv6 Day created some excitement about IPv6. Once it was over, however, everyone went back to work—which for most people doesn't include anything IPv6-related.
The idea behind World IPv6 Day on the 8th of June was to flush out broken IPv6 setups by simultaneously turning on IPv6 across a large number of Web properties —including the four largest in the world. Few, if any, problems were reported, so in that sense WIPv6D was a resounding success. Apparently, it's possible to add IPv6 addresses to large Web destinations without significant adverse effects.

Java SE7 To Arrive At End Of July
On Monday, The Java Community Process completed voting on the final approval ballots for Java SE7, and all JSRs were given the green light.

This completes the JCP's work on Java 7, but there's a few more steps to finishing the product, according to Mark Reinhold, the Chief Architect of Oracle's Java Platform Group:

At this point all of the work required to define the abstract Java SE 7 Platform in the JCP is done but the actual product, JDK 7, is not quite finished.

Here at Oracle we're busy wrapping up final testing of the release candidate, build 147. If all goes well then that will be declared the GA build on 28 July per the schedule posted in January. Oracle's commercial binaries, based almost entirely on OpenJDK code, will be published that day; implementations from other vendors will follow.


See the replays for all technical breakouts below:
• Making Heads and Tails of Project Coin, Small Language Changes in JDK 7 (Presentation/PDF)
• Divide and Conquer Parallelism with the Fork/Join Framework (Presentation/PDF)
• The New File System API in JDK 7 (Presentation/PDF)
• A Renaissance VM: One Platform, Many Languages(Presentation/PDF)
• Meet the Experts: Q&A and Panel Discussion

Watch the Java 7 Celebration Webcast
Oracle is committed to Java: the technology, the community, the Java Community Process (JCP), and the entire ecosystem focused on moving Java forward.
Watch this Webcast to find out more about the features of Java 7, hear from technologists at companies that use Java technology, and learn through a series of technical presentations and a panel discussion.

Bad Code: The Invisible Threat
One of the first things said by the non-believers of the software craftsmanship movement was that good and clean code is not enough to guarantee the success of a project. And yes, they are absolutely right. There are innumerable reasons which would make a project to fail ranging from business strategy to competitors, project management, cost, time to
market, partnerships, technical limitations, integrations, etc. Due to the amount of important things a software project may have, organizations tend not to pay to much attention to things that are considered less important, like the quality of the software being developed. It is believed that with a good management team, deep hierarchies, micro management, strict process and a large amount of good documentation, the project will succeed.

How do the new fork/join tasks provided by Java SE 7 make it easier to write parallel programs?

Multicore processors are now widespread across server, desktop, and laptop hardware. They are also making their way into smaller devices, such as smartphones and tablets. They open new possibilities for concurrent programming because the threads of a process can be executed on several cores in parallel. One important technique for achieving
maximal performance in applications is the ability to split intensive tasks into chunks that can be performed in parallel to maximize the use of computational power. Dealing with concurrent (parallel) programming has traditionally been difficult, because you have to deal with thread synchronization and the pitfalls of shared data. Interest in language-level support for concurrent programming on the Java platform is strong, as proven by the efforts in the Groovy (GPars), Scala, and Clojure communities. These communities all try to provide comprehensive programming models and efficient implementations that mask the pain points associated with multithreaded and distributed applications. The Java language itself should not be considered inferior in this regard. Java Platform, Standard Edition (Java SE) 5 and then Java SE 6 introduced a set of packages providing powerful concurrency building blocks. Java SE 7 further enhanced them by adding support for parallelism.

Les principes SOLID
A l'heure où de nombreux débats font rages sur l'éventuel successeur du langage Java, le XKE (Xebia Knowledge Exchange) de Mars a été l'occasion de faire un retour sur les fondamentaux de la conception Orienté Objet.
Faisons un petit sondage dans la communauté : quels arguments avanceriez-vous en faveur du langage Java ?
Parmi les principaux arguments, il est fort à parier que les réponses seront en majorité les applets (heu… non plus maintenant… mais souvenez vous dans les années 90), la JVM, le crossplatform, le monde Open Source et la Communauté, les nombreux frameworks, la simplicité d'écriture et la gestion de la mémoire, les IDEs, etc.

A beginners guide to Dependency Injection
This article presents a high level overview of Dependency Injection (DI). It aims to present the overall  concept of Dependency Injection to the junior developer within the context of how it could be used in a  variety of DI containers.

Dependency Injection (DI) or Inversion of Control (IOC) ?

OSGi: A Proven Approach for Developing Modular Applications
OSGi is about how to create a useful application by installing a set of (preferably reusable) modules in a framework. Basically, we set out in 1998 to solve the component programming model; amazingly I think we largely succeeded looking at the many successful OSGi projects. Mission accomplished?
comment on this article Not really, looking at the often heated debate around OSGi in the Enterprise world: Spring, Jigsaw, etc.
Many love it, some seem to hate it with a vengeance (Come on guys, get a life, this is only technology). My explanation is that OSGi violates some Enterprise developers' basic expectations that it should just be a library on your class path, providing some useful and convenient functions but otherwise staying out of the way.

Low GC in Java: Use primitives instead of wrappers
There are two good reason to use primitives instead of wrappers where possible. Clarity. By using a primitive, you are making it clear that a null value is not appropriate.
Performance. Using primitives is often much faster. Clarity is often more important than performance, and is the best reason to use them. However, this article discussed the performance implications of using wrappers.

Breaking Dependency Cycles
If you look into rules for good software design you!ll probably come around the notion that dependency circles are bad. From my interview experience I!d say that many of the more experienced developers know that rule. And almost everybody agrees to that rule when asked. (Of course that might be due to the way I phrase the question. Some people say I can be pretty … convincing).

Stringifying Java Arrays
J2SE 5 provided significant new language features that made Java significantly
easier to use and more expressive than it had ever been. Although "big" new J2SE 5  features such as enums, generics, and annotations, there was a plethora of new APIs and methods that have made our lives easier ever since. In this post, I briefly look at two of my favorites when dealing with Java arrays:
the Arrays.toString(Object[]) method and the Arrays.deepToString(Object[]) method.

vendredi 8 juillet 2011

Veille technologique semaine 27 et 28

Pour le bulletin de la semaine 27 et 28, je vous propose les sujets suivants :
  • Le site Twitter qui passe du langage Ruby au langage Java, pour des raisons de performance mais aussi de maintenance plus productive avec un langage à typage fort : Java par rapport à un langage à typage faible : Ruby.
  • Deux articles au sujet des expressions lambda ou closures : explication et historique.
  • La version 3.7 d'eclipse qui vient de sortir inclus un composeur visuel pour les IHM en Swing, SWT (Standard Widget Toolkit) ou GWT (Google Web Toolkit) : WindowBuilder.
  • Le compte rendu du club Java de PARIS pour la soirée sur le cloud : résumé.
  • Un article sur la machine virtuelle IKVM qui est capable de faire tourner du byte code Java sur la machine virtuelle DotNet. Il est possible d'utiliser le framework DotNet avec du code source Java.
  • Cinq articles qui résume la modélisation UML pour les développeurs Java.
  • Un exemple de code Hello World en Java et en Ruby
  • Un article sur Java qui explique pourquoi il est interdit de faire un return ou de lancer une exception dans un bloc finally.

Bonne lecture

Twitter Shifting More Code to JVM, Citing Performance and Encapsulation As Primary Drivers
While it almost certainly remains the largest Ruby on Rails based site in the world, Twitter has gradually been moving more and more of its stack to the JVM. The change is partially motivated by oft-cited advantages of the JVM, such as performance and scalability, but is also driven by a desire for better encapsulation of individual services, and other architectural concerns.

Closures for Java "BGGA" project
  • BGGA closures specification: Closures for the Java Programming Language (v0.5)
  • Doug Lea's jsr166y fork-join concurrency framework: without function types and with function types. Get the code here.
  • Latest openjdk prototype: (updated 2008-08-11)
  • Neal's talk about BGGA closures with Q&A
  • Differences between the openjdk prototype and the spec (v0.5)
  • Open issue list: Closures: Open Issues (v0.5)
  • Homepage for the openjdk closures project
  • A library for functional programming.
  • A definition of closures
  • comment on extension methods

A Definition of Closures
There has been some confusion over our proposal to add closures to the Java Programming Language. After all, doesn't Java already have closures in the form of anonymous inner classes? What is the point of adding something to the language that it already has? To some there appears to be a lot in the proposal that has nothing to do with closures, including the control invocation syntax, null as a type, Unreachable, throws type parameters, function interface types, and "nonlocal" returns. In my Javapolis talk I tried to give an explanation for why these features are in the proposal from the practical point of view of what kinds of things would be possible that were not formerly possible. But that begs the question: why do we call it "Closures" for Java? In this blog post I'll try to show how the definition of closures relates to the features of the proposal, and identify which features of the proposal do (and which do not) result from the definition.

WindowBuilder Pro Quick Start

Paris JUG "Cloud"
Voici la retranscription de la soirée du Paris JUG du 5 juillet, dédiée au Cloud.
A l'origine, seul Patrick Chanezon devait intervenir, mais toute la clique du cloud à
la Française ayant été prévenue de la soirée, ce sont finalement 6 speakers qui se
sont partagés la scène - même si les derniers ont dû parler très vite compte tenu du planning particulièrement serré !
Cloud par-ci, cloud par-là, tant et si bien qu'en sortant il pleuvait... Les aléas de la
météo font parfois écho à ceux de la technique.

IKVM Introduction
IKVM.NET is an implementation of Java for Mono and the Microsoft .NET Framework. It includes the following components:
  • A Java Virtual Machine implemented in .NET
  • A .NET implementation of the Java class libraries
  • Tools that enable Java and .NET interoperability

UML for the Software Developer, Part 1: Building Classes
Whatever language you code in, however you feel about documentation, and whichever process you ascribe to—you will need to model. Whether those models are in a formal charter, reference document, part of a diagram, or on the back of a napkin, you as a software developer will end up using models or modeling yourself.

Why do we need to model software? After all, aren't the acts of coding and refactoring of that code enough? That depends on what is meant by enough! You could code up some software, hand it in, and go through a constant refactoring process with the client. This is how most software is developed today. However, times are changing. A decade ago, a game would have been developed by a single developer in the basement. Graphics were primitive and it was enough to produce a few sprites, some cute screens, and an occasional story line.

UML for the Software Developer, Part 2: Mastering Associations
Associations are a key part of the UML lexicon. Use them to define the ways in which your application's classes communicate. In this article you'll see that adding a database introduces design patterns for the first time using the façade pattern.
by Mark Goetsch lasses are only the first step to understanding UML. In my last article I discussed classes in UML and how they are coded using C#. In this article I will tie-up a few loose ends by describing how classes are arrived at and then march into how they relate to each other in UML using associations.

UML for the Software Developer, Part 3: Aggregating
Part 3 of this series on UML tackles aggregation, which is a special form of association.
Part 2 showed you how associations related one class to another, but this article shows that associations are not strong enough when you need to specify ownership.

In Part 2 we looked at associations, which are nothing more than references, but they can be directional and represent multiplicity. If we were restricted to our ability to generate code using UML this would be sufficient. If we
are offering guidance on how the application should be built, as well as auto-generated code, we need something more.
To continue with examples from the previous articles, your friends at Rich Men, Inc want to start tracking what stocks they buy for their clients. Ideally they would somehow offer some aggregated values for all of the stocks that a client has in order to boost their value to the client.

UML for the Software Developer, Part 4: Deployment Diagrams
Deployment diagrams act as the link and reference point between how the system is built and where it is displayed. Learn how capacity planning, n-tier development, and coordination of tasks between different teams can all benefit from these diagrams.
So far, you and I have journeyed through the realm of class diagrams. Classes are a good start for understanding how an application is hooked together, and while they describe the static relationships between the objects in the system, classes are just an abstraction of the software itself. What happens after the classes are
built? The answer is, of course, that they need to be deployed. But where? How do I model deployments? The answer is a new diagram type—the deployment diagram.
Deployment diagrams are one of the least understood—and most important-diagrams in the UML pantheon. Many developers don't even know what they are, yet consider themselves experts in UML. The purpose of a deployment
diagram is to model the execution environment for a project. They can also be used to describe the enterprise environment, but this is more the enterprise architect's domain.

UML for the Software Developer, Part 5: Component Diagrams
Their ability to show interdependencies between applications' components make
component diagrams invaluable. They can however be surprisingly complex. Find out how to use the right architectural patterns within your component diagrams to make them manageable.
According to Clemens Szyperski (author of "Component Software—Beyond Object-Oriented Programming,"), software components are binary units of independent production, acquisition, and deployment that interact to form
a functioning system. He continues to add that a software component can be deployed independently, is a unit of third-party composition and has no (externally) observable state. In UML we use component diagrams to break down systems into understandable chunks that show the dependencies between components.

Do not return in a finally block: return will swallow your exceptions
I was recently working on a code, which was failing without giving any exception.
So I had to add lots of logging to the code, to see where is the bug. I caught nothing via this method.
So I decided to check out the module source code and yeah finally I found it while
debugging. The module was correctly implementing what was required and
generating the required Exception as expected.

vendredi 1 juillet 2011

Veille technologique semaine 26

Pour le bulletin de cette semaine, je vous propose les sujets suivants :
  • le prochain standard C++ devrait être prêt avant la fin de l'année. Le précédant date de 1998.
  • Oracle confirme que OpenJDK est l'implémentation de référence qui sert de base à la distribution d'Oracle.
  • Changement du look de la Javadoc du JDK7 : changement des stylesheet.
  • Un résumé de la présentation du framework Akka : le pattern actor pour des systèmes distribués, scallable et tolérant au panne.
  • Un chapitre : la meilleur ligne de code est celle qui n'est pas nécessaire. Pourquoi réduire le nombre de lignes de code.
  • Présentation d'un runtime pour faire exécuter les applications android (présent sur les smart phones et tablettes avec le processeur ARM) en natif processeur x86 sur windows.
  • Le pattern object null en remplacement des exceptions NullPointerException : l'invention qui a coûté très chère.
  • La gestion des ressources dans la syntaxe du JDK 7
  • Les classes atomiques du JDK 5 : comment faire des lecture-modification-ecriture sans verrous.
  • La classe Objects du JDK 7 et la méthode equals().

Bonne lecture

The New C++: Lay down your guns, knives, and clubs
"The world is built on C++," Herb Sutter tells The Reg. Considering he's one of the language's chief stewards, we question his impartiality. But he does have a point. After more than 30 years – depending on whose numbers you swallow (these or these) – C++ remains one of computing's most popular programming languages, favored for its speed if not its simplicity.
Apple's Mac OS X, Adobe Illustrator, Facebook, Google's Chrome browser, the Apache MapReduce clustered data-processing architecture, Microsoft Windows 7 and Internet Explorer, Firefox, and MySQL – to name just a handful – are written in part or in their entirety with C++.

And while new languages have since been born, C++ has endured. Java is the only one to have outpaced it in popularity, according to the TIOBE Index. PHP, Ruby, and JavaScript? Sure, some might claim that they are the future, but C++ is the past, the present, and the future.

According to Sutter, C++ is on the verge of its biggest change in the 13 years since it became an official ISO standard, a change that will make it relevant for the next two decades.
The recently finished C++ ISO standard, with the working name of C++0x, is due to be published this summer, following the finishing touches to the ISO spec language and standards wonks agreed upon in March.

Sutter didn't create C++, but he is chair of the ISO's C++ committee in addition to being a noted C++ programmer, author, and chief native-languages architect at Microsoft.

OpenJDK to be Java SE 7 Reference Implementation, Bylaws Ratified by Oracle
The OpenJDK Community Bylaws have been ratified, with 70 votes in favour, no votes against, and nine abstentions. Whilst this represents a major milestone for the OpenJDK project, building from an effort which was started by Sun in 2007, it should be noted that 61 of the yes votes were from Oracle employees, and 46 people who were eligible to vote didn't bother.

New Java SE 7 Javadoc API Documentation Appearance
In my last post, I briefly referenced the Jonathan Gibbons's post What's Up, JavaDoc? that describes some recent changes to Javadoc, including changes that allow a CSS stylesheet to be applied to the documentation. Mark Reinhold's post JDK 7: Are we there yet? talks about the changes to the Java SE 7 API default display style. In this post, I briefly look at this change.

Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors"
Lors de la What's Next, Jonas Bonér a présenté Akka, un framework facilitant la réalisation d'applications concurrentes, pouvant passer à l'échelle et tolérantes aux erreurs. Cet article tente de retranscrire le contenu de cette présentation.

Chapter 14. Writing Less Code
Knowing when not to code is possibly the most important skill a programmer can learn. By reusing libraries or eliminating features, you can keep your code base lean and mean. Every line of code you write is a line that has to be maintained.

The most readable code is no code at all.

The best way to cope is to keep your code base as small and lightweight as possible, even as your project grows.

Native x86 Android runtime will enable Android apps on Windows
A startup called BlueStacks has developed an Android runtime environment for the Windows operating system. It will enable users to run Android applications alongside conventional Windows software on Microsoft's operating system.
The technology impressed some major investors who have supplied $7.6 million in Series A funding so that BlueStacks can turn its software into a business.

Presentation: "Null References: The Billion Dollar Mistake"
Abstract: I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years. In recent years, a number of program analysers like PREfix and PREfast in Microsoft have been used to check references, and give warnings if there is a risk they may be non-null. More recent programming languages like Spec# have introduced declarations for non-null references. This is the solution, which I rejected in 1965.

Better Resource Management with Java SE 7: Beyond Syntactic Sugar
The typical Java application manipulates several types of resources such as files, streams, sockets, and database connections. Such resources must be handled with great care, because they acquire system resources for their operations. Thus, you need to ensure that they get freed even in case of errors. Indeed, incorrect resource management is a common source of failures in production applications, with the usual pitfalls being database connections and file descriptors remaining opened after an exception has occurred somewhere else in the code. This leads to application servers being frequently restarted when resource exhaustion occurs, because operating systems and server applications generally have an upper-bound limit
for resources.

Java theory and practice: Going atomic
Summary: Until JDK 5.0, it was not possible to write wait-free, lock-free algorithms in the Java language without using native code. The addition of the atomic variable classes in java.util.concurrent changes that situation. Follow along with concurrency expert Brian Goetz as he explains how these new classes have enabled the development of highly scalable nonblocking algorithms in the Java language.

Java 7 Objects-Powered Compact Equals
Obi Ezechukwu's blog High-Octane Java recently featured the post Compact Equals, which compares an implementation of a Java class's overridden equals method in traditional form versus one implemented using arrays of the class's fields and then invoking Arrays.equals on those arrays. I am using this blog post to build upon these examples to demonstrate the utility of Java 7's Objects.equals(Object, Object) method and will demonstrate the usefulness of Objects.hash(Object...) along the way.