Devoxx France 2012 day 3

I didn’t take notes on this one because my computer rebooted 🙃

Mobile is becoming strategic to the business: it’s beginning to be the equivalent to CRM, portals, and such other assets.
On the development side, mobile development is akin to traditional development. There are a couple of differences however: development cycles are very short (weeks) because time-to-market is very quick, hardware manufacturers release more often leading to a very fragmented market and we are back to client server architectures.

IBM recently acquired Worklight, a framework to address all the previous strategies, and also deal with security, SSO, integration in so on. Worklight provides a IDE, a server, runtime components and a web-based console to monitor mobile applications and infrastructure.

The guy is not bad, there’s some interesting info, but a sales pitch at 9 in the morning makes me regret not to have stayed later in bed.

The story is about George, a JavaEE developer that work for top companies. Anyway, after 3 years work, the AZERTY project is put into production: GUI is bad, the IT director is happy, users hate it. George is happy, he loves complexity and nobody understand how the system work, save him. George is promoted Project manager, then Project Director. One day, when George go into a OSS meeting, he hears new terms: Hibernate, agility, and such. Yet, instead learning those new techs, he learns golf and code no more. Since he now has budget, he brings in agile coachs into his company: it fails abismally. Finally, he becomes IT director…​ Users reject his new project AZERTY 3.0 and users use Google Apps behind his back. His boss now demands iPhone and Android applications for. He cannot code it and is finally fired.

What happened while George learned to play golf? The last 2 years saw a paradigm shift that happens every 15 years:

Standards analyst segregate Cloud into Saas, PaaS and IaaS as a pyramid. For developers, PaaS is the most important, which is something alike to the operating system. The trend is now Developing as a Service. Interestingly enough, though platforms become more industrialized, software development moves toward craftmanship.

Historically speaking, Cloud began at consumer websites solving their own needs (like Google, Amazon, and others). Nowadays, IaaS is becoming mainstream, but you still need to build and maintain your own software infrastructure. For example, when Amazon failed last year, 3 startups survived the outage, those that built their own platform.
The software development process is about to change. Business-to-consumer applications are becoming like haute couture, with new applications coming in everyday. Some applications have even short life expectancy (like Devoxx France application). Thus, development cycles have to be shortened in parallel, hence Agility. Cloud let us become more agile, by cutting us off from infrastructure.

The main risk of Cloud infrastructure is the vendor lock-in. Cloud Foundry resolves the problem by providing an Open Source product. For example, AppFog uses Cloud Foundry and added PHP. Likewise, you can create you own private cloud to host it on your own infrastructure.

There are a couple of things to learn from that:

In conclusion, George buys an iPhone, codes a little bit everyday, read programming books and is happy again! Besides, he stopped playing golf. The rest is up to you…​

Wow, the man is really good, as well as the session. If you missed the keynote, see it on Parleys ASAP.

As developers we think about abstractions, because if there weren’t any, we would have to deal with 0 and 1 and we couldn’t get anything done. And yet, by using abstractions, we sometimes forget they are only abstractions, and tend to consider them as the real thing.

Let’s take a simple document. How can you ensure that a Chocolate Cake Recipe could be saved for hundred years? Put it in a Word document? Probably not…​ Getting to text format would be better, but raises encoding issues. If you’re a government agency, stakes are higher. The goal is not to save the document, but the information.

For example, emacs tapes are still available, but there’s nothing to read them.

[Other fun examples are omitted because I couldn’t type fast enough and the whole thing is based on pictures]

Dietzler’s law: using a tool like Acces (or nay contextual tool), 80% of what the user wants is very easy, 10% is hard to implement and the last 10% cannot be achieved because you have to go beyond the abstraction and that cannot be done.

Any tool (like Maven), has a tipping point. Because once you’ve gone beyond that, it will never ever be wonderful again. At this time, you’ve got to cut and run but it will be hard because you’ll be imprisoned by the abstraction.

Wow! I missed Neal’s session on the first day and I regretted it at the time. Now, I regret it even more. The previous keynote raised the bar very high, Neal passed it with flying colors. Anyone wanting a real show (with content to boot) should attend Neal’s session given the chance. Besides, you could even get his wife’s Chocolate Cake recipe 🙂

New languages seem to bloom every so often, but the last year so announcements from enterprises (Red Hat’s Ceylon, JetBrains’s Kotlin and Google’s Dart). Here’s my chance to have a talk from someone very close to one of Kotlin’s inception.

