In the past decade, RDBMS related traction has moved away completely from SQL towards JPA/JPQL, or even further, towards NoSQL. Evangelists have widely agreed that RDBMS are not "web scale", even if the race is far from being decided.
How do you know what 60 millions users are like? Wix.com is conducting hundreds of experiments per month on production to understand, which features our users like and which hurt or improve our business. In this talk we’ll explain how the engineering team is supporting product managers in making the right decisions and getting our product road map on the right path. We will also present some of the open source tools we developed that help us experimenting our products on humans.
How far have you got with learning about Cloud? Got your head around Platform as a Service? Understand what IaaS means? Can spell Docker? Working in a DevOps mode? It's easy to focus on learning new technology but it's time to take a step back and look at what the technical implications are when an application is heading to the cloud. In the world of the cloud the benefits are high but the economics (financial and technical) can be radically different. Learn more about these new realities and how they can change application design, deployment and support.
Failure of Highly Available (HA) enterprise solutions is inevitable. But in today's highly interconnected global economy uptime is critical. The impact of downtime is magnified when factoring in Service Level Agreement (SLA) penalties and lost revenue. Even more harmful is the damage to an organizations reputation as angry customers vent their frustrations on Social Media. Resiliency, the neglected step-child of Availability, is often an after thought. Yet an enterprise solution without Resiliency is not truly HA.
Apache Cassandra is a leading open-source distributed database capable of amazing feats of scale, but its data model requires a bit of planning for it to perform well. Of course, the nature of ad-hoc data exploration and analysis requires that we be able to ask questions we hadn’t planned on asking—and get an answer fast. Enter Apache Spark. Spark is a distributed computation framework optimized to work in-memory, and heavily influenced by concepts from functional programming languages.
You created a Java EE application using a REST front-end on top of relational database using JPA. Now you need to make it highly available and scalable across a large number of machines. This session will start by introducing CDI and JCache, and will then walk through an example JAX-RS/JPA application. The session will feature a live coding demonstration where we will turn this standard Java EE application, step by step, into a fully clustered application using a CDI extension and producers to integrate Hazelcast as a JCache provider.
How can you make sure that your next Web application supports not only the desktop browser but also all the other devices and screen sizes? And that it can efficiently talk to the back-end services in a bidirectional way?
With new concepts for client-side development such as responsive Web design, MVVM frameworks, and hybrid Web applications, and with new APIs for WebSocket, REST services, JSON, and more, the combination of Java EE 7 and HTML5 is a great fit for new Web applications.
Last year we talked about DevOps, what it was, why it was important and how to get started. Boy, was it scary. Now we're wiser. More battle-scarred. The scale of the challenge for application writers exploiting cloud and DevOps is clearer, but so is the path forward. Understanding the DevOps approach is important but equally you must understand specific deployment technologies. How to exploit them and how they effect the design of applications. Whether creating simple applications or sophisticated microservice architectures many of the challenges are the same.
Normally simple tasks like running a program or storing and retrieving data become much more complicated when we start to do them on collections of computers, rather than single machines. Distributed systems has become a key architectural concern, and affects everything a program would normally do. Using a series of examples all set in a coffee shop, we’ll explore topics like distributed storage, computation, timing, messaging, and consensus.
Why is Paris so beautiful, Netflix so scalable and REST now a standard? This is about analyzing the constraints leading to architecture styles in network-based software as well as buildings. Haussmann invented a scalable model for the city, Fielding established the principles of an internet-scale software architecture (REST), and Fowler described in detail how microservices can get an application to massively scale?
Many small startups build their systems on top of a traditional toolset. These systems are used because they facilitate easy development and fast progress, but many of them are monolithic and have limited scalability. As a startup grows, the team is confronted with the problem of how to evolve and scale the system.
The era of digital service is shifting customers’ brand expectations from stability to responsiveness. Optimizing delivery speed is only half of this new equation. Companies also need to optimize their ability to listen and to act on what they hear. In order to maximize both velocity and responsiveness, companies need to transform up-front design into a continuous, circular design-operations loop that unifies marketing, design, development, operations, and support.
A JVM's Garbage Collector is responsible for finding unreachable objects and releasing their memory so that the application does not run out of memory. Historically, the key concern related to GC was throughput, i.e., the ratio of time spent in GC to time spent in the application's actual functionality. Basically, we did not want to waste precious time with garbage collection.
Feature gluttony is a common sin among IT projects. Customers deliver never ending wish lists of features they want. However, the key is not to build everything, but only things that are really needed. Learn how to defeat feature gluttony by... saying NO ;) And support this by:
- setting a common aim
- finding relation: feature value
- defining most important use cases
- defining critical processes from the business perspective
This talk will examine the various intuitions and trade-offs needed to scale a data-centric application or architecture. Building from the fundamentals of data locality, immutability and parallelism, attendees will gain a sense for how fully blown architectures can be sewn together. The result: a balance of real-time storage, streaming and analytics that plays to the relative strengths of different component parts.
Generics are one of the most complex features of Java. They are often poorly understood and lead to confusing errors. It won’t get easier. Java 10 is planned to extend Generics. It’s time to understand generics or risk being left behind.We start by stepping back to 2004 and explain why generics were introduced in the first place back.Then we travel to the present to explaining how to make effective use of Generics. We then explore various entertaining code examples and puzzlers of how Generics are used today.
In this talk @sleepyfox considers the rise and fall of Product Management from an Arthurian perspective, looks at the current failings of products and the design process and asks the question "Is it time to take a new approach to Product Management, and Product Ownership?"
Radical alternatives to traditional Product Management will be considered, and the audience asked to consider trialling new ways of delivering customer value from their Agile teams.
You may be hearing a lot of buzz around functional programming. For example, Java 8 recently introduced new features (lambda expressions and method references) and APIs (Streams, Optional and CompletableFutures) inspired from functional ideas such as first-class functions, composition and immutability. However, what does this mean for my existing codebase? In this talk we show how you can refactor your traditional object-oriented Java to using FP features and APIs from Java 8 in a beneficial manner.
Not that long ago, API calls were counted per hour. Evaluations for API management tools typically have long lists of criteria, but performance is usually left off. That might be fine in certain environments but not where IoT and mobile are concerned. For these environments the number of API calls has increased to the point that even the typical rate of 200 API calls per second is no longer enough.
Continuous Delivery is gaining recognition as a best practice, but adopting it and iteratively improving it is challenging. Given the diversity of teams and architectures that do Continuous Delivery well (consider Etsy’s monolith compared with Netflix’s 600+ services) it’s clear that there is no single, golden path.
The rapid pace of technological innovation has enabled many organizations to dramatically increase productivity while at the same time decrease their overall headcount. However, the vacillating global economy combined with "change fatigue" within organizations has resulted in a risk adverse culture. In such an environment how can one possibly introduce and inculcate the latest technology or process within an organization? The answer is to have a solid understanding of Diffusion Theory and to leverage Patterns of Change.
Parallel stream operations are supposed to run faster than sequential operations. Is this expection justified? Or is it naive? In this session we will explore when and under which circumstances parallel execution pays off. In order to understand the performance model of streams we will discuss certain internals of streams, for instance iterators vs. spliterators as well as reduction vs. accumulation algorithms. The goal is to enable stream users to come up with an informed guess regarding the performance of parallel vs. sequential stream operations.
Unit tests are the life-blood of any modern development practise, helping developers not only ensure the robustness of their code but to also speed up the development cycle by providing fast feedback on code changes. In reality this isn't always the case and even with the most diligent of refactorings applied, unit tests can actually become a hindrance to getting the job done effectively.
Building a large application often feels like an exercise in futility. No matter how we do it, even test-driving everything, there’s always one more bug. Anything that can go wrong will go wrong. And when deadlines hit, building a new feature while keeping the bugs out is even harder.
So what if things couldn’t go wrong?
You’re probably familiar with object-oriented programming. You know what types are. So what are you missing?