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 :-)
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
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: 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 Hadoop data warehouse using Java
Building a scalable and robust distributed data warehouse has now become much easier thanks to advent of open source technologies like Apache Hadoop, Apache Hive and Cloudera Impala. In this presentation, we will learn how one can build a distributed data warehouse using Java, while leveraging existing open source technologies. The presentation will give a quick overview of each of the open source technologies involved - Apache Flume for log ingest, Apache Hadoop, Apache Hive and Cloudera Impala for storing and processing the data, Apache Sqoop for transferring the data back and forth between Hadoop and your relational DB, etc. We will then discuss another important part of the talk - how each of these technologies integrate with Java and other JVM based languages. In essence, we will learn how we can stitch all these open source pieces of technologies using Java to form a coherent and robust data warehouse.
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: 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.
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.
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
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!
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: G-Force! Self-Powering Global Sensor Nets for the Internet of Things
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.
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'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.
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.
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
tl;dr - 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.
Presentation: Lightweight messaging for applications in the Internet of Things
What is Paho? In the Maori language, paho means "broadcast, make widely known, announce" - and in this talk we'd like to make sure that more people get to know about Paho, a very cool messaging protocol contributed to the Eclipse Foundation by IBM and Eurotech. Paho is an implementation of MQTT - a lightweight, scalable, messaging system for connected devices and the Internet of Things. There's a large community now working with MQTT on a daily basis, and more and more systems using the protocol. We?ll look at the protocol, some example code, how Paho relates to other projects, and talk about interoperability with other Java-based MQTT-capable brokers like HiveMQ and ActiveMQ (and maybe some non-Java ones as well...)
Presentation: Map, flatmap and reduce are your new best friends
In this talk you will learn how these and other higher-order functions enable you to write simple, expressive and concise code that solve problems in a diverse set of domains. We will describe how you use them to process collections in Java and Scala. You will learn how functional Futures and Rx (Reactive Extensions) Observables simplify concurrent code. We will even talk about how to write big data applications in a functional style using libraries such as Scalding.
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.
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.
Presentation: Reclaiming discipline in client side web development
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.
Presentation: Smarter Homes with Eclipse SmartHome and openHAB
New IoT or Smart Home devices are hitting the market every single day. Since most of them only connect to their own proprietary backend, they usually do not interact with each other. But what if you need an action on one device to be triggered by a status change of an other device? Overarching automation logic is hardly possible in those setups - this is not really smart.
The Eclipse SmartHome (ESH) project seeks to overcome the challenges of interoperability and introduces a highly flexible architecture perfectly tailored to the needs of developers. It is a flexible framework for smart home and ambient assisted living (AAL) solutions. It has a strong focus on heterogeneous environments, i.e. solutions that deal with the integration of different protocols or standards.
On top of ESH the Duke's Choice Award winning project 'openHAB' (open Home Automation Bus) provides a huge list of free extensions, which allow to easily integrate systems like KNX, Philips Hue, Z-Wave, EnOcean, DMX, Plugwise, Homematic or Sonos.
This talk gives an overview of the things that are relevant in a Smart Home and shows how Eclipse SmartHome and openHAB allows the creation of a personal Intranet of Things. Be prepared to see geeky hardware in the live demo of this session!
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.
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.
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.
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.
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.