JetBrain’s motto is develop with pleasure. There are other products beside IntelliJ’s IDEA (TeamCity, PHPStorm, and others). Kotlin is: statically typed, running on the JVM, OSS and developed by JetBrains with help from the community. Why Kotlin? Because IntelliJ’s IDEA is based on Java and though it’s not the best fit, other languages are not better.
Goals include:

Performance are to be found in different areas: no autoboxing, no constant runtime overhead in generated code and a low compilation time. Kotlin is easy to learn; there’s no distinction between libray devlopers and 'standard' developers (as in Scala). It focuses on best practices taken from other languages. This leads to no ground-breaking features, only common sense.

[Follow a bunch of code snippets]
At first, it seems akin to Scala with fun replacing def: there are Scala-like constructors, vals and vars, traits, reversed-order type/name declaration (separated by double colons)

Extension functions seem nice enough: you can not only extend types, but also functions without bothering to inherit the whole nine yards. Also, in Kotlin, functions are first-class citizens (in short, you get closures with type inference). Interestingly enough, it is by default the first argument of the function literal (as in Groovy).

An interesting feature of Kotlin is the usage of the dollar sign to reference variable inside Strings, so as to have variable replacement at runtime.

There’s a limited form of operator overloading: only a subset of operators are available to be overloaded, as it needs to be done through a specifically-defined function. For example, to overload the -, you need to ovveride the minus function.

In order to manage nullability, Kotlin allows the ? operator to only allow safe calls (as to Groovy again). For example, the following snippet returns the list size or 0 if the list is null:

The question mark marks the return type as nullable, otherwise, it’s not nullable and the compiler complains; it makes the core more concise as well as provide as safety net for handling null values.

Kotlin also provides pattern matching (as in Scala, the syntax being very similar). An improvement over Groovy’s builders, Kotlin’s are typesafe: for example, the HTML builder checks for validity at compile-time!

More features include:

Not an uninteresting talk, but there was some passion lacking in the speaker. The get-what-works-from-other-languages strategy is a very interesting one. At least, you get the best of many world out-of-the-box. I see a big problem however, how does JetBrains plan to ensure backwards compatibility if they get their critical mass. The answer from the speaker is:

Food for your thoughts (directly from the speaker): if JetBrains had known that Ceylon was being developed, it probably wouldn’t have started the project.

OK, I’m a bit of a masochist considering the presales talk from IBM, but I’m really interested in GUI and perhaps JavaFX next version is the right one (considering Flex’s fate).

The talk begins by the speaker asking to remove all misconceptions about JavaFX (good idea). JavaFX is a complement of Swing, SWT and HTML5. On Android and iOS, it works! The last addition to the JavaFX ecosystem is JavaFX scene builder.

JavaFX goals were to achieve:

JavaFX 1.0 receveid a bad feedback from the developers, they didn’t want to learn a new scripting language. Current version is JavaFX, available since 2011 on Windows (Mac OS and Linux are nearing GA completion). On the tooling side, NetBeans 7.1, 7.2 and Scene builder are provided. The community has already taken care of some integration plugins in Eclipse, while JetBrains has made contact to integrate JavaFX development in IntelliJ IDEA.

Currently achieved goals include: inclusion in the OpenJDK (through OpenJFX) and a common license with JDK. For the latter, note that JavaFX will be part of JavaSE from JDK 8. Oracle policy is to submit JSR to the JCP for standardization.

With JavaFX, you can use the tools you want, benefit from all Java features (generics, annotations, etc.) or even use your preferred language that run on the JVM. In JavaFX 2, the FXML markup language is available for UI defintion (just like MXML in Flex). Alternatively, you can still code you UI programmatically. FXML can be laced with scripting languages, such as JavaScript and Groovy.

On the graphics side, the architecture (Prism) makes it possible to use the best of hardware acceleration. The new windowing toolkit is called Glass. Its use make it possible to access advanced function (buffering, etc.). Supported media format include VP6, H.264, MP3 and AAC (very akin to supported HTML5 media formats). Moreover, JavaFX embeds the WebKit rendering engine, thus making it possible to interpret HTML and JavaScript in Java applications. Bidirectional communications are possible between the Java and the WebKit part. With WebKit’s usage, you get multiplatform testing for free.

Swing and SWT can be gradually migrated to JavaFX, through seamless integration of the latter in the existing UI. A big difference with Swing/SWT is the ability to use CSS to style your JavaFX components, hence you can reuse the same stylesheet on the web and on JavaFX. As a sidenote, there’s an already existing community around OpenJFX. Other contributions include Eclipse and OSGi plugins, DataFX (datasource access), ScalaFX and GroovyFX, frameworks (already!) and JFXtras (additional UI controls and extensions).

