When I blog about a day’s sessions, ideally I try to select a few sessions, the most interesting ones. But sometimes there are so many good sessions that it becomes really difficult to short-list them. Wednesday (javaOneDays[3]) was such a day when three of my Top 5 sessions took place. As an attendee it is a wonderful thing. However as a blogger it makes life harder.

JavaOne Schedule Builder Kiosk that I mentioned in a previous blog entry.

The first session of the day was about Servlet API 3.1 and it was entitled What’s New In Servlet 3.1: An Overview. Servlet API is most of the time too low level to be directly used in Enterprise software development but it is important to at least be familiar with it not only because sometimes it becomes necessary to use it also because it is the underlying technology of many other Java APIs and frameworks.

During their talk, the speakers classified the new and noteworthy under 3 main headings:

• Scalability (e.g. exposing non-blocking IO API)
• Support for newer technologies that use HTTP (e.g. WebSocket)
• Security enhancements

Non-Blocking IO API

If you’ve worked with the Servlet API before then you know that reading from the ServletInputStream and writing to the ServletOutputStream are blocking operations. The addition of non-blocking IO to the Servlet API introduces new APIs to ServletInputStream and ServletOutputStream, and two new event listeners: ReadListener and WriteListener. 

We can now set a ReadListener by using ServletInputStream‘s new setReadListener() method. There’s also a new setWriteListener() method in ServletOutputStream. Because those listeners are used for non-blocking IO, there are also new verification methods such as SetvletInputStream.isFinished(), ServletInputStream.isReady() and ServletOutputStream.canWrite(). As one of the attendees highlighted it, it is surprising to see that the draft specification includes a conflicting naming convention: isReady() and canWrite(). Why not canRead() and canWrite()? Or even isReady() for both interfaces?

Here’s how those new event listener interfaces look like:

public interface ReadListener extends EventListener {
  public void onDataAvailable(ServletRequest request);
  public void onAllDataRead(ServletRequest request);
  public void onError(Throwable t);
}

public interface WriteListener extends EventListener {
  public void onWritePossible(ServletResponse response);
  public void onError(Throwable t);
}

For example, rather than using the blocking read() method of ServletInputStream we can use the setReadListener() method and execute the reading operation within our ReadListener implementation.

From the examples given during the talk I much preferred the one that combined non-blocking IO and async processing. The simple doGet() method looked like this:

ServletInputStream sis = request.getInputStream();
ServletOutputStream sos = request.getOutputStream();
AsyncContext ctx = req.startAsync();

sis.setReadListener(new SimpleReadListener(sis, sos, ctx));

int b = -1;
while (sis.isReady() && ((b = sis.read()) != -1)) {
  sos.write(b);
}

if (sis.isFinished()) {
  ctx.complete();
}

And the SimpleReadListener looked like this:

public class SimpleReadListener implements ReadListener {
  ...
  public void onDataAvailable(ServletResponse resp) {
    ...
  }

  public void on AllDataRead() {
    ...
    ctx.complete();
  }

  public void onError(final Throwable t) {
    ...
  }
}

Protocol Upgrade

Protocol upgrade is part of HTTP protocol. It allows an already established connection to switch to a new and incompatible protocol. When the client initiates a request (GET, POST, etc) it can insert an Upgrade header to it indicating the desired protocols in order of preference. Upon receipt of request, the server can accept or refuse the new protocol.  If the server accepts the protocol upgrade then it sends back a 101 Switching Protocol along with an Upgrade header containing the chosen protocol.

Using Protocol Upgrade the client and the server can switch from HTTP 1.1 to another protocol such as HTTP 2.0, SHTTP 1.3, IRC 6.9 or Web Socket. For example:

Client:

GET /chat HTTP 1.1
Host: server.mycompany.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key:...
...

Server:

HTTP 1.1 101 Switching Protocol
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept:...
...

Servlet 3.1 adds 2 new interfaces to the javax.servlet.http package: ProtocolHandler and WebConnection. It also adds a new method to HttpServletRequest: upgrade(ProtocolHandler handler).

As part of their talk the presenters created an EchoProtocolHandler that implemented the new ProtocolHandler interface. An instance of EchoProtocolHandler was then used as the parameter to the new upgrade() method call to demonstrate upgrading to a simple echo protocol.

Security Enhancements

The new specification brings clarifications on various areas such as:

• run-as in the case of #init and #destroy.
• default security semantic for non-specific HTTP methods
• in a case where the same parameter name is used in the query string and as part of the POSTed parameters (what is its value?)

It also provides protection against some known security problems such as the Session Fixation Attacks.

Max Katz‘s Building HTML5 Mobile Apps with Cloud Services made my Top 3 sessions list in this year’s JavaOne. He was a great and engaging speaker who mastered his subject and used his presentation material adroitly. He talked about Tiggzi and I was really impressed by this tool. You can probably guess the nature of this session by the fact that Max only had a single slide for the whole hour. Executed well, this type of slideless, live-demo-centric presentations can be the best type of technical sessions. Throughout his talk, Max incrementally developed a live application. As of this writing, the last version is still live on tinyurl.com/javaone13. Unfortunately the app was modified towards the end of the session to demonstrate tiggzi’s capability of working with any existing RESTful services, which now points to the Devoxx‘s schedule.

Tiggzi is a cloud-based mobile application IDE. An application built by Tiggzi uses the following technologies:

• jQuery Mobile
• HTML5, CSS
• JavaScript
• PhoneGap

Tiggzi is a Web-based tool and it has a very slick UI. The components of the developed application are put together using drag & drop. The first application that Max built (I keep thinking about writing “we built”. I guess I felt it so because the presentation was very engaging and also because we, the audience, became testers using our mobile phones to validate the newly built application) was a twitter search app. Max quickly put together a few components to prepare the app visually. On the left hand side of the tool, there was a component gallery to choose from. Creating the UI looked as simple as dragging the desired components and dropping them on the phone view that sits in the middle, on the main panel.  And the selected component had its properties and its possible event bindings on the right hand side of the screen. Testing looked very simple: it was a matter of hitting the “Test” button.

Tiggzi knew how to consume JSON and XML services. Using twitter’s existing REST services, Max provided the necessary data to the application. He entered the service URL, added service request parameters and tested the service endpoint as a verification. The service endpoint was set up correctly so he defined the response structure. Mapping the service to UI components was done using drag & drop as well. I liked the way that it was represented with the request or response structure on the left, the UI component tree on the right and various arrows from left to right connecting them.

After that the app was just working. Max built an APK and at the same time the app was published as a Web app so that we, the attendees, could access the app using our own phones. Even though the requirements were very simple (twitter search), using tiggzi, it was extremely quick to achieve the desired happy path. Tiggzi also had a database console where Max could create an application database. The remaining of the session Max improved the application incremental additions.

