Interesting (slightly long) keynote from Dan North asking us to think about how people influence us and what influence we have on people. The concluding slides were classic Dan and a reminder of what a great mentor and coach he is.
The first two hours of talks don't have much of interest so I've spent time chatting to people about stuff.
Apparently you can't change talks once they've started and you can't take the bottles of water until it is lunchtime. Devoxx has a lot rules in a bad way.
So few toilets, so many queues, wow
Cryptoanalysis talk seems to be mostly theoretical. Was hoping for something a bit more practical.
The speaker is incredibly nervous.
So the crypto talk took no prisoners on the mathematics but at least my functional analysis lecturer would be proud to know that I still understand rings, groups and fields.
The summary of the talk was pretty interesting. Elliptic curve cryptography is taking over from RSA as it uses smaller keys and is less demanding in terms of its computation so that it fits in better with the low-power/mobile computing devices.
First standout talk of the conference, Charles Nutter on FFI. Discussing the JNR library he's been working on and how FFI is going to come of the OpenJDK, hopefully for the Java 9 release.
The JDK FFI interface is initially going to be internal to the JDK and make it easier for the implementers to hook into native code.
Then the API can be generalised into a public API.
A few people are asking why this is relevant but there are real use-cases around networking, sockets, user IO, scientific computation.
Also Curses.
Feeling a little uninspired in the final round of talks before the drinks so spending some time hacking in the cafe area. Accidentally downloaded the Android SDK, the wifi is excellent.
The lunch less so.
My biggest thoughts at the moment is that this is a conference, like QCon, that is about letting people catch up not about figuring out what we need to do next.
Some interesting conversation about the cost of trying early-life programming languages in the post-talks mixer.
New languages should show demonstrable benefits. Java was more productive than C, C was more productive than Assembly.
There shouldn't be any doubt as to the value of a new technology it should be contributing value regardless of the cost of the adoption.
It's interesting how peripheral Java is to my professional life now. I'm interested in what is happening with Java 8 and Lambdas but it feels like a remote interest like what Apple is doing with Swift.
I wondering what the vendors are going to do in the hall tomorrow. I think Twilio had a masterstroke with the table football.
After reflection I do believe there are standard good coding practices and that it is valuable to adopt them.
My talk clashed with queues for sandwiches and it was completely unclear as to whether I should be talking as the previous speaker was still chatting with people.
I decided to turn it into a conversation where I shared my concerns that the tensions involved in mixed-paradigms were untenable.
Technical leaders have to master both paradigms but the direction of travel is entirely towards immutability and FP.
There was a bit of back and forth but I didn't hear really convincing arguments that the thesis is wrong. Which is reassuring.
Marks and Spencers are the only company that are recruiting at the conference. The others are trying to get sales leads for tools and services.
God bless, the organisers seem to have sorted the water situation.
Just bailed on a weird talk that was a mix of recorded segments followed by weird played out scenes. One step on from reading your slides, get someone else to read your slides prior to the talk.
Russell Winder's talk now on the revival of 60's message passing system design.
Code examples from Russell's talk made Java 8 streams feel much more relevant that yesterday. However not sure I'm convinced about the GPars syntax.
It's actually not a rule that you need to start with a bio or a synopsis of your talk.
Forgotten that Cloudant had been bought by IBM
Every speaker seems to be saying that that concurrency should not be explicitly managed and that thread management should go the way of explicit memory management.
I agree but for some reason I feel uneasy about it. I suspect because I wonder about how people can effectively reason about code with non-deterministic execution order.
That was one thing that was interesting about the GPars syntax that consisted of declarations of identity, execution tasks and then datafeeding and shutdown code. The tasks are described without identity so it is clearer that you can't assume what is happening with the task except through its output.
It's taken a long time to get here but there's some interesting discussion of the Java 8 Collector API which provides some stream processing that has builtin parallelism.
Rather like a generalisation of the Clojure reducers library which also provides standard Stream processors (because typing, OO, factories)
This is really a Java conference with the serial numbers filled off. We're having the groupBy function explained to us.
Interesting to see C++ syntax to describe what object method you want to use in a map, was expecting to see an explicit lambda rather than syntax sugar.
Got vendored by Twitter but at least it was genuinely an interesting product exception capturing and reporting for Android.
I'm a fan of buying services over running infrastructure for this stuff.
Got stuck in an introduction to Responsive Design which was a weird mix of the really common (Media Queries) with the unavailable (the Picture spec).
The SPA talk is actually a vendor-talk. Another little piece of nostalgia though with a JS implementation of the Service Registry pattern.
Not only that but the vendor is also using require module loading well. All the patterns!
Amazing revelation, Selenium browser testing isn't reliable.
Really interesting quick talk on PayPal's migration from Java/C++ to Java/C++/NodeJS by Cristiano Betta.
Lots of organisational context to the change and a honest statement that performance improvements and reduced developer overhead is probably the result of addressing historical tech debt rather than purely a single tech change.
Using open source is important to attract and retain developers.
Server-side Javascript is more about encouraging developer to move around the stack rather than siloing developers. It also removes the disconnect between the prototyping teams and the production environment.
Mentioned the Dust templating language (originally from Netflix) as a way of unifying frontend and backend development by having a consistent way of templating.
PayPal have open-sourced a number of their NPM modules that they add to ExpressJS to provide the security features they need.
RedHat have renamed JBoss Wildfire. Wildfire! Dude!
More interestingly they are going to base the next iteration of OpenShift on Docker containers.
The two quickie talks I attended were much better than the first three full sessions.
Un-oh another vendor speaker... let's see how it goes.
The Java focus keeps getting more explicit, as if the speakers are picking up on the background of the audience.
A Frenchman is slagging off the British for their Friday afternoon slackness. Incroyable!
Really interesting talk by Martin Thompson about performance. There was a lot of stuff you know but you just push it out of your mind.
Ring buffers, immutability, telemetry, event streams, CPU cache
Interesting use of queue theory to make the point that unbounded queues are dangerous as service time inevitably rises as the number of waiting requests rises. Ultimately the system will fail with unbounded queues.
However the bounded queues can be massive.
Interesting suggestion to let back-pressure to flow back to the end user and have the edge system deny requests. Temporary denial of new requests makes sure that the work in progress remains quick to process.
The final talk on reactive streams (which are fascinating and important) was so rambling and uninformative that I hope people haven't been put off them.
The basic idea of producing a stand interface for Producer and Subscriber objects seems noble though.
People talked about channels and about observables but no-one gave enough information to really be able to discuss the differences between the two.
Garbage collection seems to be the consistent issue in JVM performance. Despite its virtues it would appear that the default values for the JVM no longer make sense and better profiles should be provided out of the box.