Last week, the JavaFX Scene Builder release was announced. It’s a visual development tool for GUI; drag-and-drop is supported. Integration with NetBeans comes out of the box, but it can be used with other IDE (since it’s a standalone tool). It’s entirely developed in JavaFX and available for Mac OS X and Windows.

The roadmap is the following:

[Talk ends with both a 3-tier demo, with the GUI developed in JavaFX with CSS and Scene Builder demonstrating Drag-and-Drop]

Mono tone speaker, I had to fight agains sleep. On a more positive note, this wasn’t a sales pitch but there were some interesting pieces of information. The speaker also presented an iPad running a JavaFX using the hardware accelerometer.

The session is about the inner workings of caching. Guava is an OSS of low level Java librarires. The package com.google.common.cache contains simpel caching.

LoadingCache automatically loads entries when a cache miss occurs, while Cache doesn’t. The delegate CacheLoader interface knows how to load entries.

Concurrency is internally handled very similarly to ConcurrentHashMap. In the case of exceptions occuring during load, you have to catch runime exceptions and rethrow checked IOException. For keys that are transient, a fluent weakKeys() method on the builder allow for weak references. In contract, to allow the garbage collector to collect cached values, the softKeys() method is used (there have been performance issues however, this use is discouraged).

The next step is to be able to analyze cache: just use the recordStats() method. A CacheStats is returned by the stats() method on the cache object and allows for querying. Having analyzed the cache, it’s now possible to tweak the configuration: you have to create a string containing key-value pairs and pass this to the builder.

Guava also provides an event-listener model around the cache. Builders allow for listener registration through the removalListener that takes RemovalListener instance as a parameter. Of course, you can have multiple listeners by registering more than one object. The listener is called whenever an entry is evicted, whichever the stragegy used. By default, listeners are called synchronously: it’s advised to make listeners asynchronous if they are heavyweight (or wrap them inside RemovalListener.asynchronous).

Guava also provides two different ways for refreshing the cache:

Asynchronous refresh shall be implemented to avoid blocking user thread. Just use Java’s FutureTask…​

Sometimes, it’s more efficient for a cache loader to load a set of entries at the same time than one at a time. This is accomplished by overriding CacheLoader.loadAll() and LoadingCache.getAll(). The latter does not block multiple requests for the same key.

So far, cache is fed by the cache loader. However, how can we handle specific use-cases to manually populate the cache? This is simply done with ifPresent() to query if a key is present and put() to put an entry in the cache.

In order to implement non-loading caches, we don’t need CacheLoader at all. When calling CacheBuilder.build(), you get one such cache. In order to disable caching, the current canonical way is to set the maximumSize to 0. This can be done at runtime through CacheBuilderSpec class.

Caches can be iterated over like maps with Cache.asMap(). All ConcurrentMap write operations are implemented, but it’s discouraged to use them (use CacheLoader or a Future instead). Be warned that both get() methods have similar signatures but they are different (Map.get() is in fact a "get if present").

Future works include:

A very nice talk. 'Nuff said. A bit disappointed by the lack of knowledge of the Guava team in the Java Caching API though (a JSR).

This talks is about what’s .Net and what’s lacking in Java?

For a Java developer, .Net was something akin to the blue skin of death. From a more rational point of view, let’s remember at first that Sun and Microsoft were neighbors at first.

Remarkably, Sun took a very long time to ship Java 5. The .Net framework matched Java’s features in version 2.0 and soon went beyond them. .Net principles are exactly the same; only some coding standards are somewhat different. .Net is polyglot from the start (C=, Iron Ruby, Iron Python, F=, …​). In order to seduce C++ programmers, Microsoft provided low-level API.

Some features are really better in C= than in Java (or more precisely, already available):

On the portable side, the Apache Mono project let developers program in and deploy on Linux and Mac OS X. Still, in order to maximize decoupling, do not forget to use proprietary products (SQL Server for example). Though .Net is seen as autocratic, alternative communities exist, such as Alt.Net.

As a conclusion, here are some messages:

A definitely good presentation on the benefits brought by looking over the gap, thanks to the well-oiled tongue-in-cheek exchanges between the two speakers (real pleasant teamwork, guys).

And it is the end of the Devoxx Fr 2012. See you next year, guys and thanks to all for all the great time there.