I had some of our RESTful services in mind when the realization struck me. And I got the confirmation from Max: Tiggzi works with public services. It can’t create an app that integrates with your company’s private services. The service endpoints need to be public. But I’m signing up for a free trial nonetheless. I’d like to try tiggzi for myself.

The following session was another one that made my Top 3 list: Incompetence * Motivation = Innovation? (How Kotlin and Other New Things Emerge) presented by Andrey Breslav, Lead Language Designer in JetBrains.

Andrey started his talk by explaining why listening to incompetent people was important. They have requests to make their lives easier however, most of the time, they don’t know what they are talking about. Even though you say “it doesn’t work that way” or “it’s not possible”, their message is clear: “change the world” because they can think out-of-the-box without knowing it. Incompetence is great for requirements. Competence is great for implementation.

After briefly explaining the reasons why a new language makes sense, Andrey cited some of the common language complaints that he keeps hearing and explained how Kotlin addresses those issues :

• We hate writing stupid constructors!
• And getters/setters!
• We want to use fields!
• Can’t I just say 3.toString()?
• String doesn’t have enough methods!
• One return value is too restricting!
• List<String> contains objects, doesn’t it?
• Can you figure out those nulls?
• Doesn’t know that <TD> must be inside a <TR>?
• I could use it for the browser, types and all.

Kotlin is a statically-typed JVM-targeted programming language. I like its “for industrial use” label. Code written in Kotlin compiles at least as fast as its Java counterparts. And one of the things I really like about Kotlin is its approach to nullable types and NullPointerException. Its type system is designed to prevent unwanted NullPointerExceptions. Kotlin (or rather its type system) distinguishes between nullable and non-nullable references. (Andrey mentioned that they had a tool (also still in development) that was capable of scanning the standard Java libraries to find nullable objects).

For example, the following name variable is not nullable and the second line causes a compilation error:

var name : String = "yagiz"
name = null // compilation error

The following declaration allows nulls:

var name : String? = "yagiz"
name = null // no error

The question mark that follows the type does the trick and indicates that this is a nullable type.

Kotlin has also a safe call operator (?.):

name?.length()

The call above returns name‘s length if name is not null or it returns null otherwise.

And if you still want a NullPointerException thrown when name is null then you can use the !! operator:

val length = name!!.length()

Compare to Scala this produces a better approach because it’s less verbose and Scala’s Option type comes with runtime overhead as its values are wrapped into Option objects.

Kotlin has other pretty cool features such as Closures, Extension Functions (two of the rare things that I like about Objective-C are the similar Categories and Class Extensions), Variable Type Inference…

If you are like me, you’re probably asking yourself how Kotlin compares to other languages, especially to Scala. They have some differences and official Kotlin documentation has a comparison list but the important thing to remember is: If you are happy with Scala, you probably don’t need Kotlin. However if you are looking for an improved way of writing JVM applications then Kotlin looks like a good contender to top the list.

The last session that I wanted to talk about in today’s blog was Heath Kesler‘s Advanced Enterprise Architectures Using Open Source however I realize that this has been a pretty long blog post therefore I’m going to leave it for the next article, which is going to be cover last day of JavaOne 2012.

NoSQL Morning

JavaOne Day 2 started with two interesting NoSQL sessions.

Expert in No SQL

First one was a Couchbase talk, called Autosharding with NoSQL and Couchbase,  given by Raghavan “Rags” Srinivas and Matt Ingenthron who were both very good and engaging speakers. Rags started by quickly explaining what NoSQL was. It stands for Not Only SQL and it generally refers to databases that neither expose a SQL interface nor use the relational data model. They are probably better thought as Non-Relational Databases. They typically don’t offer typical RDBMS features in order to improve overall performance. Therefore they are:

• Often schemaless
• No key constraints
• No multi-step transactions
• No concept of a join

And they are well suited for Cloud deployments.

According to the CAP Theorem (also known as Brewer’s Theorem), it is impossible for a distributed computer system to simultaneously provide all three of the following guarantees:

• Consistency (all nodes see the same data at the same time)
• Availability (a guarantee that every request receives a response about whether it was successful or failed)
• Partition tolerance (the system continues to operate despite arbitrary message loss or failure of part of the system)

NoSQL databases sacrifice the Consistency guarantee and provide Availability and Partition guarantees.

With the common RDBMS scenario at the Web scale, it becomes expensive and disruptive to shard. Typical applications scale out by adding more commodity servers however databases typically scale up by getting bigger, more complex servers. On the other hand, Couchbase scales like the typical application tier: with linear cost and constant performance. Being able to scale out and auto-sharding flatten the cost and performance curves.

Then Rags gave the example of Draw Something by OMGPOP which went viral 3 weeks after launch. They reached 40 million users in matter of weeks however they managed to meet the demand successfully by scaling out using Couchbase.

Couchbase is open-source (Apache 2.0) but companies can get enterprise subscriptions providing professional support. Their developer edition is free for 2 nodes. It is supported on Windows and Linux (and Mac but understandably it’s for development only). It is administered using a very slick looking Web console. The interesting point is that the Web console uses the RESTful API provided by Couchbase therefore anything that can be done through the Admin Console can also be achieved programmatically. It is both a distributed key/value store (based on memcached) and a document oriented database. All documents/items are stored and retrieved using standard hashtable operations such as get, add, etc. They can be stored as JSON documents.

Matt demonstrated how easy to add a node. After talking about certain operations such as CAS (compare and swap), optimistic & pessimistic concurrency, get with lock (GETL), he presented Couchbase’s View and Query API (Views are perspectives on a collections of documents). He showed code examples of Map/Reduce, Secondary Indexing and the Query API.

The case study of Orbitz was impressive. Average latency and especially max latency improvements after switching to Couchbase looked spectacular.

The second NoSQL session was Antoine Girbal‘s MongoDB session entitled MongoDB and Java: Big Data Made Easy. This was another good session presented by a good speaker. After introducing Big Data and its 3-Vs (Volume, Variety and Velocity) he told us that Horizontally Scalable Architecture becomes possible thanks to No Joins and No Complex Transactions. He introduced MongoDB’s use of its BSON format which is a binary-encoded serialization of JSON-like documents and the MongoDB/NoSQL equivalents or some RDBMS terms such as collection that is similar to table and document that is similar to row. 

MongoDB stores data as documents and supports atomic operations on them. It is schema-free. It supports SQL-like equality or regular expression searches. It has a very strong and useful Geospatial support (two-dimensional geospatial indexes), which we successfully use in DSI. An interesting fact revealed by Antoine was that MongoDB’s Java driver is currently the most used driver, which receives support from 10gen and the community. He, then, got into code examples about obtaining a Mongo instance, working with a database and a collection instance, working with BSON objects, inserting, querying and indexing.

