Google Glass has been gaining a lot of attention since it's inception and it's not without reason, Google Glass might just be the next big thing.
This presentation will take a developers perspective and in detail explain how Google Glass works, what possibilities and limitations there are, and show how to develop different kinds of applications.
What you will learn:
* How Google Glass works
* What you can (and can't) do with them
* How to set up the development environment and deploy applications.
* How to take advantage of the built in hardware
* How to handle touch gestures
* How to port existing applications
* How to deploy Glassware
* What use cases there are for commercial glass application
This presentation is based on the second generation of Google Glass.
Presentation: A Little Graph Theory for the Busy Developer
In this talk we'll explore powerful analytic techniques for graph data. Firstly we'll discover some of the innate properties of (social) graphs from fields like anthropology and sociology. By understanding the forces and tensions within the graph structure and applying some graph theory, we'll be able to predict how the graph will evolve over time. To test just how powerful and accurate graph theory is, we'll also be able to (retrospectively) predict World War 1 based on a social graph and a few simple mechanical rules.Then we'll see how graph matching can be used to extract online business intelligence (for powerful retail recommendations). In turn we'll apply these powerful techniques to modelling domains in Neo4j (a graph database) and show how Neo4j can be used to drive business intelligence. Don't worry, there won't be much maths :-)
Learn how to take part in Java technology evolution through the Java Community Process (JCP) program. You can participate as an individual, corporation, or nonprofit such as a Java user group (JUG). This session gives you step-by-step instructions on how to participate in the Adopt-a-JSR program and provides tools for running events as part of the Adopt-a-JSR program. It discusses details such as how to run hack days, translate content into local languages, and collaborate with other Java leaders on Adopt-a-JSR activities. In addition, it highlights use cases from JUG hack days and applications developed through the Adopt-a-JSR program.
Almost everyone has heard about Node.js, but lots of people dismiss it as being just "Javascript". In this talk, you'll learn about what Node.js is, why its important you understand it and learn why it's the most powerful web technology in recent years. We will start off Node.js basics, and in by the time we are done you'll be ready to write your first realtime Node.js app!
The web as a platform is now ready for organizations with workflows that demands desktop clients. Single page applications lets you keep your workflows but takes away the need for the clients to be installed on the user workstation. The consolidation of clients in to the web browser simplifies the desktop IT-environment for the IT-departments. The consolidation of clients in to the web browser also makes it easier to make the applications available as a service in the cloud.
This talk is going to show the basic architecture of a single page application and the demands it puts on the backend. This talk is also going to show different client side libraries and frameworks, what to use them for and what the difference between them are.
When mentioning Akka, most of us think of a framework allowing one to design high performant, scalable, and fault tolerant systems. But the question is, how can one utilize the power of Akka when surrounded by legacy?
In this talk, we will share our insights and experiences from developing an international, government approved high performance system with Akka in a legacy environment. Despite that Akka APIs are more favorable in Scala, we decided to go with Java. A decision that turned out to be very important for the business. In addition, we will present how domain specific requirements influenced our design, the traps we walked into, and how everyone may benefit from Akka regardless of green or brown field development.
Presentation: Android Programming: Pushing The Limits
Developing high-quality Android applications is a very challenging task. Besides having to master the UI framework, you need to have a full understanding of your application and components life-cycles, thread-management and data persistent which is unique to the Android platform.
In this session, Erik Hellman will go through some of the tips and tricks covered in his book "Android Programming: Pushing the Limits" as well as show how to take full advantage of some of the more advanced features in the Android platform. Learn how to optimize your background processing, best-practices for ContentProviders, write useful tests for your Android applications, use the hidden APIs efficiently and reduce the work for the garbage collector in a smart way.
Learn how to build "heroic" apps with Angular and Dart. Use Dart's structured language and libraries with Angular's components and data binding. See real code and examples that blend the best of Dart and Angular. This session is for any developer that wants to build for the web with productive tools, familiar language, and modern web frameworks.
Presentation: Angular vs Ember vs Backbone and Knockout in real applications
You've probably heard about MVC in the browser by now. You've heard about Backbone, Knockout, Angular and Ember so you try to make a choice. You read the documentation, you check out the examples and create a simple demo application and finally you choose. Nine months later you are deep in the trenches of the framework and the simple examples suddenly feels misguiding. Did you make the wrong choice?
Joakim made a similar journey. The solution worked fine but since he really wanted to know if a different framework would have been a better choice he decided to try. He implemented several of the most complicated parts of the system using both Angular and Ember and compared it to his Backbone/Knockout solution. In this talk Joakim will guide you through this journey, share his findings and let you know where each framework shines.
AngularJS is a very powerful framework with many unique features. One of the strong points of the framework is its ability to extend HTML through directives. There are endless applications of directives, from creating custom widgets to defining DSL on top of HTML. This hands-on lab is going to introduce participants to writing different types of AngularJS directives like:
- simpler, attribute-based widgets (tooltips, popovers)
- widgets (pagination, date/time picker etc.)
- complex, co-ooperating widgets (tabs, accordions etc.)
- integrating with the NgModelController in order to provide custom model validation, formatting and rendering (buttons, custom fields in date/time pickers)
All the example used during the workshop will be based on the Bootstrap3 widgets. This lab will not only teach you how to write different types of directives but is also going to cover directives testing and best practices and pitfalls.
Presentation: AngularJS: Making a browser a better development platform
This talk will familiarize you with AngularJS JavaScript framework and its revolutionary approach to writing single-page web applications. AngularJS is unique in many ways with its DOM-based, declarative templating, ability to extend HTML vocabulary and strong focus on testing.
AngularJS will be introduced by contrasting it with traditional approaches and showing benefits of the AngularJS-way (extremely concise yet readable code, testability and most importantly ? making web development fun again!). This will be an interactive talk with plenty of code examples.
Presentation: Apache TomEE, JavaEE Web Profile and More on Tomcat
Apache TomEE is the Java EE 6 Web Profile certified version of Apache Tomcat and combines the simplicity of Tomcat with the power of Java EE. The first half of this session introduces TomEE and shows how Tomcat applications leveraging Java EE technologies can become simpler and lighter with a Java EE 6 certified solution built right on Tomcat.
The second half jumps right into action and gives a coding tour of TomEE, including quickly bootstrapping projects, doing proper testing with Arquillian, and setting up environments. If you're a Tomcat lover or a TomEE enthusiast, this is the session you don't want to miss!
Presentation: Apples and Oranges, Highlights of Eclipse, IntelliJ IDEA and NetBeans IDE
Which IDE do you use for Java development? Eclipse? NetBeans? IntelliJ IDEA? Do you know what its most powerful features are? Generally, developers stick to one IDE and configure it to match their daily programming needs. They don't consider a different IDE, not really being aware of what they're missing. Because comparing apples with oranges doesn't make sense, let's instead look at what the key problems are that each IDE tries to solve. Is a hybrid development environment imaginable, where each IDE is available? This session doesn't do a "shoot-out". It shows you what makes each IDE unique, in turn, and what specific problems it tries to solve. And hopefully you'll attend the session and share your experiences.
Bring your favorite questions about Java SE and the Java Development Kit -- past, present, or future -- to this open Q&A session with key members of Oracle's Java team.
Jasmine is the most popular testing framework in the JavaScript world. In this session, we'll explore Jasmine. This session is a code-driven class that covers the Jasmine BDD JavaScript testing library.
A number of disruptive ideas have over the last few years emerged to create what can only be described as a perfect storm for enabling the concept of 'Internet of Things'. The term coined just at the turn of the century describes a way to let our Internet connected computers harvest and process information not only from humans, but also from the things around us.
In this inspirational overview session we will explore the developments that led us to where we are today. We will have a look at the software and hardware technologies that are available to us, how they work, and most importantly, how you can program the things around you to do do what you want!
Presentation: Benefit from Groovy now. When, Why & How!
With over 1.7 million downloads a year, there must be a reason why the Groovy programming language is adopted so much by various enterprises and projects. In this presentation, Guillaume Laforge, the Groovy leader, will tell you about when, why, and how developers integrate Groovy into their projects. You'll learn about integration patterns, business oriented mini-languages, interesting ecosystem projects based on Groovy, and more!
Presentation: Beyond Beauty: JavaFX, Parallax, Touch, Raspberry Pi, Gyroscopes, and Much More
A 3-D environment can provide beauty and immersion in a user interface. Unfortunately, it can be really heavyweight for small devices or even the Web, but there are simple techniques that can make your UI unbelievably realistic without the need for 3-D hardware. A technique often used in video games is to use independent layers that are scrolled at different speeds in a simulated parallax motion. This effect provides the illusion of depth, resulting in a rich user experience. If you include touch and screen orientation, the result is a unique and very realistic interface. Attend this session, which includes demos, to learn about the implementation of this unique UI pattern.
Presentation: Browser IDEs and why you don't like them
Everything has gone Cloud but developers haven't yet accepted tools that are hosted there, why is that? What's missing in the available Cloud based tooling environments that makes a developer cringe? This talk will look at how you build an app on the desktop and how you build it in the Cloud to figure out what are the shortcomings of either approach. You're likely to leave this talk a little surprised at how much you really can do in the Cloud, or by your comments, effect the next set of feature requests.
Presentation: Building a large scale JavaScript application in TypeScript
How can you survive a project that uses JavaScript massively on both the client and the server using node.js? The project is about on-line development components, such as the TypeScript playground (http://www.typescriptlang.org/Playground/) or Visual Studio Online "Monaco", that enables users to edit Azure web sites online. We had an existing large JavaScript code base and we wanted to give TypeScript a try. Today the project is one of the largest TypeScript code bases inside Microsoft with more than 200k lines of TypeScript in production. In this talk I will give a quick introduction into TypeScript and then take a deep look at how TypeScript and other technologies were used to successfully scale up a large JavaScript project that ships in some of Microsoft's biggest products and services.
Presentation: Building an iPhone multiplayer game with a Scala CQRS-backend (IN SWEDISH)
In the beginning of 2013 the multiplayer iPhone game Paintfeud was released. It had then been crafted for the last year as a hobby project with the aim to learn about Mobile development, CQRS, Scala and Event Sourcing. We found out, the hard way, that some of the maxims and common "good design practices" learned from our years developing web applications had to be violated. Especially the unreliable nature of mobile networks as well as the eventual consistency part of CQRS put some extra efforts on both the client, the server and the protocol to make the end user experience good enough. We had to fake state, duplicate logic and trick the end user. Dirty but pragmatic. This presentations takes us through the client and server application, its architecture and its design decisions, focusing on these tricks.
Note! This presentation will be held in Swedish
While Hadoop and related projects (like Hive, HCatalog, HBase, Pig, etc.) have been very popular in the data ecosystem, developers still have to work with very low level primitives when building applications on Hadoop, thereby making Hadoop hard to build upon. A step in the direction of changing that is Cloudera Developer Kit (CDK). CDK is an open source project with the goal of simplifying Hadoop application development. It codifies best-practice for writing Hadoop applications by providing documentation, examples, tools, and APIs for Java developers.
In this presentation, we will discuss the architecture of a common data warehouse built on Hadoop. Hadoop concepts and components (including HDFS, Avro, Flume, Crunch, HCatalog, Hive, Impala, Oozie) will be introduced along the way, and they will be explained in the context of solving a concrete problem for the application. The goal is to build a simple end-to-end Hadoop data application that you can take away and adapt to your own use cases. Attendees should be familiar with Java and common enterprise APIs like Servlets. No prior experience of Hadoop is necessary, although an awareness of the functions of components in the Hadoop stack is a plus.
Tutorial: Building mobile apps using AngularJS, NodeJS, RethinkDB & PhoneGap
Mobile apps are popping up left and right, but as a developer it's very hard to develop on iOS, Android & many other platforms. PhoneGap solves this problem by giving developers a great platform to build HTML5 apps for Mobile. But we can take this further! We can use the power of AngularJS, combined with the speed of Node.js and the flexibility of RethinkDB, you can develop optimized near-native speed mobile apps on iOS & Android with a workflow that's as slick as butter.
Presentation: Building Mobile Backends with the Mobile Backend Starter
Today, building the next generation of mobile apps and scaling them to manage success requires leading edge platforms and infrastructure. In this session we look at how you can use the Google Cloud Platform to build highly scalable, Java-based mobile backends. Using the Mobile Backend Starter and live demos, we'll show how easy it is to deploy and configure a Mobile backend application on App Engine and then we'll walk through development of an android application that makes use of the backend features (Pub/Sub, User Data, Continuous Queries, AuthN) and also look at how you would do the same for an iOS application.
Presentation: Building new IoT Services easily with Open Hardware and Lhings
Rapid prototyping in IoT has become easier in recent years due to the arrival of cheap but powerful electronics that benefit from the open hardware paradigm. In spite of this, the problem of connectivity is still troublesome for most developers. Residential routers, firewalls, multitude of protocols, etc. forces us to write a lot of boilerplate code to make our devices capable of communicating to each other through the Internet. In this presentation we will show how to concentrate your coding effort on what your devices do and forget about network and interoperability issues. We will connect some Java capable devices using Lhings, a cloud service that allows you to connect them easily and manage them from the Internet. The main concepts behind using Lhings will be presented and a live coding session will be performed. If you like getting your hands on code and build IoT services with us, this is your talk!
Technical challenges rarely come in isolation. In any large-scale project they blend with both social and organizational aspects. To address that complexity we need to look beyond the current structure of the code. We need strategies to identify design issues, a way to find potential suspects like code smells and team productivity bottlenecks.
Where do you find such strategies if not within the field of criminal psychology? Just like we want to hunt down criminals in the real world, we need to find and correct offending code in our own designs.
Adam Tornhill promises to introduce both modern offender profiling and its powerful counterparts in the software world. We'll learn how to uncover the wealth of information stored in our code interactions, investigate novel analysis methods and interpret the resulting patterns. To achieve this, Code as a Crime Scene will combine research on software evolution with findings from different fields of psychology.
Presentation: Continuous Delivery and Zero Downtime
Your Continuous Integration system is well oiled and kicks in after every commit. Your code is compiled. Your tests are green. You feel ready to take your project to the next level and move to Continuous Delivery.
This transition can be rough and comes with new challenges. We'll look at 5 essential pillars of software architecture that will make it a success: Environment Detection, Auto-Configuration, Database Migrations, Feature Toggles and State Management. By the end of this session you'll have a solid understanding of what it takes to build applications that can be delivered reliably into production multiple times a day, with Zero Downtime.
Continuous Delivery is all the hype these days. This tutorial Will show how it is set up in reality. We start with an overview of what Continuous Delivery is and how it can help you. We then quickly dive into the details. You will learn what it takes to architect a Java application so that it can be delivered continuously into production, with code, configuration and database delta, multiple times a day, with zero downtime. You'll gain solid understanding of what your architecture must provide to enable this. This tutorial assumes a good understanding of software architecture, the Java language, Linux and relational databases in general. Buckle up! This tutorial is intensive.
Aldebaran Robotics is the world leader in humanoid robotics. Early 2012 the company released the latest version of the NAO robot : NAO Next Gen.
NAO is a state-of-the-art humanoid robot with 25 degrees of freedom. It comes with a complete software suite and SDK to help users programming and interacting with the robot.
In this session, after introducing NAOqi (the programming framework used to program NAO), we will talk about the various ways you can program in Java for NAO.
We will take about Choregraphe: a simple, graphical way to edit movements and write behaviors, and then show you how to use NAOqi from Java with live demos
Presentation: Developing for multi-component environment while keeping your sanity
Managing a modern multi-component application in a continuous integration/deployment environment can be very tricky. In this session we will concentrate on two of the aspects - environment setup, showcasing tools like Vagrant, Chef and Puppet for creating and controlling development, testing, staging, production and other environments and pushing the deliverables through those environments, using tools like Gradle, Jenkins and Artifactory. Join us and get all the little tips and tricks that will help you rule your development world.
Hands-on Lab: Developing Internet of Things services - from chip to phone
This hands-on lab will take you through the development of IoT services from programming small devices up to bringing sensor data from IoT devices to cloud services and smart phone apps. The first part of the session will present some of the recent trends, standards and tools that make the IoT revolution possible. The hands-on part will let you develop applications using several IoT devices such as smart power plugs, LED lamps and CO2 sensor all connected via IPv6 / 6LoWPAN.
In this community BOF, we'll discuss and share experience with DevOps and Continuous Delivery. DevOps is a modern approach in software engineering to foster collaboration of development and operations, by aligning goals, processes, and tools. The term DevOps is heavily overloaded. Let's explore what DevOps is and what not, and discuss how you can start your own individual DevOps initiative in your own company and project.
Are you using Subversion or CVS? That's great, whatever you do, don't migrate to Git! Git makes you work overtime, confuses developers with too many options, destroys the social interaction with your co-workers and much more. Git has unnecessary features like offline commits and cherry picking that nobody needs at his day job. Your code is the most important thing for your software development and you should use a mature technology for storing it. Let the kids play around with Git.
In this ironic lightning talk I will give you 5 reasons, why you shouldn't use Git always with a twinkle in the eye. So create a new branch in SVN and come to my session while you checkout the branch.
Java EE 7 is now final. The platform focuses on boosting productivity, better meeting enterprise demands and embracing HTML5. JAX-RS 2 adds a new client API to invoke RESTful endpoints. JMS 2 is undergoing a complete overhaul to align with improvements in the Java language. Long awaited batch processing and Java EE concurrency utilities are getting added to make the platform richer. A new API to build
WebSocket driven applications is getting added. JSON parsing and generation is now included in the platform itself. There are numerous other improvements coming with this latest version of the platform.
This University session will have a mix of lecture and demos that will provide a comprehensive introduction to the updated Java EE 7 platform using GlassFish
Presentation: Easy Distributed Systems using Hazelcast.
Today's applications are getting more and more distributed everyday and it is well-known that distributed programming is hard. With Hazelcast though, distributed programming is easy and lots of fun. A common reaction of Hazelcast users is "Ooh my God, this cannot be that easy". Hazelcast is an open source, highly scalable, transactional, distributed/partitioned implementation of queue, map, set, list, lock and executor services for Java. Hazelcast is for you if you like to easily: share data/state among many servers (e.g. web session sharing), cache your data (distributed cache), cluster your application, partition your in-memory data, send/receive messages among applications, distribute workload onto many servers, take advantage of parallel processing or provide fail-safe data management.
You don't want your IDE to propose java.awt.List as import when you need java.util.List? This talk will show you how to get rid of the proposal and how to use your IDE effectively to concentrate on your work.
It will cover the most interesting features from the leading Java IDEs Eclipse, IntelliJ Idea and Netbeans. Their default settings give you a good start but there is a lot more to discover to make you more productive. This includes syntax highlighting, editor, compiler and code completion settings. In addition we will try-out the most useful refactoring actions and shortcuts. After this talk you have an overview on how to setup your IDE in a way which will support your working style and will make you complete your work much faster.
Developers choose HTTP for its ubiquity. HTTP's semantics are cherry-picked or embraced in the myriad of apis we develop and consume. Efficiency discussions are commonplace: Does this design imply N+1 requests? Should we denormalize the model? How do consumers discover changes in state? How many connections are needed to effectively use this api?
Meanwhile, HTTP 1.1 is a choice, as opposed to constant. SPDY and HTTP/2 implementations surface, simultaneously retaining semantics and dramatically changing performance implications. We can choose treat these new protocols as more efficient versions HTTP 1.1 or buy into new patterns such as server-side push.
This session walks you through these topics via an open source project from Square called okhttp. You'll understand how okhttp addresses portability so that you can develop against something as familiar as java's HTTPUrlConnection. We'll review how to use new protocol features and constraints to keep in mind along the way. You'll learn how to sandbox ideas with okhttp's mock server, so that you can begin experimenting with SPDY and HTTP/2 today!
Presentation: Every day is like a little DDOS attack. A billion games played per day
King is the number one casual games company for mobile and the social web and are running Java! An insight into the architecture and infrastructure with code and numbers of King where simple solutions support a small, tightly managed feature set for online casual games. With a couple of hundred application servers and half as many database machines in a self-managed colocation, what software architecture permits developers in all King offices to share these resources?
A deeper dive into the inner workings of the storage software stack, and overview of how to deal with some of the implications it brings! Laced with ?war-stories? about real incidents that lead to the solutions and decisions.
Tutorial: From Basic To Advanced Javascript, A Developers Guide
Ok, you know basic OO and basic functional programming. You have "cheated" with Javascript in some web apps by copy and pasting some jQuery code from StackOverflow. This session will take you a bit further on your journey to becoming a solid Javascript programmer.
In the first part we'll just cover the basics in and learn the ins-and-outs of JavaScript at a fast pace. We'll look at the (many) quirks in JavaScript, and work through advanced features that make this language so powerful. We'll look into the details of a prototype language and discuss things like parasitic inheritance.
In the second part of the we'll go from basic JavaScript to advanced JavaScript. We'll talk about JavaScript design patterns, frameworks, and conventions. We'll also look at JavaScript libraries that will help you get the most out of JavaScript - not jQuery, but a library like UnderscoreJS and SugarJS.
In the third part we'll explore the functional side of JavaScript. We'll live code examples that apply things like first-class functions, higher order functions, and currying. We'll see why coding in a functional style is a great way to build larger JavaScript codebases versus imperative style.
This half day university session is meant to bring you up to speed with the latest and greatest JavaScript techniques and tools. Whether you're building client side JavaScript with HTML5 or server-side JavaScript with node.js, you'll come away with knowledge and patterns for how the pro's use JavaScript for building real apps. Come with an open-mind and ready to learn!
Tutorial: From Database into the Web, end-to-end REST Web Services with Spring
Spring offers dedicated support to develop Java Enterprise Web Services: starting with sophisticated but simple data access layers using Spring Data to hypermedia-driven REST web services with Spring MVC and Spring Hateoas. The workshop provides a guided tour to implement a REST web service using these technologies and shows how Spring and it's ecosystem projects significantly ease this task.
Presentation: Futures and Rx Observables: powerful abstractions for consuming web services asynchronously
A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone.
In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available on the JVM. You will learn how to access web services using reactive observables, which are asynchronous data streams. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.
Presentation: G-Force! Self-Powering Global Sensor Nets for IoT
Learn how you can build scalable, performant, self-sustaining Embedded Ecosystems for the Internet of Things using inexpensive devices and Java, powered by modular, small-scale Renewable Energy (solar, wind) systems - and integrate those installations worldwide for a globally-aware, zero-footprint network.
Using low-cost, off-the-shelf hardware including Raspberry Pis, BeagleBone Blacks, Arduinos, and various sensor/control devices, see how you can quickly build, tune, and deploy self-sustaining sensor meshes and the systems to monitor/control them from anywhere in the world with HTML5 and JavaFX Rich Internet Applications and a Java Embedded Suite back-end.
This session takes you from concept to completion and demonstrates the power and accessibility of the Internet of Things via the Java ecosystem.
Presentation: Go Reactive: Blueprint for Future Applications
The game has changed: we write interactive web applications, we distribute the processing of huge data sets and our services need to be available at all times. This new breed of applications comes with its own set of requirements and forces us to establish new blueprints for designing our systems. In this talk we ask the crucial questions along this path, show which answers work and which don't, and distill the essence of the common theme, Going Reactive.
Hands-on Lab: Go Reactive: Hands-On with Play, Akka and Scala
Reactive Applications are the next major evolution of the Internet. They allow for applications to be responsive, scalable and resilient by building on a fully event-driven foundation. Typesafe:s Reactive Platform consisting of the Play Framework, the Akka middleware and the Scala programming language embraces this new programming paradigm which allows developers to write interactive applications that are always available and which adapt to changing load by being distributed by design.
In this tutorial session we will be building a reactive application using Play and Akka. The application will consist of a clustered back-end service and a web front-end querying it using a RESTful API. We will walk through the process of designing such an application and learn how the implementation is structured, including a tour of the tools used for Going Reactive.
Presentation: Griffin, Smart Home Automation over Wi-Fi
Every Home automation, SmartHome or SmartGrid solution presented on the market so far has been built on proprietary communication networks or been hoping for a new standard to win the battle. At the same time 99% of all households already have a perfect infrastructure for home automation, wireless LAN or more generally known as Wi-Fi.
With your already existing wireless infrastructure you also get one more thing for free, and that is the data access to Internet with all its data and services. The turn-key Interactive Wi-Fi-Cloud solution, Griffin, that will enable control of your home by your Smartphone and by Cloud services.
The platform enables developers and manufactures of all kind of Home appliances to get to market in the quickest way with a proven IP-based communication.
Quickie: Grunt, build tool for the frontend slacker
Grunt is a tool for automating the work building web applications. The Grunt ecosystem is huge and it's growing every day. With literally hundreds of plugins to choose from, you can use Grunt to automate just about anything with a minimum of effort.
In this presentation I will show you how to install, configure and run Grunt. I will also show why Grunt is the perfect tool for the lazy developer and possibly answer the question why Grunt would be The Dude's (from the movie Big Lebowski) favorite build tool.
Presentation: Habits of Highly Effective Technical teams
Most software development teams deliver applications over time, over budget and with a distinct lack of quality. However, some organisations and teams are orders of magnitude better, allowing their business to scale and be flexible in a rapidly changing world.
So how do you transform your organisation and teams from a cost center into part of your revenue generating business? How do you get your IT and software development teams to work at their creative best? How do you create those magic "x10" teams that the tech media keeps talking about?
Over the past 12 years Martijn Verburg (aka The Diabolical Developer) has specialised in transforming technical teams. From deep tech start-ups through to ponderous government departments, he'll cover the cultural and technical habits of the highly effective teams.
He's going to unveil the truth, and also tell you what not to do from bitter first, second and third hand experience.
Presentation: High performance reactive applications with Vert.x
Vert.x is a lightweight, high performance, reactive application platform for the JVM that's designed for modern mobile, web, and enterprise applications.
In this talk you will learn about the design principles and motivation behind Vert.x and why we are heading for a reactive future.
You will also hear an overview including demonstrations of some of the key features of Vert.x including the distributed event bus which extends right into the browser, high availability, and the module system. Demonstrations will involve examples in Java, JavaScript, Scala, Groovy and Python.
You'll also learn about how improved build tool and IDE integration simplify the process of developing applications with Vert.x - including short demonstrations of module auto-redeploy from the IDE and executable "fat jars".
Presentation: How I Learned to Stop Worrying and Love Flexible Scope
Not fixing scope too far in the future is one of the cornerstones of agile delivery, but it is at the same time the thing that enterprise stakeholders fear the most. Ironically, being able to change decisions after delivery starts is one of the biggest benefits that companies can get from agile delivery, so it's necessary to stop worrying and embrace flexible scope to get the full benefits of an iterative process. In this talk, Gojko Adzic will show you how to convince people to embrace flexible scope, not only for startup environments but for big enterprise projects as well.
This talk will highlight some of the great tools that are available to teach children how much fun coding is. Also some of the different formats used for reaching kids. Some of the tools highlighted will be Scratch, Greenfoot, Alice, Sagan, Lego mindstorm, Arduino and RaspberryPI. Different formats will be highlighted as there are great cultural differences between the different countries on how children are thought and how after school activities are organized. One of the formats mentioned will be Devoxx4Kids which we are organising in the Netherlands but also some local Dutch programs will be mentioned.
The sea change in HTML 5 is likely to shift the pendulum away from today's thin-client based server-side web frameworks like Struts 2 and JSF to JavaScript powered next generation rich clients. With strong support for REST, WebSocket and JSON, Java EE is well positioned to adapt to this change.
In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript rich client technologies like AngularJS, Backbone, Knockout and JQuery to utilize the core strengths of Java EE using JAX-RS, JSR 356/WebSocket, JSON-P, CDI and Bean Validation. We will also introduce Oracle's own JavaScript rich client solution code named project Avatar.
We bring the "things", you do the hacking...
With new low cost devices entering the market, access to the world of embedded computing is become more cost affordable. And, with continued advances in Java, developers can easily begin creating innovative applications that leverage these low cost devices.
We will bring a variety of embedded devices, sensors, screens, and toys that you can program in Java. After a short demonstration, we will give you the opportunity to experiment with the hardware to create your own innovative device mashups. Let's see what creativity the Jfokus audience can come up with to build the Future!
Presentation: Is It A Car? Is It A Computer? No, It's a Raspberry Pi Java Carputer
Since 2001 all petrol engined cars sold in Europe are required to be fitted with a European On Board Diagnostics (EOBD) interface. Low cost connections to this provide Wi-Fi access to raw car system data. The Raspberry Pi provides a low cost ARM processor based embedded system for multiple uses. This session will look at how Embedded Java and a Raspberry Pi has been used to communicate with the diagnostic and management systems of an Audi S3 and process the data. With the addition of a touch screen we will show how JavaFX has been used to provide an in-car informatics system for less than $200.
Adding an accelerometer to the hardware configuration allows us to measure the forces affecting the car. Exciting data like G-forces, lateral loads, power output and acceleration times can all be added to the display. By accessing CAN bus data it is even possible to repurpose things like steering wheel buttons to provide hands-free control of the interface.
Videos of the system in action will be shown.
Presentation: Java 8 Language Capabilities - What's in it for you?
There is a good amount of excitement about the new version of Java. The big evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to put them to good use.
Presentation: Java application platforms for design-to-cost embedded systems
To address software complexity challenges in the embedded market due to availability of new embedded microcontrollers (MCU) with more than 512 KBytes of program memory, we will demonstrate how proven Java application design strategies (Object Oriented Programming and virtual platforms) can apply to design-to-cost embedded electronic systems.
During this session, we will describe mature Java solutions to sustain efficient design processes for embedded systems in order to meet fast time-to-market and to provide the Java engineering community with new opportunities to design software for such systems.
We will explore: (1) regular Java application platforms for microcontrollers such as STMicroelectronics's STM32 MCUs; (2) Java synergies with underlying Operating System and C code; (3) Graphical User Interface design with MicroEJ MicroUI/MWT Java solution; (4) OSGi Service Oriented Application design with MicroEJ "Hardware As A Service" solution dedicated to Internet-of-Things gateways.
The concept of Platform as a Service promises a deployment and runtime option where operating systems and services are managed for us, where scalability concerns are handled more or less automatically, and where late-night calls about unavailable systems are a thing of the past. But what is the current state of these offerings? What options are available for running Java applications, and what do they offer? How mature are they? How do I deploy and run my application in a PaaS? What special considerations must I take when building my application to run in the cloud?
In this hands-on lab we we will take an in-depth tour of the current Java PaaS landscape. We will discus key vendors' technology stacks, and compare their different offerings. We will also discuss how to build portable and PasS friendly applications, how to managed monitoring and how to do backups and all that other stuff needed in a live production environment.
During the hands-on lab attendees will deploy a simple, but non-trivial application onto a couple of cloud offerings to get a feel for how it is done, what the tooling looks like and key differences and similarities between the offerings and how those impact the application.
Attendees will need to bring their own computers. Prepared Linux VM:s will be provided for experimentation.
Presentation: Java SE 8 for Tablets, Pis, and Legos
This is not your grandfather's Java ME. Deep dive and demonstration on the new Java SE Embedded support for ARM processors. We will demonstrate the full power of Java SE 8 running on consumer tablets (iOS/Android), embedded devices such as Raspberry Pi and PandaBoard, and the new Lego Mindstorms EV3, all of which use low power ARM chips. See end-to-end coding on devices, discuss coding practices for building performant applications, and get the low down on what is supported and what is not.
Presentation: Lambda Expressions: Myths and Mistakes
How will the everyday developer cope with Java 8's Language changes? Java 8 will ship with a powerful new abstraction - Lambda Expressions (aka Closures) and a completely retooled set of Collections libraries. In addition interfaces have changed through the addition of default and static methods.
The ongoing debate as to whether Java should include such language changes has resulted in many vocal opinions being espoused. Sadly few of these opinions have been backed up by practical experimentation and experience.
Are these opinions just myths?
What mistakes does a developer make?
Can a "blue collar" Java Developer cope with functional programming?
Can we avoid these mistakes in future?
In London we've been running a series of hackdays trying out Lambda Expressions as part of the Adopt-a-JSR program and have been recording and analysing the results. Huge topics of mailing list discussion have been almost entirely irrelevant problems to developers, and some issues which barely got any coverage at all have proved to be a consistent thorn in people's side.
This lab will take the attendees through a number of task using the new Lambda expression syntax, which is part of the next release of Java, JDK8. In addition the lab exercises will let the attendees experience the way the Java class libraries have been improved to make using Lambda expressions incredibly powerful by including elements of functional programming. The new Stream class and its associates will be covered.
You never develop code without version control, why do you develop your database without it? With Liquibase, database changes are stored in human XML-files and committed to the source control system. Changes are applied to the developers local databases. As changes are committed they are distributed to all other environments including all developers local databases, test databases, staging databases, and even to production databases. This presentation will introduce you to Liquibase and the topic database change management. The presenters will also some advanced topics based on real life experience, a few tips and tricks and lots of demonstrations on stage.
What can software development learn from the motor racing industry? In the 1970's we began to see over specialisation of drivers and designers leading to drivers who knew little about how their cars worked. Jackie Stewart, 3 times F1 world champion, coined the phrase "Mechanical Sympathy" as a term for the driver and the machine working together in harmony. This can be summarised in that a driver does not need to know how to build an engine but they need to know the fundamentals of how one works to get the best out of it.
For software development, have we reached the point of over specialisation whereby developers no longer understand the fundamentals of how a computer works? Are we more influenced by fashion than science these days? Is fashion just a poor proxy for stylish design that can co-exist with science?
In this session we will explore these questions and how we can strike a balance between elegant design and the application of science in the development of great modern software.
Java SE 8 brings a variety of improvements to the "metadata" features of the Java language and platform. Type annotations which enables enhanced static checking were added to the language and libraries, the restrictions on repeating annotations were lifted, and the ability to reflectively get parameter names were added. This talk will introduce these features and highlight some of the considerations that went into the design.
Mobile development is hot - and there's a bevy of options for developing mobile apps. If you're looking at cross-platform solutions, there's a multitude of options to choose from. In this session we'll explore the three basic categories for developing mobile apps: native, cross-platform-to-native, and mobile web. We'll discuss the sweet spot for each of these three approaches and the benefits and drawbacks of each. Technologies discussed include Android, iOS, HTML5/CSS3, Phonegap, and Titanium.
The Streams API is set to become as important in the future as the Collections API is today. But to find our way around it, we will have to discover new idioms - and forget some old ones! This session analyses Stream operations and investigates the role of collectors. We will end by using Streams to implement some typical bulk processing problems in clearer, more efficient, and more parallelizable ways than traditional loop processing.
Quickie: NoSRV Architecture: Dynamic web applications without backend servers
Expect higher loads? Run fewer servers! Save your headaches and money for other things and get rid of your web and app servers. By letting the browser directly and securely access managed services with HTTP APIs you can build dynamic, data driven applications without having to care about server infrastructure.
In this session we'll see how a new type of two tier web application is made possible on Amazon Web Services by integrating mechanisms like federated authentication, CORS, REST APIs and fine-grained security policies. As an example we'll look at how a simple blog application with file upload capabilities can be implemented in just HTML and JavaScript using S3 and DynamoDB as the backends without any custom server side logic.
Learn how you can use the same techniques to decrease the load on your own servers to easier scale up and lower the cost of your infrastructure.
This informal BOF will cover latest news and discussions of OpenJDK, JCP and Adopt OpenJDK/JSR, the two JUG lead programs to gain more developer involvement in Java standards as well as the language and the platform itself. All levels of experience are welcome and we will make sure that your questions are answered and that you have some concrete activities you can get started on to help change the future of Java! We also will discuss most wanted features of JavaEE 8
Presentation: Performance Testing with a Raspberry Pi Wall Running Java
In this session, learn how a large number of cheap Raspberry Pi computers running Java can be combined into a powerful load testing engine for networking applications and how this tool has been used in the real world. The Raspberry is fun, and with Java it shines.
Presentation: Practicing at the cutting edge: Learning and unlearning about Java performance
They say that wisdom comes with age. Like many concepts in software, we have an imperfect proxy here. Age being the imperfect proxy for experience, discovery, and learning. When pushing a technology to the limits of performance one has a lot to learn and then unlearn over time as the language, runtime, operating systems, and hardware evolves.
Martin will reflect on his experience with Java since its inception. Starting with building financial GUIs to run on OS2 and NT, then the era of Servlets and J2EE, streaming data and media concurrently to thousands of devices, processing and indexing the largest catalogues, encryption on mobile phones, LMAX and the Disruptor, and the current generation of low-latency trading applications that must cope with millions of events per second with latency measured in the microseconds.
The talk will focus on the major steps in the evolution of Java and how it contrasts to C/C++ over time. We will also cover the challenges of pushing the limits of performance plus the need to collaborate with industry experts and organise our teams, which often stands at odds with the development culture in many industries and organisations.
Tutorial: Programming in Functional Style with Java 8 Lambdas
Imperative style programming has been the de facto practice in Java until now. That's changing in Java 8, thanks to lambda expressions. With this new facility we can create applications that are more functional in style. While there's change in syntax, the biggest change is in the way we will program, the way we will express our design ideas.
Function style of programming has several benefits. With the declarative style it promotes, our code will start to closely resemble the problem statements. By favoring immutability, we will be able to create code that's less error prone, easier to understand, and easier to maintain.
In this session we will take a deep dive into the functional style of programming in Java 8 using lambda expressions. We will start from familiar grounds, explore some design options, and refactor code to more functional style. Along the way we will explore the new facilities offered in Java 8 and how we can make use of them.
The Rasberry Pi is a 25 USD, credit-card sized computer that that plugs in to any HDMI TV and USB keyboard/mouse. It includes an ARM chip that is powerful enough to run Linux and a full Java Virtual Machine. The possibilities are endless!
In this BOF we will discuss, hack and get tips and trix on how to get up and running with the Rasberry Pi. Everyone can join and we are eager to here all about your cool projects and experiences.
The Rasberry Pi is a 25 USD, credit-card sized computer that that plugs in to any HDMI TV and USB keyboard/mouse. It includes an ARM chip that is powerful enough to run Linux and a full Java Virtual Machine. The possibilities are endless!
In this BOF we will discuss, hack and get tips and trix on how to get up and running with the Rasberry Pi. Everyone can join and we are eager to here all about your cool projects and experiences.
Presentation: Reclaiming discipline in client side web development
We all know the history of JavaScript and the browser - originally JavaScript was just snippets of code here and there to do pretty little effects. The modern web application though often has more code in the client side than the backend, code that implements business logic, and code that can often be the most complex part of the system. Yet solid engineering disciplines such as separation of concerns, dependency management, code reuse and unit testing are applied to JavaScript code in enterprise projects in an ad-hoc fashion - as nice to haves, not as givens that you must have at the start of a project. This presentation will show how Play Framework will, out of the box, get you started with writing well engineered rich client web applications, allowing you to apply the same engineering practices as givens as you apply to your backend code.
Presentation: Reliable real time processing with Kafka and Storm: When off-the-self is just not good enough
At Spotify we produce tens of terabytes of data each day across several data centers on multiple countries. Trying to build and maintain a platform to transfer this amount of data each day is not easy. Traditional off-the-shelf messaging products, such as Active MQ or Rabbit MQ would just break under the load in scenarios of this scale. Recently we deployed our new system based on Apache Kafka and Storm to enable us to transfer and process this data in near real-time.
Even with Kafka and Storm you will only get at-least-once delivery of messages. However our situation needs a stronger delivery guarantee than that. We have implemented an end-to-end acknowledgement subsystem on top of our Kafka that provides at-least-once semantics and supports most failure scenarios that are reasonably likely to occur.
In this presentation we discuss the architecture of our system, the rationale behind it and the challenges getting it into production, covering TCP security issues, JVM GC tuning and monitoring.
Presentation: REST Assured - Hypermedia APIs with Spring MVC
Spring MVC forms a solid foundation to implement REST based web-services in Java. However, in real-world projects developers still face challenges when it comes to advanced questions of REST. How to really leverage hypermedia? How to model more complex business functionality with REST. The talk introduces the Spring RESTBucks sample project to implement a business process in a hypermedia-driven way and discusses approaches to challenges in implementation and how the Spring HATEOAS library helps overcoming them. We also dive into new Spring MVC testing features introduced in Spring 3.2, that make it easy to integration test REST webservices.
Frameworks like GWT and Vaadin take care of some aspects of information security on the developers? behalf whereas other aspects are still up to the developer to get right. This presentation walks through the OWASP Top 10 list of typical security flaws and investigates how they relate to applications developed using GWT or Vaadin. The goals of the presentation is to show how a mature framework can improve security and to make developers aware of aspects that they still need to handle themselves.
Presentation: Scala macros: What are they, How do they work & Who uses them
Macros are one of the new features in Scala 2.10. So far they are marked as experimental, but I think nobody has doubts that they will stay there for good. Introducing macros was quite controversial, as Scala isn't a "lean" language already, but I think it was worth it.
Macro is simply a Scala program, executed at compile-time, which manipulates the AST of our program. While we probably will mostly write macros when creating a library of a framework, rather than in day-to-day work (hopefully!), for sure it is good to know what are the mechanisms behind them. In the presentation, I would firstly like to show step-by-step how to write a simple macro and how does it work. In the second part I will present libraries, which already use macros (but without implementation details), such as ScalaMock, Expecty, Slick or my own, MacWire.
The major cause of web insecurity is insecure software development practices. This highly intensive 4-hour bootcamp provides essential application security training for web application, webservice and mobile software developers and architects. This bootcamp is a combination of lecture, demonstration and code review. Participants will not only learn the most common threats against Java web and webservice applications, but more importantly they will learn how to also fix the problems and design secure web solutions via defense-based code samples and review. This session is for all web application developer or architect, web security professionals and development managers who are tasked with building secure web applications, web services and mobile applications.
Perhaps you're on a team without testers struggling with shaky releases. Perhaps you're the curious type who likes to know a little bit about everything. Perhaps you just give a damn about quality.
This tutorial is for anyone who feel that they would like to be better at testing and learn how to apply it in an agile context. We want to release value to our users as often as possible, how do we combine that with maintaining good quality? What kind of testing should we do to get the most bang for our buck?
We will explore the mindset and concepts which help you towards this goal. For example, what you can do to shorten your feedback loops and find defects earlier. You will also learn what exploratory testing really is (no, it's not just clicking around hoping for some bugs) and how do it well. At the end of this tutorial, you will have the tools to evaluate where your team is when it comes to testing, inspiration for where you would like to be and know how to perform efficient exploratory testing. Take this opportunity to increase your impact on the quality of your software. Your colleagues will be impressed by your new bug finding skills!
Presentation: Tackling complexity in giant systems: Approaches at Google, Microsoft, Amazon, Netflix & VMware
Systems architecture evolve in cycles every 15-20 years, oscillating between centralization and decentralization, but growing in size and complexity. The last cycle shifted from vertical to horizontal scalability for hardware, applications and data platforms. This talk will describe approaches used by some of the companies who pioneered cloud platforms to tackle complexity when building these giant distributed systems.
Presentation: Ten cool things we can do with popular JVM Languages
Languages offer a lot more than syntax and compilers. They often have supporting libraries and special facilities that set them apart from other languages. Some languages offer special compiler support for a particular construct, like tail call optimization, for example. Others provide interesting library support or capabilities. In this presentation we will dive into 10 cool things we can do with different languages on the JVM, to improve our productivity and ease development. If mixing languages is an option on your projects, you will have ten more reasons to move forward after this presentation.
Keynote: The Arduino User Experience - looking at IoT from just a hardware abstraction layer
Arduino is an open source hardware and software project that has inspired the creation of a whole ecosystem of companies dedicated to connecting with the physical world. Many of those are nowadays running the IoT race, trying to push their products to the masses.
The big question is which steps need to be taken in order to make an IoT project succesful, understanding the market vertical and all its parts is key. In Arduino we see four big verticals within IoT: home, industrial, personal and education. Each one of them needs different approaches to solving the challenges of a platform.
Not only good technology is needed, but also the capability of integrating with others, easy installation methodologies, great user experience, good deals with communication providers and even installation crews to deploy your physical devices.
This talk will make a quick introduction to the Arduino platform and history, will give examples of projects implemented by some of the Arduino users, will highlight some of the issues people find when trying to create IoT platforms by themselves. As an example, the talk will depict Arduino's take on connected objects from 2005 and the company's current strategy within IoT.
The speaker will also introduce the work done by Arduino within the FP7 framework in the creation of connected devices, highlighting the complexity of getting companies, universities and research centers to collaborate in making the vision a reality.
Enterprise Java developers value reliability and stability, but what happens to your technology stack if you're willing to take a risk? At jClarity we're running production systems using Html 5, Angular.js, vertx, Mongo, groovy and deploying using chef. Its been an interesting ride: some things worked really well and some things don't.
Come along and find out what we'd recommend and what we'd avoid with hindsight. We'll also talk about how we ended up with such a diverse stack and how to make technology choices in a fairer way. We've made the mistakes so you don't have to.
Write once run anywhere is both a blessing and a curse. For years, the WORA promise has ensured a consistent, compile-free experience for JVM users. Unfortunately, sometimes pure-Java libraries just can't do what developers need done. Sometimes, you just have to go full native. The Java Native Runtime is a core library and suite of support libraries
for binding and calling out to native code. Without writing a line of C, you can make native calls, pass callbacks, and manage off-heap memory; every OS, library, and kernel-level feature is available to Java developers.
I'll show how JNR is designed, compare code and performance with alternative approaches, and talk about why the JDK needs a standard FFI (foreign function interface) in Java 9.
Presentation: The Java Virtual Machine on Gemalto M2M products
Gemalto has been delivering M2M solutions for more than 15 years and a pioneer in Java for cellular M2M. Gemalto's new generation of Java-enabled Cinterion modules deliver a powerful platform for a wide range of IoT and M2M applications. The Concept Board allows quick prototyping while Terminals enable a quick market entry and modules allow for cost optimized design. Use this session to learn how build and run a HelloWorld application using Gemalto's cellular M2M solutions.
Presentation: The Modular Java Platform & Project Jigsaw
Project Jigsaw aims to create a simple, friendly, and scalable standard module system for the Java Platform, and to apply that system to the Platform itself so as to improve its scalability, performance, security, and maintainability. This session will explain its key goals and design principles, show the progress made in the past year, and demonstrate its use.
Yanzi is releasing an open-source based Internet of Things development kit with Smart plugs, LED-lamps and DIY boards all using low-power IPv6 wireless connectivity. The presentation will show the development kit and what you can do with it both if you just intend to use the devices as is or if you like to reprogram the firmware of the devices.
Quickie: Tips and tricks for releasing with Maven, Hudson, Artifactory and Git
Maven is a mainstream build tool that does a great job in building the application. On the other hand, often, releasing is still a pain. Maven's release plugin isn't always the best solution for releasing the software. This session shows how to do better. We go through some tips and tricks to streamline your Maven release process and to make it even more lightweight. We'll integrate Maven with the build server Hudson, the binary repository manager Artifactory and the version control system Git.
We cannot firewall or patch our way to secure websites. In the past, security professionals thought firewalls, Secure Sockets Layer (SSL), patching, and privacy policies were enough. Today, however, these methods are outdated and ineffective, as attacks on prominent, well-protected websites are occurring every day. Most every organization in the world have something in common, they have had websites compromised in some way. No company or industry is immune. Programmers need to learn to build websites differently. This talk will review the top coding techniques developers need to master in order to build a low-risk, high-security web application.
Presentation: Truly Native Java Apps on iOS with RoboVM
RoboVM is a new open-source project with the goal of bringing Java and other JVM languages to iOS devices. The RoboVM ahead-of-time compiler translates Java bytecode into native code that runs directly on the CPU without the overhead of an interpreter. Access to the iOS Cocoa Touch APIs is provided through a Java to Objective-C bridge enabling the development of apps with truly native UIs and full hardware access. In this talk you will be introduced to RoboVM. We will demo JavaFX on iOS and show some libgdx based games which have already been ported to RoboVM and iOS.
Why are some organizations better, sometimes much better, at reaching their goals?
Can we explain & understand the difference in ways that help us transition towards higher performance?
I believe we can and that the answer is straight-forward, surprisingly simple & actionable.
This session will be about the surprising power of mindset, at the personal, group
& organizational level. Covering topics like:
* why is 'mindset' important?
* what can we predict from different personal mindsets?
* how do these findings apply to an organization?
* an introduiction to a simple model of organizational effectiveness
The former JRockit Mission Control (JRMC) is now called Java Mission Control (JMC) and is a tools suite which includes tools to monitor, manage and profile your Java application without introducing the performance overhead normally associated with tools of this type.
The main and most important feature is the Flight Recorder. The Flight Recording feature work with events produced by the underlying JVM. This means that the overall profiling overhead for your applications stays at less than 2%.
This session will discuss how to use the Java Flight Recorder to analyze various aspects of Java programs running of the Oracle HotSpot JDK.
The presentation will:
* Explain how the Java Flight Recorder works.
* Show different ways to control the Java Flight Recorder.
* Show examples on how to analyze recordings in different ways.
Presentation: What do you mean, backwards compatibility?
The Java driver for MongoDB has been around almost as long as the NoSQL database itself. It was designed without some of the modern Java features we now take for granted, and the API might be easier with features like lambdas.
The existing Java driver is extensively used, which leads to a tricky question: how do you create a new API that uses modern development patterns whilst retaining backwards compatibility? Your users are fundamental to the success of your business, you do not want to alienate them, break their systems or make it hard for them to migrate to the New World Order.
In this presentation Trisha will share some of the pain experienced and solutions tried while creating a new Java driver for MongoDB.
Presentation: XMPP in the world of IoT - An open standard for interoperable IoT
Talk on how XMPP fit into the world of IoT. The big advantages, technologies, possibilities, and differences.
The XMPP Standards Foundation has accepted a series of extensions for internet of things available at http://xmpp.org/extensions/.
The talk is about how XMPP could be a solutions to several of the challenges in deployment of massive IoT.
This talk gives an example on how to connect realworld devices using the extensions XEP323 and XEP325.
Have you felt the deep thrill of creating a small contribution to the gigantic Java platform? If you haven't, it might be intimidating to even try to think of where to start.
Java is open source through the OpenJDK project. The OpenJDK community secures the Java platform for the future, by driving it in new directions - demanded by the need of 10 million developers. Find out how to start your career in open source, how to contribute to Java and the current status of the OpenJDK community.
Google Glass has been gaining a lot of attention since it's inception and it's not without reason, Google Glass might just be the next big thing.
This presentation will take a developers perspective and in detail explain how Google Glass works, what possibilities and limitations there are, and show how to develop different kinds of applications.