Finally the speaker ended his talk with MongoDB’s Replica Sets (how they behave and elect a new Primary in case of failures) and Sharding.

One of the remaining notable sessions was Building iPad Apps in Pure Java with Vaadin presented by Joonas Lehtinen. Vaadin is a Java framework for building rich Web applications. By following the GWT approach, Vaadin compiles Java code into HTML5 and JavaScript.

Joonas started his talk by explaining why iPad has become a very important tool: it had a very quick and important market penetration, it currently holds 70% of the tablet marketshare and approximately 100 million iPads have been shipped to date. Furthermore, last year Apple claimed that 93% of Fortune 500 companies had deployed or were testing iPads.

Vaadin, which means female deer in Finnish (hence the curved-bracket and v in their logo that form the head of a stag) is an open-source (licensed under Apache License 2.0) Web application framework for building rich Internet applications. As opposed to most of the other HTML5-and-JavaScript-based mobile application development tools, Vaadin features a server-side architecture, which means that the majority of the code runs on the server-side. Some of you probably has seen the similarity of this approach to GWT’s and not so surprisingly, Vaadin is using GWT (Google Web Toolkit) under the hood to generate Web-based output. Its programming language is Java and just like in GWT, the programming model is very similar to desktop UI building with events and widgets unlike the traditional Web UI programming model.

During the demos, it looked like Vaading has a rich set of UI library, mostly through its commercial TouchKit. For example their iOS theme has the following major components (among others):

• TouchKitWindow
• NavigationManager
• NavigationBar
• NavigationButton
• SwipeView
• PopoverWindow
• Tabsheets
• Toolbar
• Switch

One of interesting features of Vaadin is that it offers Offline Mode but we didn’t get a chance to see it working as part of the demo. It is also supported by a Maven archetype and running/testing it becomes as easy as typing:

mvn package jetty:run-war

Its on-line documentation looked very comprehensive and they’re also offering a downloadable free e-book if you are interested in learning more about it.

Vaadin looked very convincing with its component library, ease of use and programming model. It was a very positive first impression.

The last session I want to talk about today is one of my afternoon sessions entitled JAX-RS 2.0: New and Noteworthy in the RESTful Web Services API presented by Marek Potociar and Santiago Pericasgeertsen.

More and more developers/architects become convinced that REST, with its simplicity, is in general the best way to expose services. For the Java platform, there are many good frameworks and in DSI we have been happily using RESTEasy. However standards are important and I like it when standards emerge from the industry/community rather than dictated by a God-like company. This is the case with JAX-RS, Java’s RESTful service standard. There are very important changes coming with JAX-RS 2.0.

JAX-RS is now a 4-year-old mature specification. Not surprisingly its new version, JAX-RS 2.0, is mostly annotation-driven. It is part of Java EE 6 however it has no internal dependency. And JSR-339 API is now public, meaning there won’t be any more major changes to it, only slight adjustments.

During their talk, Marek and Santiago developed some of the new features coming with JAX-RS 2.0.

Client API

This is an area where there needed to be standardization and simplification because HTTP client libraries are usually too low-level. This API gives the developers the ability to work with high-level classes such as: ClientFactory, Client, Configuration, RequestBuilder etc. Here’s an example:

//Create a client
Client client = ClientFactory.newClient();

//Get account balance
String bal = client.target("http://.../atm/{cardId}/balance")
                   .resolveTemplate("cardId", "4444333322221111")
                   .queryParam("pin", "5678")
                   .request("text/plain").get(String.class);

Quite simple, really.

Common Configuration

There have been multiple configuration-related complaints therefore the common configuration proposal attempts to evolve the existing client-side Feature into a common solution for both client-side and server-side.

For example, on the client-side:

client.configuration().register(JsonMessageBodyReader.class)
                      .register(JsonMessageBodyWriter.class)
                      .register...
                      .setProperty("jsonp.callback.name", "callback")
                      .setProperty("jsonp.callback.queryParam", "true")
                      ...

becomes:

JsonFeature jf = new JsonFeature().enableCallbackQueryParam();
Client.configuration().register(jf);

On the server-side:

public Set<Class<?>> getClasses() {
  ...
  classes.add(JsonMessageBodyReader.class);
  classes.add(JsonMessageBodyWriter.class);
  classes.add(JsonpInterceptor.class);
  ...
}

becomes:

public Set<Class<?>> getClasses() {
  ...
  classes.add(JsonFeature.class);
  ...
}

Feature is a new interface and in the above example JsonFeature is an implementation of that. On the server-side it is also possible with dynamic Features.

Asynchronous Processing

Another great addition to the spec is asynchronous processing capability.

On the server-side, this offloads the I/O container threads, especially critical for the long-running operations. It represents suspendable client connections where it is possible to suspend the connection while waiting for an event and resume when the event in question arrives.

On the client-side there’s an asynchronous request invocation API.

Filters & Interceptors

It’s really not so difficult to imagine immediate use for filters and interceptors. It would allow us to customize JAX-RS request/response processing for operations such as logging, compression, security etc. It is introduced for both on the server-side and on the client-side.

Hypermedia Support

Support for HATEOAS (Hypermedia As The Engine Of App State).

Server-Side Content Negociation

Content negotiation is a mechanism defined in the HTTP specification that makes it possible to serve different versions of a document (or more generally, a resource representation) at the same URI, so that user agents can specify which version fit their capabilities the best. One classical use of this mechanism is to serve an image in GIF or PNG format, so that a browser that cannot display PNG images (e.g. MS Internet Explorer 4) will be served the GIF version.

All in all it has been a very good JavaOne so far. Pourvu que ça dure!

Hasta Mañana!

Unfortunately, as I feared, this first day of JavaOne started very early for me. I woke up at 4AM and I decided not to fight it. It gave me time to do a bit of work and write yesterday’s blog entry.

Atomic Data Structures

I left my hotel at 8 and walked 3 blocks that separated it from Hilton where my first session was taking place. It is important to pick a good session to start the week. I thought I did a good job in pre-enrolling in “How do atomic data structures work?” but unfortunately it didn’t live up to my expectations. It was obvious that the presenter knew his topic very well and this was his area of expertise however he gave the impression that he was nervous. Consequently, his talk was not well structured, his thoughts wandered and his jokes failed to revive the audience.

The session was centred around non-blocking data structures and how they work. The background consisted of the definition of atomicity, various standard ways to achieve it, what is a lock-free data structure, synchronized regions, memory barriers, various useful classes from the standard Java API such as java.util.concurrent.atomic.AtomicReference and java.util.concurrent.atomic.AtomicReferenceFieldUpdater. The background ended with a section about atomic updates.

The speaker then talked about linked queues, non-blocking linked queues and array-based bounded queues. It was a good refresher to listen to techniques such as the required steps in removing and adding an element. The most interesting part of the session was about the LMAX Disruptor.

LMAX is a trading platform. In their quest to achieve very low latency and high throughput with their Java platform, they created a framwork that has “mechanical sympathy” for the hardware (cache misses at the CPU-level are costly) and that is lock-free (locks requiring kernel arbitration are costly). Their solution is Disruptor and it sounds like a very interesting framework.

Constraint Programming API

My next session was one of the most interesting sessions of the day: Dr. Jacob Feldman‘s Constraint Programming API talk. I didn’t know Dr. Feldman previously but it turns out that he worked in University College Cork for 5 years. I was pleasantly surprised to hear that UCC”s Cork Constraint Computation Centre (4C) was the world leader in this area.

Constraint Programming (CP) is a programming model where the developer/designer states the relationships between the variables declaratively. CP separates Problem Definition from Problem Resolution. For example, you have a system where 3 variables have the following relationships (constraints):

• x + y = z
• x = y – 3
• 0 <= x, y, z <=9

You could solve this simple problem by creating nested loops and by enforcing the constraints. But the API gives you a way to describe the problem in a readable fashion and solves the problem with better-than-reasonable performance.

Another simple example would be an application/component that displays a greeting message based on the time of the day, the gender, the marital status and the salutation of the person. With each variable the decision table grows and the combinations grow exponentially. You can easily see how far such a problem can go.

Dr. Feldman started his talk by defining what are optimization engines and what are the leading optimization techniques that are currently in use. He mentioned mainly two optimization techniques:

• LP/MIP (Linear Programming/Mixed Integer Programming)
• CP (Constraint Programming)

And as the name of his session indicated, he focused on Constraint Programming. He gave a very simple example how a problem resolution can hide the associated problem definition. As part of his coding example, where 3 nested loops were used to solve the problem, by optimizing the code, the problem definition became completely obfuscated to the reader. One couldn’t go back to the code and extract the initial constraints easily. Instead he used the CP API to define the problem more clearly before solving it in a Constraint Satisfaction Problem (CSP) example:

Problem p = ProblemFactory.newProblem("Test");
Var x = p.variable("X", 1, 10);
...
Var cost = x.multiply(3).multiply(y).minus(z.minus...

Then he quickly mentioned the concept of constraint propagation and bi-directional constraint propagation:

Imagine there are the following constraints:

• x < y
• 0 <= x, y <= 10

Given the constraints above the following emerges:

• 0 <= x <= 9
• 1 <= y <= 10

Changes in x causes changes in y:

• x > 3
• y > 4

JSR-331 defines a constraint programming API for Java. It has some basic concept such as Problem and Solver:

Problem:

• Var
• VarReal
• VarBool
• VarSet
• Constraint
• …

Solver:

• Search strategy
• Solution
• …

The rest of the talk was going through various very interesting examples in different nature:

• Map colouring problem where given a list of countries and colours the application has to match a country with a colour that is different then its neighbours’.
• A logical problem: ” SEND + MORE = MONEY” where each letter corresponds to a digit.
• The famous “Zebra Puzzle” that is said to be invented by Einstein.
• Scheduling problems,
• House construction problems,
• Resource allocation problems,
• Cloud balancing

It was a very interesting and engaging talk. I’m already downloading OpenRules to have a deeper look at it. For more information Dr. Feldman recommended the Handbook of Constraint Programming by Francesca Rossi, Peter van Beek, Toby Walsh.

Java vs Node.js

My next session went through building a RESTful Web API using oAuth 2.0 by very much concentrating on oAuth and infrastructure. The most interesting information that I retain from the talk is that even though they love Node.js’s even-driven model, it failed to make an impression on Shutterfly who still uses Java because Node.js hasn’t performed as well as they expected.

Continuous Integration and Automated Mobile Application Testing

The talk of Intuit’s Eing Ong was another great one. Concentrating on Android and iOS, she first described a typical setup. After a theoretical introduction to mobile tests in a continuous integration environment using and the two main automated testing techniques (instrumented and non-instrumented), she presented demos using iOS and Android ran by Jenkins.

Let me quickly reiterate some of the main points starting with the advantages of instrumentation and non-instrumentation:

Non-instrumentation:

• Device platform agnostic.
• Test code reuse.
• Test language & test harness autonomy.
• Support for:
  • Multi-applications testing
  • Custom UI Levels
  • Database/server API assertions
  • Use of external libraries (e.g. image manipulation)

Instrumentation:

• Elements can be accessed.
• Ease of debugging
• Ease of test verification
• Reduced tools dependencies
• Support for:
  • Installing application
  • Launching application
  • Cleanup (kill application)
  • Test execution on device
  • Code coverage

When to use these techniques:

Non-instrumentation:

• External interaction
• Hardware interaction
• Image-based features

Instrumentation:

• Text-based features

Mobile automation tools:

Android:

• Non-instrumentation
  • eggPlant
  • Sikuli
  • MOET
  • MonkeyRunner
• Instrumentation
  • Robotium
  • Calabash
  • MonkeyTalk

iOS:

• Non-instrumentation
  • eggPlant
  • Sikuli
  • MOET
• Instrumentation
  • UIAutomation
  • KIF
  • iCuke
  • Frank
  • UISpec
  • Zucchini
  • Bwoken
  • Calabash
  • MonkeyTalk

She was a great speaker who kept the session interesting.

Mobile WORA with Codename One

I’m very happy that Codename One session didn’t disappoint me and even exceeded my expectations. This talk was one of the highlights of the day. Presented mainly by Shai Almog accompanied by his colleague Chen Fishbein, both ex-Sun employees, the session covered Codename One, a cross platform mobile development tool in Java.

Codename One is free & Open Source tool. It allows Java developers to build true native apps for all major mobile devices. Its architecture is very interesting as some part of the heavy lifting is done on the cloud. This is especially useful for iOS applications as one needs a Mac in order to build an iOS application. Codename One has the following architectural parts:

• Java API
• Designer
• Simulator
• IDE Plug-in (NetBeans and Eclipse)
• Build Server
• Service Cloud

The Java API does most of the heavy lifting by compiling and glueing the user code to the target platform code. They are also talking to JetBrains to collaborate on a plug-in for IntelliJ IDEA.

Their Kitchen Sink demo looked very good on ten or so different devices running iOS, Android, Win8 Mobile and BlackBerry among a few others. However I need to try it for myself to get a real feel for it. As I am writing this post, Eclipse is installing the Codename One plug-in and I’m hoping to get my hands on a simple example very soon.

Their “free” usage is somewhat limited, especially for iOS applications. Every user gets 100 credits/month that can be spent for builds. An Android app consumes 1 credit/build however this goes up to 20 credits/build for iOS as it is a much more lengthy and costly (Mac hosting on the Cloud is more expensive). But I think this should be fine for most amateurish apps. To get unlimited credits, one pays $9/month, which covers, understandably, various costs associated by running servers on the Cloud. For enterprise level agreements, there’s a higher and more expensive tier.

All in all Codename One looked very promising. Very soon I’m going to have a first-hand experience using it. I’ll probably blog about it later.

It’s time for me to get ready for the 2nd day of JavaOne 2012. I’m hoping to meet you here tomorrow.

A demain!

Every year there is one or a few dominating themes in JavaOne. You get a feel for it just by looking at the conference schedule during your pre-enrolment. If you check the same calender just before the first day of JavaOne, you can see which sessions are popular, too popular actually, and full. I even noticed a few talks whose waiting list was in the order of 200. So, without setting foot in Moscone Center and talking to fellow attendees one can get a fair impression about what are the main themes of the year.

There is definitely a concentration around Cloud-related sessions and also HTML5-related responsive Web technology sessions. But I think Cloud is the term we are going to hear most often in this year’s JavaOne. So, it doesn’t come as a surprise that Larry Ellison, CEO and co-founder of Oracle, introduced Oracle 12c to thousands of conference attendees at Moscone Center today. What does “c” stand for? You guessed it right: Cloud. One of the main design goals of Oracle 12c was Cloud computing deployments. Cloud is now at the heart of Oracle. They put the emphasis on the Private Cloud with their Exadata and/or Exalogic servers.

Again, it is very disappointing not to have any talk on Android. If there’s someone out there listening (or reading) this is me complaining about it. Android is Java’s only viable mobile platform. You keep talking about developers, community, teamwork, etc. Prove that these are not stories told just to motivate developers and companies in order to generate more revenue. Prove that you really care about what the community wants. Put your greed and differences aside for once and do what is right for the developers.

JavaOne 2012 – Technical Keynote Speech

This year the format of the Technical Keynote Speech was somewhat different. There weren’t many short technology demos, which was probably a good thing. Instead, the JavaFX team has developed a Schedule Builder/Viewer application and it was the main application used in various demos. I think this is a better approach. It also serves a purpose and the attendees can use it during the conference to get a feel for it.

The Conference Schedule app was pretty slick and responsive. They ran it firstly on a Windows laptop. And then on a Mac. To be honest I couldn’t see any difference. I’m curious about its UI, and I’m going to look at it in detail if I can find an opportunity because some sections had a very iOS-like look and feel. From such a demo one can understand that JavaFX has come a long way. I especially liked  to hear about practical features such as being able to produce native code so that a JavaFX application can be submitted to Apple MacStore for instance.

A talk about Project Lambda was next. I’m not a huge fan of lambda expressions. I’ll probably use them but I have the feeling that they add more complexity and diminish the readability of the code. But I am going to hold on to refrain from having a strong opinion until I get a chance to use lambda expressions on real living, breathing code.

There was a brief mention of Java 8′s Default Methods. I like the idea. A very similar concept exists in Objective-C and being able to augment standard interfaces and provide default implementations come in handy.

Then they ran the same Conference Schedule application on a touchscreen kiosk (supporting multi-touch gestures) and on an impressive Raspberry Pi. Raspberry Pi is a nice little Linux box that you can get for $25. I’m not kidding. Go and have a look. Or as they advertise: “Take a byte!”

Then followed a short section about Project Jigsaw, explaining why it is now part of Java 9 and not as previously announced Java 8, and about the new Compact Profiles. The Compact Profiles specification defines three subset profiles for the Java Runtime Environment. Currently the entire JRE takes up about 52MB. The proposed profiles will take up 10MB, 17MB and 24MB, each level allowing a more feature-complete runtime. However, it looks like the minimalistic profile will allow things like running a Web server, for instance.

The second part of the keynote speech was about Java Enterprise Edition 7. Java EE 7 comes with increased productivity. It encompasses new and/or improved specifications such as:

• A new batch API (Batch Applications For The Java Platform 1.0 – JSR 352),
• A new JSON API (Java API For JSON Processing (JSON-P) – JSR 353),
• A new WebSocket API (Java API For WebSocket 1.0 – JSR 356),
• Java Temporary Caching API 1.0 (using annotations such as @CachePut, @CacheKeyParam, @CacheValue),
• Bean Validation 1.1 (using annotations such as @NotNull, @Max(“10″), @Future),
• JMS 2.0 (less verbose, reduced boilerplate code, resource injection, AutoCloseable support, etc)
• JAX-RS 2.0 (client API, message filters and entity interceptors, etc)
• THML5 support (HTML5 Forms, etc)

The keynote speech, a long one, ended at around 8PM, with the mention and demos of Project Avatar and Project Easel.

All in all, it looks like it is going to be an interesting week in JavaOne. Talk to you tomorrow.

Since it is multi-threaded application C# logs loads of RPC Unavailable errors once the COM+ crashes, but nowhere I could find original point where the crash occurred. Actually the thread dies and even if debugged in VS the debugger doesn’t break on this unhandled exception as one would expect, even though it breaks on all other – RPC Unavailable exceptions.

So, the first task in this case, for me at least, would be to find what method is called when the crash occurred. When facing something unexpected like this I resort to WinDbg which I know just enough to get by analysing crash dumps. Necessity on couple of other occasions made me learn the basics so here are some notes.

Preparation

First we need the crash dump. That’s easily obtained through DebugDiag tool. Instructions on how to get the dump from Microsoft is a bit on the dry side, I prefer instructions with some pictures in it. In this case I needed to select a specific MTS/COM+ application and choose mine from the list. In the list of exceptions I chose C0000005 to generate Full Userdump. Analysing crash dump through DebugDiag tool is normally useful, but in this case did not offer any useful insight.

After exception happens user dump is created and from there on we can use WinDbg. That’s a part of Windows SDK and I selected to install it as Standalone Component. Follow this intro for getting started with WinDbg. Here’s the list of useful commands of which stack commands are particularly useful.

Oh, BTW, you’d better make sure to have debug symbols available for your COM+. In case of VB6 private symbols are rubbish, but at least for exported symbols I got names of methods, otherwise it would’ve been impossible to resolve this.

Analysis

Lets see what we have in our crash dump:

This dump file has an exception of interest stored in it.
The stored exception information can be accessed via .ecxr.
(2620.1b6c): Access violation - code c0000005 (first/second chance not available)
eax=03d5ba94 ebx=72a1a274 ecx=75ebb100 edx=00a3f140 esi=72a1a008 edi=029df748
eip=75ebb13a esp=00a3f06c ebp=00a3f174 iopl=0         nv up ei pl zr na pe nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00010246
oleaut32!_IDispatchProxyVtbl+0x26:
75ebb13a 336c0000        xor     ebp,dword ptr [eax+eax] ds:0023:07ab7528=????????

So _IDispatchProxyVtbl is crashing. Errrr, looks like vtable – we’re trying to call some method on COM+ … well, I know that OK, lets try analysing this exception:

0:013> !analyze -v
...
FAULTING_IP:
oleaut32!_IDispatchProxyVtbl+26
75ebb13a 336c0000        xor     ebp,dword ptr [eax+eax]

EXCEPTION_RECORD:  ffffffff -- (.exr 0xffffffffffffffff)
ExceptionAddress: 75ebb13a (oleaut32!_IDispatchProxyVtbl+0x00000026)
ExceptionCode: c0000005 (Access violation)
ExceptionFlags: 00000000
NumberParameters: 2
Parameter[0]: 00000000
Parameter[1]: 07ab7528
Attempt to read from address 07ab7528

DEFAULT_BUCKET_ID:  INVALID_POINTER_READ
PROCESS_NAME:  dllhost.exe
ERROR_CODE: (NTSTATUS) 0xc0000005 - The instruction at 0x%08lx referenced memory at 0x%08lx. The memory could not be %s.
EXCEPTION_CODE: (NTSTATUS) 0xc0000005 - The instruction at 0x%08lx referenced memory at 0x%08lx. The memory could not be %s.
EXCEPTION_PARAMETER1:  00000000
EXCEPTION_PARAMETER2:  07ab7528
READ_ADDRESS:  07ab7528

FOLLOWUP_IP:
oleaut32!_IDispatchProxyVtbl+26
75ebb13a 336c0000        xor     ebp,dword ptr [eax+eax]

MOD_LIST: <ANALYSIS/>
NTGLOBALFLAG:  0
APPLICATION_VERIFIER_FLAGS:  0
LAST_CONTROL_TRANSFER:  from 75d904e8 to 75ebb13a
FAULTING_THREAD:  00001b6c
PRIMARY_PROBLEM_CLASS:  INVALID_POINTER_READ
BUGCHECK_STR:  APPLICATION_FAULT_INVALID_POINTER_READ

STACK_TEXT:
00a3f174 75d904e8 029df170 00216750 00000202 oleaut32!_IDispatchProxyVtbl+0x26
00a3f190 75df5311 110082bb 00a3f380 00000002 rpcrt4!Invoke+0x2a
00a3f598 759daec1 02a7bfb8 002110a8 00178b88 rpcrt4!NdrStubCall2+0x2d6
00a3f5e0 75ebffd3 02a7bfb8 00178b88 002110a8 ole32!CStdStubBuffer_Invoke+0x3c
00a3f604 759dd876 03d5ba00 00178b88 002110a8 oleaut32!CUnivStubWrapper::Invoke+0xcb
00a3f64c 759dddd0 00178b88 0282dde8 03466750 ole32!SyncStubInvoke+0x3c
00a3f698 758f8a43 00178b88 0019ec48 03d5ba00 ole32!StubInvoke+0xb9
00a3f774 758f8938 002110a8 00000000 03d5ba00 ole32!CCtxComChnl::ContextInvoke+0xfa
00a3f790 758f950a 00178b88 00000001 03d5ba00 ole32!MTAInvoke+0x1a
00a3f7bc 759ddccd 00178b88 00000001 03d5ba00 ole32!STAInvoke+0x46
00a3f7f0 759ddb41 d0908070 002110a8 03d5ba00 ole32!AppInvoke+0xab
00a3f8d0 759de1fd 00178b30 028bc878 00000400 ole32!ComInvokeWithLockAndIPID+0x372
00a3f8f8 758f9367 00178b30 00000400 001af3f8 ole32!ComInvoke+0xc5
00a3f90c 758f9326 00178b30 00a3f9cc 00000400 ole32!ThreadDispatch+0x23
00a3f950 75a1c4e7 00230b56 00000400 0000babe ole32!ThreadWndProc+0x161
....

Not really useful. I’ve analysed exceptions before and this command’s output was much more useful on those occasions.
So lets see the stack (knf shows the stack with  frame number and size of the frame):

0:013> knf
#   Memory  ChildEBP RetAddr
00           00a3f174 75d904e8 oleaut32!_IDispatchProxyVtbl+0x26
01        1c 00a3f190 75df5311 rpcrt4!Invoke+0x2a
02       408 00a3f598 759daec1 rpcrt4!NdrStubCall2+0x2d6
03        48 00a3f5e0 75ebffd3 ole32!CStdStubBuffer_Invoke+0x3c
04        24 00a3f604 759dd876 oleaut32!CUnivStubWrapper::Invoke+0xcb
05        48 00a3f64c 759dddd0 ole32!SyncStubInvoke+0x3c
06        4c 00a3f698 758f8a43 ole32!StubInvoke+0xb9
07        dc 00a3f774 758f8938 ole32!CCtxComChnl::ContextInvoke+0xfa
08        1c 00a3f790 758f950a ole32!MTAInvoke+0x1a
09        2c 00a3f7bc 759ddccd ole32!STAInvoke+0x46
0a        34 00a3f7f0 759ddb41 ole32!AppInvoke+0xab
...

None of these are my Dlls, these are all COM+ infrastructure calls. The size of that rpcrt4!NdrStubCall2 is big enough to rouse suspicion. rpcrt4.dll is part of RPC Architecture and NdrStubCall2 is server-side entry point for RPC Stubs.
We’re nearly there, lets dump the raw stack:

0:013> kd
00a3f174  00a3f190
00a3f178  75d904e8 rpcrt4!Invoke+0x2a
00a3f17c  029df170
00a3f180  00216750
00a3f184  00000202
00a3f188  00000002
00a3f18c  00a3f380
00a3f190  00a3f598
00a3f194  75df5311 rpcrt4!NdrStubCall2+0x2d6
00a3f198  110082bb MyDll!__vba+0x71
00a3f19c  00a3f380
00a3f1a0  00000002
00a3f1a4  e28df787
00a3f1a8  02a7bfb8
00a3f1ac  00178b88
00a3f1b0  00000000
00a3f1b4  00178b88
......

So the highlighted line looks like something I’m looking for, just not really informative. It seems like it might be a pointer to somewhere in vtable? Lets see:

0:013> u 110082bb
MyDll!__vba+0x71:
110082bb e9c0d80000      jmp     MyDll!MyObject::Method1+0x50 (11015b80)
110082c0 816c2404ffff0000 sub     dword ptr [esp+4],0FFFFh
110082c8 e923df0000      jmp     MyDll!MyObject::Method2+0x330 (110161f0)
110082cd 816c2404ffff0000 sub     dword ptr [esp+4],0FFFFh
110082d5 e966e30000      jmp     MyDll!MyObject::Method3+0x140 (11016640)
110082da 816c2404ffff0000 sub     dword ptr [esp+4],0FFFFh
110082e2 e949e50000      jmp     MyDll!MyObject::Method4+0x1c0 (11016830)
110082e7 816c2404ffff0000 sub     dword ptr [esp+4],0FFFFh

And there it is (note, these are not real method names, __vba is real though). That is the culprit. Well, not really, there was some interoperability issue. The culprit was .NET code, I was passing COM+ objects back and forth, and done something in between to mess up the things. At any rate it was faster to rewrite the method than to chase the exact problem since the method in question is used only for testing.

However, if I hadn’t been able to figure out the name of the method I would’ve never been in the position to even consider a fix.
For proper debugging and analysis of RPC calls see Remote Procedure Call debugging. As I said before, I know enough to get by and in this case, luckily, I didn’t need to dig deeper. On a couple of other occasions I had to and will follow up in further posts.

In Short

• Get the dump
• Fire up WinDbg
• !analyze -v to analyse exception
• knf – to get the call stack
• kd – to dump the raw stack
• u address to disassemble at address

ls -R | grep ":$" | sed -e 's/:$//' -e 's/[^-][^\/]*\//--/g' -e 's/^/ /' -e 's/-/|/'

On Windows I used Cygwin to run this *nix command. And what I got was pretty satisfactory:

   .
   |-ear
   |-ejbs
   |---src
   |-----main
   |-------resources
   |---------META-INF
   |-primary-source
   |-projects
   |---logging
   |-servlets
   |---servlet
   |-----src
   |-------main
   |---------webapp
   |-----------WEB-INF
   |-src
   |---main
   |-----resources

Let me know if you have a better or quicker or nicer way of doing the same thing.

UPDATE: As suggested by Derek, you can use the “tree /a” command on Windows, for even a prettier output:

+---ear
+---ejbs
|   \---src
|       \---main
|           \---resources
|               \---META-INF
+---primary-source
+---projects
|   \---logging
+---servlets
|   \---servlet
|       \---src
|           \---main
|               \---webapp
|                   \---WEB-INF
\---src
    \---main
        \---resources

This article isn’t going to make the case for doing things Ray Ryan’s way. I don’t think there’s any need to convince anyone. But I would like to point out some choices that emerge from developing complex applications using these patterns and make some suggestions about what these choices might mean.

But firstly, I’ll like to touch on one thing that Ray Ryan did not talk about much, and which is not covered in many of the GWT MVP articles I’ve read: the ‘M’ in MVP – the Model. The suggestion seems to be, from a reading of the standard literature, that the Model is just whatever DTO the Presenter happens to be holding onto at any given moment. It’s true that a model like this will serve you well in a great many scenarios. For example, if your MVP Triad is displaying a list of Users, then a List<UserDTO>, returned from a service call, is all you probably need to act on when coding the behaviour of this Triad. But there are other circumstances, when we will need to maintain some client-side state, and in this case, the DTO is just not enough. This shouldn’t surprise us. The DTO has its own specific role to play in the overall architecture. A good DTO should contain just enough data to allow the client to communicate efficiently with the server, while still displaying everything that the current MVP’s View wants to show. The DTO is typically a reduced blend of domain objects, assembled on the server side for use by that MVP Triad in particular, and passed forward and back in a way that reduces chattiness. It should never contain any information that represents client-side state.

Once we accept the need for a Model, even if a simple POJO, we are faced with the question about where to create and maintain this Model. If you’ve been using Ray Ryan’s architecture for even a short while, the answer is obvious: GIN. The central class in an MVP Triad is the Presenter. It should mediate between the Model and the View. The Presenter is also the Activity in the standard literature on Place management, and we use GIN to instantiate the Presenter/Activity when its corresponding Place is reached. By extension, the View and Model, which are linked by the Presenter, are also created through GIN, as they are injected into the Presenter’s constructor. All it takes is to add one little @Singleton annotation to the definition of a Model class, and suddenly we have a Model instance that can be created, maintained and presented automatically whenever required by its Presenter/Activity – even if that Presenter/Activity is instantiated afresh each time its Place is reached. This Model can hold any number of DTOs as well as the MVP’s own presentation state (e.g. a boolean to represent visibility of a collapsible part of the screen).

Now we have a singleton class that holds our presentation state without infecting our DTOs. But we quickly realise that we can take this singleton Model one step futher: we can share it with other MVP Triads.

The mechanism to share isn’t hard to understand – we simply add our Model class to the constructor of another Presenter/Activity. Harder to understand is why we would do this in the first place. Well sometimes this can be a very efficient way of sharing information between two cooperating Triads. Let’s go back to our example of a Triad to show a list of Users. Let’s say we want to be able to click in the list and move to an EditUser Place, with its own MVP Triad for editing the details of a particular User. Once the edit is finished, we’d like to go back to the list of Users and see the updated User in that list, preferably without performing an entirely new service request to retrieve the list. A shared Model instance could store the list of UserDTOs and the selected UserDTO together, allowing each Triad to work from common data, while still respecting the Place management pattern of GWT.

This is a convenient, readable and efficient way of allowing two Triads to communicate, but it comes at the price of increased coupling. Triads which share a common Model are coupled not just by the fact that they depend on a common data structure, but also because their internal implementations are based on common assumptions about how each Triad reads and updates the Model. This is not a problem as long as we are aware of the coupling, and restrict this pattern of communication to Triads which are designed to always work in tandem. We can even begin to use this knowledge to define the elusive meaning of the word Component in the context of large-scale GWT architectures: Components are groups of cooperating MVP Triads that may share Model instances. A component, in this sense, might be the group of MVP Triads that performs CRUD operations (even sophisticated and varying CRUD operations) on a particular subgroup of domain objects. In our example, we might have the User component, which is composed of Edit User, Add User, View User and List Users MVP Triads.

Taking this as the highest form of coupling between Triads, let’s work backwards and ask ourselves in what other, less-coupled ways can our Triads communicate. In my experience of the patterns that emerge from this GWT architecture, the next most tightly coupling mode of communication is where one Presenter/Activity issues the instruction to go to a new Place, thus passing control to another Presenter/Activity – quite probably to a Triad outside the component as we’ve just defined it. Places offer a fig-leaf of decoupling in this context. In principle, the invoking Triad does not know what – if any – other Triad may respond to the instruction to move to a new Place. In practise, our Places are deeply associated with particular Activities, and therefore particular MVP Triads. We could of course change the behaviour associated with a Place simply by mapping it to a different Activity, but this rarely happens. And in fact, the name of our Place – if we have any sense – gives a strong indication of what other component it belongs to. For example, our View User activity may, in response a button clicked on its View, instruct GWT to switch to a Place that lists all Operations performed on the system by the particular User. Control would switch to the Operations component of the application (in particular, the MVP Triad that knows how to list Operations). This is coupling across components, and I think should be allowed, not just because of the fig-leaf of Places, but also for readability. The code in the View User Presenter/Activity makes it quite clear to the glance of a developer, where control is going. This is a reasonable trade off if all you want to do is move from one Activity to the next. It is a better alternative to the least coupled form of communication, which can be harder to follow: Application Events.

There are entries on this blog, going back years, that talk about a loosely-coupled way of communicating between Triads. You can consider this article to be an evolution of those ideas. They describe an Application Model View Control (AMVC) architecture in which Triads communicated by passing Events exclusively via an intermediate layer called the Application Layer. The Application Layer is responsible for interpreting those events and invoking application level logic to coordinate the behaviour of multiple other Triads. Transplanting this idea to the Ray Ryan architecture, we introduce the idea of an Application Activity/Presenter which listens on GWT’s event bus for events that have an application-wide meaning (for example, LogOutCurrentUser). Such an event might come from any component in the application, and its effects might be spread widely across the application – a much more complex operation that merely switching to a new Place. This is a pattern that we have been following in DSI to good effect. But it can lead to difficult-to-read code at times. As such, it is probably best kept for complex patterns of activity across component barriers – not just switching Place.

To summarise, the Ray Ryan approach to large scale GWT application development allows choices to emerge when it comes to communication between Triads. We can organize these choices into a kind of hierarchy and try to apply a consistent pattern to their use, creating as we do so, a new definition for what we mean by Component:

Most coupled: Shared Model instances. Only sparingly and ONLY within Triads of the same component.

Medium coupling: Invocation of one Triad’s Place from another Triad. Can be trans-component. Use if simply switching Places.

Least coupled: Event Applications passed through a mediating layer. User for all other (more complex) interactions.

If you’re reading this, you already know that you need to obtain a Maps API Key in order to use Google Maps in your Android application. Here’s how you can quickly create your development key:

Locate your .android directory: Your personal Android settings that are associated with your profile are located in the active AVD (.android) directory. This directory is under your home directory.

• Windows Vista/7: C:\Users\<user>\.android
• Windows XP: C:\Documents and Settings\<user>\.android
• OS X and Linux: ~/.android

Locate your debug keystore: You should see your debug keystore file directly in your .android directory. It is called debug.keystore.

Get the MD5 Fingerprint: Open a command prompt and navigate to the .android directory. Use the keytool command to get the MD5 Fingerprint:

keytool -list -alias androiddebugkey -keystore debug.keystore -storepass android -keypass android

The output of this tool should look like:

Certificate fingerprint (MD5): 32:46:AA:56:D9:71:8B:2A:0B:34:A1:B6:96:1E:87:59

Note: If you are using Java 7, the output of this command will show you SHA1 Fingerprint instead of MD5:

Certificate fingerprint (SHA1): 32:46:AA:56:D9:71:8B:2A:0B:34:A1:B6:96:1E:87:59:32:46:AA:56

In this case, add the -v parameter to the above-mentioned toolkey command:

keytool -list -alias androiddebugkey -keystore debug.keystore -storepass android -keypass android -v

This is going to run this command in verbose mode therefore you’re going to see a bigger output and at the end of it you should see the MD5 fingerprint:

Certificate fingerprints:
MD5: 94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5:98
SHA1: 32:46:AA:56:D9:71:8B:2A:0B:34:A1:B6:96:1E:87:59:32:46:AA:56
SHA256: 8B:2A:0B:34:A1:B6:96:1E:87:59:32:46:AA:56:E4:42:91:5D:36:BB:24:46:AA:41:A6:88:D7:20:F1:8E:B5:98
Signature algorithm name: SHA1withRSA
Version: 3

Go to Maps API Sign Up page: Go to https://developers.google.com/android/maps-api-signup. Read and if you agree with the terms and conditions tick the checkbox. Then paste your MD5 Fingerprint in the My certificate’s MD5 fingerprint: text field. Finally hit Generate API Key. And Voilà!

I managed to catch a really top-class seminar from David Starr and test champion Peter Provost. Their delivery was compelling, the demos great and the subject was just what I came to see. Their top-down web application testing demo really opened my eyes to what WatiN could do for some of my more complex web application projects. I really have to tire kick that framework a bit to see how well it works in practice, as so many of our projects are workflow heavy and invariably require authentication there might be some practical constraints on all that yummy goodness.

Tomorrow is the final day and hence I’m looking forward to the savagely talented and deeply compelling Mark Russinovich’s “Case of the unexplained…” session that he does every year.

The big items on Microsoft’s agenda are Azure and Windows 8. It’s just as you might imagine. To be fair, windows 8 looks like a pretty nice product and I loved the really cool “Windows to go” feature they demo’ed at this morning’s keynote. The demo involved an apparently impromptu video freeze. I think the shocked audience was expecting a Bill Gates blue screen moment. However, it turned out to be all part of the clever demo. “Windows to go” is nice and another string in the Windows 8 bow, but nothing new to Ubuntu fans I think.

Incidentally, the keynote presentations this year seem to be stressful affairs, all the presenters seem rushed and slightly off the pace. Luckily yesterday’s connectivity disaster seemed mitigated. Someone seems to have screwed up on the bandwidth allocation for the conference and the network imploded under a mountain of inane tweets and Facebook twaddle.

Today’s breakout sessions were all crackers. I finally got the 411 on Microsoft’s retro debugger IntelliTrace; I’ve wanted to get the poop on that for some time. It turns out, it’s pretty easy and Microsoft has made some efforts to facilitate deployment within production environments for the new version of Visual Studio. The new application lifecycle management (ALM) features of Visual Studio 2012 are being strongly pushed under the heading of “continuous delivery”, something of a holy grail for me with TFS. It would be so nice if it was a trivial exercise to deploy continuous integration builds for manual testing. Now, Microsoft seems to have gone some way to delivering that, at least for web and Azure applications. The automatic deployment of TFS builds brought a small tear to my eye. I’m slightly in love with Visual Studio 2012 for that reason alone. Manual testing has also received a minor usability overhaul in 2012, under the ALM umbrella; I’m going to have to push that quite heavily with some of our clients this year.

I managed to pick up a stream of invaluable tips on what works and what doesn’t when using Virtual machine instances locally (in Windows 8) for development purposes. The main one seeming to boil down to “make sure your employers are not parsimonious with your personal hardware”. I guess that’s pretty obvious really, but the presenter Brian Randell was very specific on what was required of the hardware and a lot of his hard won experience was communicated.

Lastly, some seemingly minor, but sensible, licensing changes seem to have the potential for increasing code quality for less outlay. Visual Studio 2012 Premium is now set to include Test Professional and the Ultimate edition will have unlimited licensing for test agent instances when performance or load testing.