This workshop will start from scratch and walk you through how to develop an Angular 2 application. We’ll cover how to build components, forms, services, and how all the various pieces fit together. You will walk away with a solid foundational knowledge of Angular 2 and be comfortable with starting your own app or contributing to a team.
An increasing number of people are chosing to have NFC tags implanted under their skin. These implantable keys have a multitude of uses: information storage, replacing key fobs and swipe cards to access buildings, memberships and public transportation, as well as unlocking and personalizing personal devices and even making payments.
In this full day workshop with world leading industry experts we will learn about uses and develop solutions for NFC chip implant uses. Participants will get a broad orientation of current and potential uses based on personal user cases. For those who are interested we're offering free implants to all participants.
The workshop will include both hardware and software elements depending on participant interest.
Join us in exploring the ultimate technology frontier: the upgraded human body!
09.00-10.30 Introduction to NFC implants and uses
Different user cases for chip implants. Useful reference sources. Emerging future applications of implants. Hannes Sjoblad, Bionyfiken.
Concrete hacks and solutions – unlocking my computer and other private devices and systems. Patrick Lanhed, DigitasLBi Sweden
10.30-10.50 Coffee break
10.50-12.00 Implanting and discussion
Live chip implanting and discussion on practical and health aspects of implanting. Jowan Österlund, Biohax International
12.00-13.00 Lunch break
13.00-14.30 Hacking workshop part 1
Platforms that are currently used for NFC interfacing for payments, access and identification. Led by Theo Franzén, Fidesmo
If you want to join in on the fun coding action you should have:
The latest version of the Android SDK
An Android 4.4 or higher device
A recent version of Android studio (stable)
A recent version of the Android support libraries
Clone this repo https://github.com/Franzaine/ImplantCommunicator
14.30-15.00 Coffee break
15.00-16.30 Hacking workshop part 2
Led by Juanjo Tara, Arduino
Platforms for using chip implants for bitcoin payments
Compression of data on chip implants
If you haven't been living under a rock the last couple of years you have probably heard about docker. But, what is it and why should you care?
What? A Docker container gives you the benefits of a virtual machine, no hardware needed and isolation of your application, without the drawbacks, having to ship an entire operating system with your application, slow startup time, and difficult host interaction.
Why? As developers, we want to use the best (often the newest and shiniest) technology to solve a particular problem. As operations people, we want to use proven, well-tested technologies. Docker helps to solve this age old conflict.
In this workshop you will learn why Docker and containerization is the future of DevOps and how to use it efficiently. You will learn how to build, run, and link containers, what volumes are and what they are used for.
You will also learn about some orchestration solutions which exists for managing a cluster of containers, both locally and in the cloud.
React is both easy and simple to learn and use. After learning a few core ideas, building complex web interfaces rapidly becomes almost trivial. In this workshop, we will be learning ins and outs of React and at the end of become ready to use React in our existing and new projects. One of the major selling points of React is that it lives happily with existing technologies so that one can transition to React in an existing application piece by piece, rather than committing to it fully and we will see how React makes this easy.
One of the most important reasons React has become popular has been its speed. In this workshop, we will go over this issue and learn about virtual DOM which makes React this fast, but most importantly we will see that speed is actually not the biggest selling point of React. We will argue that speed of development, simplicity and ease of reasoning about code written with it is of utmost importance and we will observe how thinking in terms of isolated components makes building UIs effortless and designer friendly.
We’ll never be able to understand large-scale systems from a single snapshot of the code. Instead, we need to understand how the code evolves and how the people who work on it are organized. In this workshop you'll learn novel analysis techniques to support both technical and organizational decisions around your codebase.
The techniques are based on software evolution. They use data from the most underused informational source that we have in our industry: our version-control systems. Combined with metaphors from forensic psychology you'll learn to analyze version-control data to:
• Identify the code that's most expensive to maintain amongst millions lines of code.
• Predict the modules that are most prone to defects.
• Detect architectural decay and learn to control it.
• Analyze different architectures such as layers and microservices.
Since large-scale software development is also a social activity, we'll make sure to cover techniques that let you:
• Build a knowledge map of your codebase.
• Understand how multiple developers influence code quality and what you can do about it.
• Get a psychological perspective on the challenges and pitfalls of large-scale development.
We'll analyze systems written in different languages such as C#, Java, and Scala. Since the techniques you'll learn are language agnostic, you will be able to apply them to your own codebase immediately. Once you've finished this workshop you'll have a completely new way to look at your codebase and experience of using the Empear Analysis Suite.
This workshop is delivered in a practical hands-on style. We'll mix theory with hands-on analyses. The exercises are done by analyzing real-world systems to find real problems.
All analyses are done with Empear AB's Analysis Suite and you will be provided with a trial version of the tools during the workshop.
This workshop is for programmers, software architects and technical leaders with programming experience.
While we use Git for the exercises, the tools aren't limited to Git and we'll also discuss how you use them with other version-control systems such as Subversion and Mercurial.
Agile has a problem. When we started out with Agile, people used it because it made their lives and products better. Now people complain that Agile is about meetings, top-down mandates, and wasting time. We can do better. It’s time for a change.
In response, Diana Larsen and James Shore developed The Agile Fluency™ Model. The model describes how teams grow in their understanding of Agile over time. It's a descriptive model, because it reflects what happens in the real world, and in it's an aspirational model, because you can use it to understand how to invest in improving your teams.
We've found the model very useful for helping teams, managers, and executives understand what they can get from Agile and what they need to invest in order to get those results. The model's emphasis on concrete outcomes means executives are open—even eager—to devote the effort needed. Leaders appreciate being able to see the tradeoffs and make a strategic decision, and teams thrive when given meaningful goals and the time and resources needed to achieve them.
In this workshop, led by Diana Larsen, together we’ll dig deeper into the model, including:
Agile Fluency Model Overview
Bringing Agile Fluency into your organization
Examples of Agile Fluency in real-world teams
Examples of organizational investments
Supplemental materials for metrics and assessments
Agile principles and practices in the model
New directions and support for the Agile Fluency Model
React has a fundamentally new approach to UI development. Perhaps its most interesting capability is that it isn't limited only to the web: it can render native iOS and Android apps, too. In this session, we'll walk through how to build a new rendering backend for React targeting native desktop apps. This isn't a simple webview in a desktop app. This is a full-blown React backend targeting the native widget set, but powered by Node.js running on the desktop. This is an advanced workshop where we'll pop the hood of React and take a look at its internals, so get ready to learn a lot!
Sociology is inherently what makes Agile software development methods different from their predecessors. Other aspects of Agile such as pride of workmanship, craftsmanship, focus on quality, testing, highly iterative development, incremental small batch development, and a focus on human psychology were not new, many of these aspects of Agile dating back to the 1960s. The new element in 2001 was sociology - collaborative working in a high trust environment.
This talk will explain how a deep understanding has been used to engineer the growth of the Kanban movement globally, and how different mechanisms in the Kanban Method can be used to increase social capital in the workplace with a significant economic, social and psychological payoff for both business and individuals that work within those businesses.
InfluxDB is an open source time series database with no external dependencies. This talk will introduce you to InfluxDB's API for writing and querying millions of time series. We'll look at the SQL style query language and the various functions and transformations that can be run against series in the database. I'll also introduce concepts around clustering, data retention, and data summarization.
Angular2 rethinks how data flows through your application - learn how, why, and what to do to get ready for the next level of Angular development.
curl and libcurl can probably be considered corner stones in of client-side Internet transfers and in particular HTTP, running on every imaginable operating system and CPU architecture in use today. Started in the late 90s, the project now counts perhaps more than one billion users. Daniel takes us through how it started, how it works and why it never gets done.
Is testing keeping up with the advances of software development? Are our approaches evolving as quickly as the new technologies, or are we being left behind, using the same methods and techniques as we did decades ago?
Testing needs to get more innovative! Scientific discovery relies on innovation; on scientists being willing to pursue new ideas even if it means having to learn new methods or technologies. Similarly testers need to be creative and courageous, exploring new approaches and questioning old habits. Science is credible, curiosity-driven, critical, impartial and dynamic; science continuously challenges and questions methods, techniques and core beliefs. Shouldn’t testing do the same?
Taking inspiration from the scientific method, this session suggests an approach for testing that encourages innovation through creativity and collaboration. You are provided with new insights that can help you re-invent your testing!
Writing software for a virtual machine allows developers to forget about machine code assembly, interrupts and processor caches. This makes Java a convenient language, but all too many developers see the JVM as a black box and are often unsure of how to optimize their code for performance. This unfortunately adds credence to the myth that Java is always outperformed by native languages. In this talk we'll take a peek at the inner workings of the HotSpot Virtual Machine, its Just-In-Time Compiler and the interplay with a computer's hardware. From this, we will understand the more common optimizations that a virtual machine applies to be better equipped to improve and to reason about a Java program's performance, and how to correctly measure runtime!
Universally, estimating software stories and tasks is hated by developers and most normal people. Almost as universally agreed, the results obtained from forecasting using those estimates are dismal. This session begins by listing the top ten reasons why estimation is a flawed approach and then goes onto offer simple alternative techniques. The alternative techniques described are simple to implement and will perform better than traditional estimation (not a high bar), and often better than intuition alone.
By attending this session you will learn –
- The top ten reasons why current estimation fails
- The situations when estimation is irrelevant and misleading (#NoEstimates)
- The difference between forecasting and estimating
- How little data is needed to be better than intuition alone
- Simple forecasting approaches that don’t fail – Monte Carlo Forecasting
This talk is distillation of what makes microservices different from normal services. While this talk can serve as an introduction to microservices the real goal is to help tease out the key areas of what is a very broard topic.
There has been lots of buzz around Microservices over the last year, but there has often been a lack of clarity as to what Microservices are, or how to implement them well. I've been working to distill down the principles of Microservices to help ensure that we don't just end up repeating the mistakes we made during the last 20 years of service oriented architecture. I'll talk about what they are, the benefits and downsides, and the core principles to stick to do to them well.
But it's also one of the most complex. Why?
Hoplon proposes a different way to fuse them: by making them both different syntaxes for the same programming language, ClojureScript. In the Hoplon model, HTML elements are just functions and vice versa. Elements are created and composed functionally, and their states are coordinated with an abstract spreadsheet.
I'll explain Hoplon's core concepts and show, with code examples, how new degrees of concision and composition can be achieved using Hoplon.
It's not enough to simply model a domain as commands and events. A robust solution needs to deliver said commands and events (collectively, hereafter: messages) quickly and reliably. MessageRouter, a recently open-sourced tool developed at Quicken Loans, solves exactly this problem. Using CQRS as a backdrop, this talk will explore the use of actor-based concurrency (via F#'s built-in asynchronous programming features) to build the message-dispatching core of a real-world system. In addition to the purely technical aspects of MessageRouter, this session will also discuss solutions to some of the challenges faced in building polyglot enterprise software on the common-language runtime (i.e. Mono or .NET). While no prior exposure to CQRS or F# is assumed, attendees will benefit from having, at least, a basic working knowledge of the common-language runtime.
In just a few few weeks, we reduced by 94% the OutOfMemoryError crashes in the Square Register Android app. We built LeakCanary to automatically detect memory leaks and make it very easy to fix them. This talk will cover the principles as well as the underlying implementation details. We'll dig into a few interesting examples and lessons learned.
"Well I started out down a dirty road, Started out all alone, And the sun went down as I crossed the hill, And the town lit up, the world got still, I’m learning to fly, but I ain't got wings, Coming down is the hardest thing, Well the good ol' days may not return, And the rocks might melt and the sea may burn, Well some say life will beat you down, Break your heart, steal your crown, So I've started out for God knows where, I guess I'll know when I get there"
(Lyrics by Tom Petty & Jeff Lynne) Experiences from Getting our virtual keyboard (JustType.se) out to the market as perceived in mid flight. Including forming the team, running a failed Kickstarter campaign, marketing attempts, investor relations and so on.
Projects fail because they don’t test. Some fail because they test the wrong things. Others fail because they test too much. In this session, an enterprise consultant turned startup entrepreneur will share project case studies in testing atrocities and what can be learned from them. You’ll come away questioning your own testing. Check your dogma and let’s build better software.
To understand large legacy systems we need to look beyond the current structure of the code. We need to understand both how the system evolves and how the people building it collaborate. In this session you'll learn to mine social information such as communication paths, developer knowledge and hotspots from source code repositories. It's information you use to improve both the design and the people-side of your codebase.
We'll start by investigating well-known codebases like Roslyn and Scala to see the wealth of information these methods deliver. After that we look at tooling support and how these techniques improve your existing practices and workflows. Finally you'll get tips on crafting your own tools as well as guidelines for when you'd like to do that. This is a new approach to software development - come join the hunt for better code!
Traditionally browsers communicate via servers, but what if they could speak to each other? WebRTC is a small set of APIs that make peer to peer communication possible between browsers and mobile applications. Video, audio and data can flow from browser to browser, opening up a new set of possibilities for modern communications.
We'll take a look at what WebRTC gives you and, importantly, what it leaves out. We'll take a look at the hurdles involved in implementing WebRTC and speculate over more complicated use cases and examples.
C# 6.0 has a potpourri of new convenient language features. In this talk, we’ll not only have a look at how to use each of those, but we’ll also look under the covers by browsing the Roslyn source code. Ever thought compiler source code is frightening to look at? No worries, your tour guide is ready to show you the inner beauty of the C# compiler!
You’ve worked hard to define, develop and execute a performance test on a new application to determine its behavior under load. You have barrels full of numbers. What’s next? The answer is definitely NOT to generate and send a canned report from the testing tool! Results interpretation and reporting is where a performance tester earns their keep.
We’ll start by looking at results from actual projects and together puzzle out the essential message in each. This will be a highly interactive session where we’ll display a graph, provide a little context, and ask “what do you see here?” We’ll form hypotheses, draw tentative conclusions, and identify graphs that give us the best insight on system performance and bottlenecks. We’ll try to describe these analytic steps, and consider a CAVIAR approach for collecting and evaluating test results: Collecting, Aggregating, Visualizing, Interpreting, Analyzing, Reporting
Mobile app developers face a number of challenges when they build great app experiences User expectations are high, and continue to rise and constantly challenge performance, network requirements, response time etc. We have all experienced fallout or slow internet and how that affects the mobile experience in a negative direction. Couchbase Lite with Xamarin makes it easy for developers to build Offline first mobile experience that compensate for slow or broken connectivity and help give the best user experience even when connectivity is challenged. In this session you will learn how to use Cocuhbase Lite with Xamarin to build your own Offline first apps.
Let's look at the latest, most advanced and exciting things you can do with Android today. From developer tools, APIs, services, hardware features and more, this session should inspire you to build the next billion-dollar mobile startup
Spring Boot, the convention-over-configuration centric framework from the Spring team at Pivotal, marries Spring's flexibility with conventional, common sense defaults to make application development not just fly, but pleasant! Ideal for microservices and for all your distributed systems and devops needs. Join Spring Boot co-lead Dave Syer for a look at what Spring Boot is, why it's turning heads, why you should consider it for your next application (REST, web, batch, big-data, integration, whatever!) and how to get started.
There is a new category of technology that is emerging across the world, in which a system does complex work on behalf of its user. In these agentive systems, a low-level artificial intelligence acts as an agent on a user’s behalf to accomplish some task. It delivers on the promises of user-centered design more than ever before, but will require that designers and technologists think of them clearly and distinctly. It will require them to master new scenarios and new tools.
Come get ahead of this trend as Chris introduces it and tours the tech across 7 key examples.
An introductory talk to Go where we will discuss why Go's popularity is raising so fast.
Let’s face it, we all want to bring our applications and services to everyone. In the end we don’t care if they're using a platform like Android, iOS, OS X or Windows…
It’s about reaching every single potential customer that we possibly can. It’s about reaching people. But the reality is that it’s hard – it’s costly in terms of time, money and knowledge.
No matter if you’re a large company or a small startup – it’s challenging.
Join me as I show you our transformation with Office – and our journey to create a single developer platform for you. A developer platform where you can use what you already know and love, to bring your solutions to more than one billion users – cross-platform and cross-device.
Let’s break the traditional way of targeting platforms and developing solutions.
This session is intended for developers (we will get our hands dirty and code!).
We will describe why agile methods benefits from continuous delivery and how we have applied this in two very different real life cases (one large scale and one quite small).
The presentation have only partially been given before.
Model rocketry and high powered rocketry as a hobby for anyone. The thrill and joy, the many different challenges, the community and resources and how to get started.
Fabric, formerly Crashlytics, is well-known for its focus on SDK quality, and has been deployed on billions of devices. In this session, attendees will learn the skills to develop and distribute SDKs for Android. We’ll cover an overview of Fabric, deep dive into technical decisions we made, and present the learnings on developing an SDK for stability, testability, performance, overall footprint size, and, most importantly, exceptional ease of implementation. Over the course of the session, we'll uncover and explain many of the challenges we encountered when building SDKs at Twitter. Topics include device feature detection, supporting multiple application types (from Widgets to Services to Foreground GUI applications), API design, deploying artifacts, and coding patterns to support developer customization. We'll conclude with advanced topics, from less-known but very useful tricks to minimizing impact on application start-up time to reducing memory footprint and persistent CPU use.
Do you know how your application will react when you throw the kitchen sink at it? What about when you add the water and plumbing? ;Most developers don’t think to use application fuzzers as part of their tests and this leaves nice security gaps for amateurs and professionals to find.;In this session, you will learn what application fuzzers are, how to use them and examples of using these tools to find vulnerabilities in your code before you deploy to the wild.;This session is rated at 200-300 for an audience of developers and testers. Pre knowledge of security concepts if not required, however knowledge of web application development and general web principles will make this session more enjoyable and relevant for you.
At Jet.com, we've based our architecture around cloud-based event-driven microservices, and over the last several months, have schooled ourselves on what works and what doesn't. This session will walk you through the lessons we have learned on our way to developing our platform.
It's easy to build and deploy monoliths, but they become difficult to manage once an app gets large. Microservices are a trendy pattern, but are often more trouble than they're worth when an app is small. In this talk I'll go over how we built a large Node.js app as a monolith and gradually moved it to a microservice architecture.
Velocity is one of the most common metrics used-and one of the most commonly misused-on agile projects. Velocity is simply a measurement of speed in a given direction-the rate at which a team is delivering toward a product release. As with a vehicle en route to a particular destination, increasing the speed may appear to ensure a timely arrival. However, that assumption is dangerous because it ignores the risks with higher speeds. And while it’s easy to increase a vehicle’s speed, where exactly is the accelerator on a software team? Michael “Doc" Norton walks us through the Hawthorne Effect and Goodhart’s Law to explain why setting goals for velocity can actually hurt a project's chances. Take a look at what can negatively impact velocity, ways to stabilize fluctuating velocity, and methods to improve velocity without the risks. Leave with a toolkit of additional metrics that, coupled with velocity, give a better view of the project's overall health.
Live Coding systems encourage us to think extremely differently about programming languages. Live Coders not only run and modify our code live - we often perform with it live on stage in front of large crowds of people who really don't want the code to miss a beat.
In this code and demo-heavy talk we will take a deep technical dive into the internal ideas and innovations of Sonic Pi - a system designed specifically for live coding. We will explore Sonic Pi's novel temporal semantics which allow multiple concurrent threads to execute in synchronisation whilst still allowing live hot-swapping of code. For example, we will examine cue and sync, techniques which allow users to coordinate, manipulate and synchronise threads whilst they're still running.
Ultimately, we will uncover an exciting area of programming language research in an approachable and instructive manner all whilst making some sick beats and drops.
Sony recently launched LifeLog API for application developers. Applications can now access users’ lifestyle, fitness and health data, collected through smartphone sensors and connected SmartWear devices. In this talk we will show how to derive insights from user’s LifeLog data using machine learning. We will take a look at how the Sony Lifelog team use Spark to scale analytics to large number of users, and how we use it to create new features for Lifelog users.
Software developers love to argue over irrelevant details. We even have a term for it: bikeshedding. When you're building an API, there is tons of opportunity to bikeshed. Do you wrap your data in an object? What HTTP status codes should you use, and in what situations? How do you do pagination?
JSON API is a standard for writing APIs in JSON. Extracted from work done with Rails and Ember.js, JSON API gives you a foundation for making all of these kinds of decisions by creating a standardized format for your API. And when you follow a standard, you can use tools that also know the standard.
In this talk, Steve will show off JSON API, and how you can use it to help you implement your own APIs.
Every part of a business is producing data - from the invoices in accounting to log records on our servers. i would like to demonstrate on real life examples how you can use Elasticsearch and other tools to make use of that data, regardless of their "shape" or volume.;We will start with gathering but focus mostly on the analysis Elasticsearch can provide us, from the straightforward analytics (and their visualizations) to the more specialized tools that will enable us to find the "uncommonly common" - exceptions to established patterns.;All tools used are open source.
You use open source software every day, whether you realize it or not. OSS runs the world, and yet few people have ever contributed. Why? This talk will try to answer that question and give you the motivation and confidence to help out your favorite OSS projects or start one of your own. We'll talk about how to get started, what it takes to run a successful project, strategies for finding OSS development time, and the ultimate benefits to you and your career. Every software developer needs to be an OSS contributor, and I want to help you get there.
At some point as a developer, you'll consider writing a library. Maybe you've invented a cool new way to perform a specific task and want to share it with the world. Maybe you just can't quiet the itch to modularize your huge code-base. Or perhaps you simply want to reuse your code in an elegant way. Whatever the motivation, writing a library is tough work. You'll hit unpredictable, hard-to-solve roadblocks. You'll face questions about the build system, the publishing process, Android vs. Java compatibility, and more. ;In this talk, I'll show you the best practices to write libraries both in Java or C/C++. We'll discuss API design, CI techniques, and performance considerations to provide you with the right tools for the job.
Having constraints and guarantees about the way a program executes makes it much easier for developers to reason about concurrency.;It's a common belief that providing serializability, one of the strongest forms of consistency in transaction processing, is too expensive for general use.;We describe research that introduces new techniques for making conflicting serializable transactions faster, on both multi-core and distributed systems.
A magic ring that can push gestures to your smartphone, an egg tray that can tell you when you should have eaten all the eggs. There are many inventive ways to make sure you can be a part of the IoT wave. Unfortunately a good part of the devices end up in the trash can due to many reasons. Flaky, unusable and intrusive are terms that often describe these devices.
Are we trying to hard to put every device on the internet or is it the fallacy of the next big thing?
The world could sure use some enhancement, but that doesn't mean that every device in our home should be on the internet. Some of the most pushed devices are activity tracking and home automation, but we need to go even further. We will venture through the devices that can help us, and not skip the entire security aspect. How can can we mix and match sensors to create new and awesome things...behold IoT is coming.
What are the underlying neurological and psychological principles of flow? I will talk about how neuroscience is linked to a successful recording session in a studio and how these same principles also apply to developing video-games and other knowledge-work.
Bluetooth® technology beacons are big news. 2014 was the year when many organizations ran initial pilot projects and 2015 is forecast to be the year of large beacon deployments to create major new services. In fact, ABI Research predicts we’ll see a 60 million unit market by 2019. That’s a whole lot of beacons.;This session will review fundamental beacon application concepts and issues facing developers in the real world. The AltBeacon beacon advertising data format will be introduced and we’ll explore how to develop an application for Android that works with AltBeacon. Finally, we’ll take a look at how boards such as the Intel Edison can be turned into a beacon for testing purposes.
The Android Sdk has changed much since its first version. Every new version comes with many new APIs. However, there is no perfect API, some do too much under the hood, others couple your classes to the context, others have more lifecycle events than you have years in your life.;The talk will show how to make your app scalable, your code clean, your performance optimized and your UI neat. The talk will show in a pragmatic way the pros and cons of using certain Android APIs, strategies and libraries. It will touch on Fragments, Loaders, AsyncTasks, OOP patterns (mvp vs mvvm vs viper) and styling.;This talk is a compendium of my experience in large code bases since I started to work in Android in 2009.
Time series data presents unique challenges when compared to other types of data. Write throughput is incredibly high while read throughput is even higher still. Deleting large ranges of data on a regular basis make updating indexes particularly hard.
In this talk I'll cover how the time series data use case differs from normal database use cases. I'll go into detail on the tradeoffs we made in InfluxDB to create a distributed system that is highly available and maximizes scale and throughput.
On the distributed side of things I'll cover how we handle consistency and coordination in the cluster. How we built a specialized MapReduce framework for time series data.
We find security vulnerabilities almost everywhere. Few developers build perfect systems, and dealing with security vulnerabilities is about managing risks. It’s becoming more important to deal with security in a structured way, as threats and attacks are on the rise. This session will introduce and discuss the "CWE/SANS Top 25 Most Dangerous Software Errors". You will learn how the Top 25 is structured, and how you can work with it in your development projects. You will see hack demos and examples of vulnerable products, and understand how such vulnerabilities can be avoided at an early stage in development.
George Box wrote, “all models are wrong, but some are useful".
Every software test is based on a model, because we can never test everything. We make choices about what to include in a test and what to leave out. Like a model of anything—an airplane, a housing development—a test model is a simplified reduction of the feature, system or business process we are testing.
The test model we employ embodies our strategic choices, and then serves as a conceptual construct within which we make tactical choices. This is true whether or not we are aware that we are employing models. Every test approach is a model—even if we base our test design on user stories. If we’re not consciously modeling, we may not be doing it well.
The presentation will look at how to use and combine common but powerful test modeling techniques. Using examples of visual test strategy models developed for customers, we’ll examine how to develop your own models and present them for stakeholder understanding and buy-in.
In this session I will walk you through how to build your own retro handheld console that is powered by Java, runs on a Raspberry Pi, and is printed on a 3D printer. Some of the topics that we will cover along the journey include:
• Hacking Java on the Raspberry Pi
• Rigging input devices with Pi4J
• Insane performance tuning on the JVM
• Why your boss [or SO] needs to buy you a 3D printer!
And of course your retro gaming mettle will be put to the test, so make sure to dust off your old 8 and 16 bit consoles to prepare.
This presentation is about the most fun you can have while still legitimately calling this conference “work.” In fact, I will hopefully inspire you to do your own creative “work” leveraging Java and Raspberry Pi to hack the real world.
BDD uses examples in conversation to illustrate behaviour, allowing development teams to explore, specify, and test that they're writing software that matters. Most Agile developers are familiar with its scenarios and "Given, When, Then" template... but how easy is it to get started?
In this beginners' session, we look at the language of examples. We'll look at easy ways to get the first scenarios out of business people, what questions to ask, and how we can improve our scenarios, independently of automation, to get a better understanding of what the software should do... or should it?
We will give a tour of functional and relational interpreters in
Scheme and the logic-programming language miniKanren. We will begin with a traditional interpreter for a Scheme-like language in Scheme, and will ultimately develop an interpreter for the same language in miniKanren. The latter will run forward for values, backward for expressions, and will synthesize programs that are difficult to believe.
We begin by taking a historical trip through what we know about cognitive psychology and software development - the mechanisms which allow our brains to manipulate such an intangible and complex domain. We consider the rich mental imagery reported by expert software designers and the creative process itself - particular how we can encourage the incubation of new ideas. We discuss the specialist mind and the unusually large proportion of autism in software development. What do we know about high-functioning autism? How do our practices and workspaces already help? How could they still be improved? What are sensory processing issues? How can we provide kinder workspaces that cater for the different kinds of mind we so dearly need?
The idea of self-driving cars is no longer science fiction. They already exist and are being trialled in many parts of the world with significant investment from the automotive industry and large technology companies such as Google, Apple and Uber. Within the next decade we will have commercially available self-driving cars. We will be able to sleep, read books, play games or work while journeying from A to B – the impact on personal time and work-life balance will be huge.
This keynote will provide delegates with a realistic view of how far advanced autonomous vehicles actually are and how they will very soon impact the way in which we travel and live. Of course there are some challenges which will be discussed, however these will be overcome and it won’t be too long before we own our own driver-less cars; our own piece of the future parked on our driveways.
Designing and consuming web APIs is simple, but hypermedia-rich REST APIs can be daunting. Hypermedia breaks the client-server coupling, allowing clients to adapt and react to instructions from a REST API. This is where most developers abandon hypermedia, when the effort of building client consumers becomes apparent.
However, the React.js immutable and component-based design are perfect for the interaction model of REST and hypermedia. In this session, we'll look at end-to-end REST, from building out a server API serving hypermedia-rich responses to clients in the browser consuming the API to build truly reactive clients. We'll end bringing the power of React Native's approach to native mobile development to the flexibility of hypermedia APIs.
RxJava is a powerful library for creating and composing streams of data. It can quickly be used to great effect, but a deeper understand of its internals will prevent running into pitfalls later on.
This talk will focus on the core mechanism of how streams are created and observed: subscribers and subscriptions. We will start with an introduction to the contract of the Subscriber type and how it is used by sources to create streams. Then we will touch on operators and how they use subscribers to modify the data flowing through streams. Finally we'll look at how threading behaves in operators like subscribeOn and observeOn.
Only a very basic level of RxJava knowledge is required for this talk. It will be assumed that you have used or at least seen the basics of RxJava's API before.
Every team, team leader, and team member needs specific collaboration skills for learning as a group, sharing knowledge, and developing “co-intelligence.” Learning together is essential to coordinating shared work. Based on the leanpub.com book, “QuickStart Guide to Five Rule for Accelerated Learning” by Willem Larsen and Diana Larsen, this session will show you how to set conditions for effective, fast team learning about customer needs, product qualities, work process, teamwork, and every kind of learning that enables great results the team, and the organization, can feel proud to deliver.
Learn about GraphQL, what it is, why it's interesting and how to employ it.
Songkick, a London-based Startup, helps music fans find out when their favourite artists are coming to town and get tickets.
In 2011 it became apparent that our release process, although very effective at managing release risk, was too heavy handed for our rapidly growing development team. Constant struggles with our single codebase and test process motivated us to radically change our approach and adopt Continuous Deployment.
In this talk I'll explain what we changed and why. I'll show you how your core principles can be used to drive process change and how we removed many of the delays and frustrations from our release process. Now, several years later we continue to release multiple times a day whilst maintaining a quality product for our users.
Enterprise Services Planning (ESP) is the new future of management for professional services businesses. Your business is an ecosystem of complex interdependent services. The new strategy for surviving in the fast moving, rapidly changing 21st Century is to create a business that this continually "fit for purpose" by installing an organizational capability for evolutionary change and adaptation. ESP enables this new strategy by helping you evolve your network of services and make them fit for purpose one at a time. ESP practices help you with Portfolio Management concerns: schedule and sequence work; forecast delivery dates and expected outcomes; allocate capacity; manage dependencies; understand and manage risk; ensure sufficient liquidity to react to unfolding events.
Apache Camel is one of the most complete integration frameworks out there. With more than 150 components and a large community it clearly has it's fans. Deploying the lightweight core is easy. Getting into modules and even more components makes this challenging. There are different approaches to ride that Camel. How to get the most out of it with Java EE and WildFly is exactly the topic of this session. It will introduce you to both Java EE 7 and Apache Camel in a very brief way and follows up with the different integration and deployment scenarios along with introducing the tools which help you the most on the way to your integration solution.
This talk is an ode to all the failed projects, bad code, and other crazy things that software engineers, managers, and coworkers do. Have you been on a project death march, or a project you knew was a train wreck? Or perhaps you've seen code that defies all logic? Whether it's ruining the integrity of a database, or eating up all the available memory on a machine, every day we see engineers making bad choices, and causing projects to fail. In this session, we'll review 20 years of fails in the industry witnessed by the speaker. You won't be left hanging though, as we'll discuss what you can do instead to ensure the success of your projects.
As our industry matures there is an increasing demand for high-throughput, low-latency systems heavily utilizing event-driven programming and asynchronous processing. This trend is rapidly converging on the somewhat well established but so-far not well understood term "Reactive".
This session explores how Java EE as a whole aligns with this movement via features and APIs like JMS, MDB, EJB @Asynchronous, JAX-RS/Servlet/WebSocket async, CDI events, Java EE concurrency utilities and so on.
We will also see how these robust facilities can be made digestible even in the most complex cases for mere mortal developers through Java SE 8 Lambdas and Completable Futures.
Microservices give us many options. We can pick different technologies, mix synchronous and asynchronous integration techniques or embrace different deployment patterns. But they also give us different options in how we think about securing our systems.
Done right, and microservices can increase the security of your vital data and processes. Done wrong, and you can increase the surface area of attack. This talk will discuss the importance of defence in depth, discussing the many different ways in which you can secure your fine-grained, distributed architectures.
The modern computing landscape is choc full of languages, each with novel features or suited to solving particular problems. However, to truly unlock the power of modern hardware -- and modern culture -- developers must start *socializing* the code written in these languages. But getting disparate tribes to talk to one another is no easy feat! Fortunately, this example-driven talk will show how ZeroMQ (a light-weight and powerful communications library) can connect many diverse languages, platforms, and cultures. Particular emphasis will be placed on the cross-cutting patterns which facilitate robust and complex solutions regardless of programming language. ZeroMQ will be shown as conductor, conspirator, and compatriot. In the end, we'll see 7 languages, across 2 platforms, connected via 1 fantastic technology.
In this talk, we'll explore how to build and architect enterprise systems using NoSQL, in particular, using the RavenDB Document Database.
Oren Eini, founder of RavenDB, will talk about modeling concerns, high availability and scale out, how to manage a system with polyglot persistence, complex domain and a high rate of change while maintaining speedy development rate and keeping the ops team happy.
Rust as a language is uniquely poised as being great at concurrency. There are many languages which are focused on this topic, but Rust takes a different approach. Most languages deal with the evils of shared mutable state by controlling the 'mutable' part. Rust instead tackles the 'shared' part. In this talk, Steve will show you the hows and whys of concurrent Rust.
If you can answer “Yes” to any of these questions this session is for you!
Do you have bad meetings?
Do you feel like a hamster in the developer wheel?
Do you want to have more fun at work?
Do you feel frustrated with how people communicate in your organisation?
Do you have a longing for great relationships?
Are you ready to enter something new and different?
YES! Great things are happening in coaching! Come join us to experience the power of Co-Activity and explore how it can serve you and your organisation.
We will share a couple of Co-Active coaching skills to instantly impact the way you communicate, build relations and live your dream today.
Accessibility is a quality outcome of a good design and development practice. However, accessibility is commonly overlooked on product teams, or is considered a secondary or tertiary concern to be addressed at the end of product development. It can be difficult to get product teams to integrate accessibility into process and practice. Security and privacy are widely held as crucial to software and online services, in part due to their accompanying legal obligations. Can accessibility, with its legal imperatives, provide a driver for closer attention to designing quality user experiences, based on a solid development practices?
Trying to scale agile? A company culture that supports agile is the key to create a sustainable, scalable environment.
Many successful companies have a strong company culture built on strong values. Even though the values of Spotify, Apple and Qlik are not fundamentally different from that of other companies, acting on these values contributes to their success.
Join this session to hear about how Qlik, an international company with over 2000 employees has created a culture that has helped the company through extreme growth and many challenges.
This talk will focus on how R&D live the culture and put core values to work. Find out how Qlik does Qlik Academy, Appreciation and Guilds. These are stories of a culture that creates alignment and shared vision. A culture that fits in perfectly with the values of agile.
You will leave with an understanding why a strong culture matters and how values can build a culture that creates market leading software in an agile working environment.
Data science and machine learning are rapidly growing fields that focus on extracting insights from data. But what actually hides behind the buzz words? In this talk I'll use data science tools in F# to analyze some publicly available online data. You'll see how F# simplifies data processing tasks and seamlessly integrates different steps of the analysis. I'll also explain cool ideas behind some machine learning algorithms, such as deep neural networks. You'll see how easy it is to dive into data with the right tools and how to extract interesting information yourself.
Microservices? A thing? Or hype? What does it mean in practice? The answer, like so many Facebook statuses, is complicated. In broad strokes, microservice offer a refreshed approach to application architecture. Microservices are a new way to describe many of the patterns that have fallen out of large-scale applications in practice over the recent years. There is no doubt that the approach works. The question is: how does one build a microservice architecture? Join Dave Syer for this session introducing Spring's support for building microservice architectures, including both Spring Boot, and the new Spring Cloud project incorporating Neflix OSS.
The past years building for the web has become more and more complicated, while our in-browser DevTools slowly have been turned into small editors by the browser vendors, but what has happen to our development workflow? It's time to rethink web development workflow and our tooling.
When Stephen Bourne released the his shell in 1977, shell scripting was born and he turned every UNIX user into a developer.
The UNIX shell can be used interactively, but the real power is when the shell is used as a programming language. Modern shells like bash can be seen as a general-purpose language but the syntax and semantics can be awkward at times. Moreover, with UNIX a broad range of small utilities follows (cut, sed, tr, etc.). These utilities together with the programming constructs of the shell, enables the user to automate any tasks and thereby become a more productive user.
This talk will go through how to use the command-line/terminal/shell efficiently (key bindings, pipes, redirection, etc.), and general patterns and pitfall in shell scripting will be discussed (checking if a file exists, looping, etc.). To feel the real power of OS X, knowing how to write shell scripts is essential.
Java agents are pluggable self contained components that run embedded in a JVM and intercept the classloading process. They were introduced in Java 5 along with the powerful java.lang.instrument package. Java agents can be loaded statically at startup or dynamically (programmatically) at runtime to attach to a running process in a fail-safe fashion.
Java agents were an awesome addition to the JVM as it opened a lot of opportunities for tool designers and changed Java tooling landscape quite drastically. In conjunction with Java bytecode manipulation libraries it is now possible to do amazing things to Java classes: we can experiment with programming models, redefine classes at runtime, record execution flow, etc.
I’d like to give an overview of Java agents’ functionality along with the usage examples and real world experiences. You will learn, how to implement an agent and apply Instrumentation API in combination with bytecode manipulation libraries to solve interesting tasks.
Motion design has become a necessary skill for designing and building the modern web. The character and energy that motion brings to an interface is becoming as expected on the web as it is in other mediums. Great web animation comes from thinking like a motion designer when putting our work in motion. Matching the motion we add to our message and design goals.
In this session we will cover key animation principles like timing, offsets, and secondary action as they apply to our interface design decisions. We’ll also cover motion principles specific to designing interactive animations. Consider this your crash course into becoming a motion design pro!
Mobile apps have revolutionized the mobile experience. Every day, new applications are released with innovative and new experiences for customers. Yet, in the rush to be first to market, these great ideas often suffer from a lack of attention to performance. Sometimes this lack of attention slows the application down, and customers complain about performance. Other times, the app succeeds in blowing their customer’s mind, but also blow through their battery and data plan.
We’ll look at several examples of real mobile applications that have suffered from performance issues. Some involve simple mistakes and were easy to resolve. Others are major architectural decisions that will hamper the application’s success going forward. We’ll attempt to dissect how and why the issues made it into production and postulate how the organization could resolve the issue, and prevent such issues from occurring again.
Come and learn how to write managed code that will be up for the toughest performance challenges. In this talk, we’ll study common and not-so-common performance pitfalls that managed code developers should be aware of when writing massive scale cloud applications using C# and .NET. Based on experiences from the trenches where we build large-scale services powering Bing and Cortana, this talk is packed with tips and tricks to measure and improve your code.
How does scale change development? After 10 years developing largely unsuccessful but glamorous sites, I’ve spent the last two helping develop a massively successful network, Stack Overflow.
In this talk, I'll show how our question lists work, starting from building an MVP, and showing how performance was iteratively optimized to the current implementation. Working at scale can teach us to build better software at any scale.
With WatchKit 2, developers can now write apps that run directly on the Apple Watch, independently of the iPhone. Learn how to create Watch apps and iOS apps that share code and resources, and communicate with each other in real time.
Today’s software development projects are typically iterative, fast moving and subject to change. As testers in these environments, we are continuously faced with an overwhelming amount of information and data to take in, analyze and process in order to determine what testing approach to take.When time is tight, the pressure
to make quick decision increases – how do we know that we are testing the right things, the right way, at the right time? How can we reduce decision-making time, without losing confidence in our decisions?
The presentation suggests a simple framework consisting of four fast steps to determine what test approach to take.
Assess: What does quality mean to us?
Align: How much documentation do we really need?
Advise: How should we test?
Accelerate: How can testing save time?
Focusing on reducing waste and increasing efficiencies, the framework allows testers to quickly make context-driven decisions. This session goes through the framework and how to apply it.
At its heart, much of Domain-Driven Design is all about object-oriented design. The challenge with elegant designs is that they all start out ugly. But our domain objects don't need to stay as anemic, data-centric property bags. With a small set of well-honed refactoring techniques, we can turn an ugly domain model into a wicked domain model, where our business objects respect boundaries, take our commands, and never, ever find themselves in a bad state.
Kodapor is the biggest, Swedish group for coders on Facebook  with over 8000 (not yet over 9000) members.
R has made the world of data analysis more approachable and has become an important tool for computational statistics and data visualization. With Microsoft acquiring Revolution Analytics it's also now a part of the Azure family.
Talk will demonstrate how you can use R to turn application data into business insights and actionable statistics. Using a year worth of Github commits, Barbara will ask questions such as which languages have had interesting trends and who the influencers are. The records reveals interesting conclusions about future trends and why particular repositories are more popular than others.
By developing intuition about the data sets and investigating them with more formal statistical methods, data can shape businesses to be more profitable. At the end, attendees will understand the power of the R language and how they can apply the same approaches for their own application allowing them to turn unstructured data into information that could be potentially monetised.
In this second talk on agentive technology, Noessel dives deep into two examples that help illustrates a model of interaction that details the differences in this new approach to interaction. The first example is Schwabs’s Intelligent Portfolios. The second is Sweden’s own Narrative camera. If you were intrigued the the overview in the first talk, this is the place to come get more details that will help you begin to think, design, and develop this way.
Determining a data storage solution as your application scales can be the most difficult part of web development, and takes time away from developing application features. MongoDB, Redis, Postgres, Riak, Cassandra, NoSQL, MySQL, NewSQL — the options are overwhelming, and all claim to be elastic, fault-tolerant, durable, and give great performance for both reads and writes (preview: They don't).;In this talk I’ll discuss different storage solutions and explain how to think about your datastore from your application backwards, instead of from your data model forwards, and how almost any datastore can scale as long as you use it the right way.
Given a sufficiently strong type system, you can model your problem domain in such a way that invalid states become unrepresentable. This is one of the corner stones of encapsulation, but requires a lot of effort in mainstream object-oriented languages. In functional languages like F# and Haskell, on the other hand, this is possible using a purely declarative approach to types.;Once your types can guarantee that only valid states are representable, Property-Based Testing becomes a breeze.;In this talk, we'll look at using the powerful combination of F# types and properties to address an example problem.
How to take advantage of immutable data as a simplifying force to build performant applications in React.
Let’s forget theory for a moment, and concentrate on the real world test automation. I've interviewed over 60 testers and developers on my TestTalks podcast. In this presentation you will discover seven of the most common themes/best practices taken from my guests as well as my own automation experiences. Find out what it takes to succeed with automation awesomeness with actionable advice you can apply right away to your own test automation projects.
Today there are a host of data-centric challenges that need more than a single technology to solve. Data platforms step in, blending different technologies to solve a common goal. ;But to compose such platforms we need an understanding of the tradeoffs of each constituent part: their sweet spots, how they complement one another and what sacrifices they make in return.;This talk is really a grand tour of these evolutionary forces. We’ll cover a lot of ground, building up from disk formats right through to fully distributed, streaming and batch driven architectures. In the end we should see how these various pieces come together to form a pleasant and useful whole.
Go is a simple language: both its grammar its type systems are easy to explain and express. Both of these aspects have an influence on the tooling one can develop and this talk will concentrate on what information you can extract from a program without having any human reading the code at any point.
Android is the most popular operating system in the world and is used by billions of people! This presents unprecedented opportunity in emerging markets to make a positive impact on people's lives.
You will explore emerging use cases across such diverse sectors as agriculture, banking, activism, and healthcare. You will walk away with a deeper appreciation for the technical and social challenges you will encounter in these markets and practical mitigations to overcome them to make a difference.
How will you impact the next billion?
Over 10 billion devices which use Bluetooth were shipped in the technology’s first 10 years. But last year alone, a further 3 billion new Bluetooth devices materialised. Bluetooth is going through what has been described as “quiet revolution”, with massive and increasing levels of adoption driven by the release of the latest version of Bluetooth called “Bluetooth Smart”. Bluetooth Smart enables some exciting and very current technology trends such as IoT (Internet of Things), Wearable Technology, the Smart Home and Beacons.;In this session attendees will learn about the fundamental concepts and architecture of Bluetooth Smart and how to create apps which exploit it. There may even be a demo or two!
Databases are global, shared, mutable state. That’s the way it has been since the 1960s, and no amount of NoSQL has changed that. However, most self-respecting developers have got rid of mutable global variables in their code long ago. So why do we tolerate databases as they are?
A more promising model, used in some systems, is to think of a database as an always-growing collection of immutable facts. You can query it at some point in time — but that’s still old, imperative style thinking. A more fruitful approach is to take the streams of facts as they come in, and functionally process them in real-time.
This talk introduces Apache Samza, a distributed stream processing framework developed at LinkedIn. At first it looks like yet another tool for computing real-time analytics, but really it’s a surreptitious attempt to take the database architecture we know, and turn it inside out.
After this talk, you'll see the architecture of your own applications in a completely new light.
As an industry, our capability for delivering software increased significantly over the last ten years. We now have much better processes, tools and techniques, and we can produce a lot more software significantly easier and faster. But companies rarely get the benefits from this new capability, because the ecosystem around software teams hasn't improved at the same speed. This talk will focus on how to unlock all that potential, and turn the fact that your teams can deliver frequently into an engine that will help you outrun your competition. This is a talk for tech and business people.
After 15 years building web applications on the Microsoft stack, and several years working at Microsoft on ASP.NET and NuGet, I found myself using Node.js and React. Come hear how I survived the boldest change of my career and how you too can overcome the challenge of a platform change.
At first glance, writing concurrent programs in Java seems like a straight-forward task. But the devil is in the detail. Fortunately, these details are strictly regulated by the Java memory model which, roughly speaking, decides what values a program can observe for a field at any given time. Without respecting the memory model, a Java program might behave erratic and yield bugs that only occure on some hardware platforms. This presentation summarizes the guarantees that are given by Java's memory model and teaches how to properly use volatile and final fields or synchronized code blocks. Instead of discussing the model in terms of memory model formalisms, this presentation builds on easy-to follow Java code examples.
Docker has taken the world by storm and is rapidly becoming the de-facto way to deploy applications and services. With a new development and deployment approach it brings new challenges and best practices. ;During this talk Ben will discuss his experiences of working with Docker on a daily basis as a development platform and deploying it into production.;Ben discuss his experience with using Docker around areas such as:;- Development, Test and Build lifecycle;- Building and creating small, streamlined, containers;- Auto-discovery architecture;- Scaling production nodes;- Resource management;- Security concerns and considerations;At the end attendees will understand the advantages along with the potential issues of running Docker based on real world experience. This should enable them to identify how to migrate and build their own applications using a container based architecture.
An interactive and fun demonstration of memory and mental phenomenas that hopefully makes you question the boundaries of the human mind.
With unikernels, applications can be compiled into small operating systems that run as stand-alone virtual machines. In this talk I will give an introduction to unikernels, what they are and how we can use them. I will also show how we can write and deploy unikernel services with MirageOS and boot them on demand in milliseconds with Jitsu.
MirageOS is a unikernel operating system developed at OCaml Labs in the University of Cambridge. MirageOS consists of a set of libraries that provide operating system features, such as a TCP/IP stack, a file system and so on. An application written for MirageOS links to these libraries and thus, the compiler only includes the features the application needs. This results in very small unikernels that boot in fractions of a second, as well as a more secure system as unused code is not included.
Jitsu - or Just-in-Time Summoning of Unikernels - is a DNS server and toolstack for booting unikernel VMs on demand.
Writing software that has to deal with time is hard. In fact, it’s crazy hard. How is it that something so seemingly mundane and ubiquitous to the modern society can cause such grief and frustration when we try to get it clearly defined in code?
How can metrics be used safely in coaching Agile teams? The classic Goldratt quote 'Tell me how you will measure me and I will tell you how I'll behave' signals the danger of using metrics to manage or motivate employees. This session shows and suggests approaches to Agile metrics that avoid the common pitfalls and shows some practical dashboards and the resulting chaos or calm they caused. This talk will show actual dashboards and metrics from actual industry engagements. It will explain how to safely capture and display these and how to teach an organization to see and understand its data. Be warned though, the techniques shown go beyond burndowns charts and cumulative flow diagrams.
- The dangers of managing by metrics
- Balanced approach to metric dashboards (less is more, but too little is disastrous)
- Digital storytelling and patterns (examples of good and bad dashboards)
- Coaching advice and dashboards
- Visualizations of the edge – attention grabbing ideas for action
Docker hit the developer scene in a big way last year. It made it easy for developers to run their applications locally and easily share and deploy them. But it wasn't quite ready for prime-time. It wasn't easy to run n-tier applications locally, manage Docker across different geographical locations or cluster Docker for availability and performance.
Recent releases of Docker have introduced new capabilities and tools to help with these use cases. In this session we're going to look at these new capabilities including:
* Looking at Docker Compose for building n-tier Docker applications and managing application stacks.
* Introduce Docker Swarm which provides orchestration and clustering for Docker servers.
* See how to integrate Docker and service discovery tools.
By the end of the session, you'll have a good understanding of how to take your Docker implementation to the next level and make use of these new capabilities.
Virtualization, Cloud Deployments, and Cloud-Based Tools have challenged and changed performance testing practices. Today’s performance tester can summons tens of thousands of virtual users from the cloud in a few minutes at a cost far lower than the expensive on-premise installations of yesteryear.
Meanwhile, systems under test have changed more. Updated software stacks have increased the complexity of scripting and performance measurement, but the biggest changes are in the nature and quantities of resources powering the systems. Interpreting resource usage when resources are shared on a private virtualization platform is exceedingly difficult. Understanding resources when they live in a large public cloud is impossible.
In this session, we’ll discuss strategies for engaging with these new contexts, and performance testing them effectively. Please bring your experiences to share.
At Jet.com, we have a lot of data. A LOT of data. We needed a way to safely, quickly, and relevantly process and explore all our data. Using F# and an event-based microservices architecture, we're able to do all this and more. In this talk, we'll cover how we handle processing events from 300+ microservices in to our data warehouse in real time, so that we can optimally react to our customers' wants and needs.
Would you like to see mammoths roam the Siberian wilderness again, or risk running into an auroch on your evening stroll?
It is more than twenty years since the movie Jurassic Park first fascinated the whole world, and now scientists are trying to make the fiction reality. Researchers around the world are busy trying to bring back species using advanced genetic technology. The animals range from rhinos and pigeons to dinosaurs, and the reasons for bringing them back range from curiosity to fighting climate change.
We will soon be able to revive lost animals, but is it really a good idea?
Tim dug into research on Artificial Intelligence. He could not believe what he was reading. It hit him pretty quickly that what’s happening in the world of AI is not just an important topic, but by far THE most important topic for our future.
Let's the duo tell you about Kung Fury story!
- Making of a Kickstarter campaign, how did we do it, what happened and how would we have done it differently today?
- Story boarding, Planning shots (camera, equipment, lights, practical/digital effects)
- Making movies with your friends
- How to fix the budget for, in many ways, an untraditional movie project
- Making of the David Hasselhoff music video / Hackerman’s Hacking Tutorial
- Post production (Fido in Stockholm and why it is important to have a VFX-supervisor on set)
- The premiere weeks (Cannes, Umeå, USA)
- What's happening today
- Making mistakes is a good thing
- Q & A
“Hacking your home – reverse engineering wireless transmissions;The internet of things is built around sensors, without sensors we don’t know what goes on and we can’t tell our software to make rational choices based on the analytics of this data, but building our own sensors are not always practical or cost efficient when there are numerous of the shelf solution that could do the same thing if we could only access their data! This talk demonstrates how to reverse engineer standard sensor wireless protocols from weather stations, movement sensors and more to use for your own designs!”
Did you know that React and Node can be used to build good old-fashioned line of business applications? We'll look at how!
You see, we all grew up building web applications with server-side rendering. Then we were convinced that we should render in the browser--but that proved to be a maintenance nightmare for LOB applications. With React, Node, and Fluxible, we can build apps that initially render on the server and have the client take over from there. Best of all, we can do this by using a single programming model that you'll realize you already know.
Knowledge Work is best done with working together. Without true cross-discipline collaboration, the full value of an organization cannot be realized. But you can’t just mandate collaboration. Many organizations do more than just separate disciplines; they design systems, metrics, and rewards that practically make design, development, product, and operations natural enemies. “They don’t get it.”, you hear from all sides. In this talk, Doc will take a look at what motivates teams and organizations, how our systems produce the exact results we design them to produce, and how we can use simple (but not necessarily easy) techniques to counter years of “us versus them” conditioning.
Browsers have had native DOM elements since the dawn of time, and yet any time you talk to web developers about it, everyone complains about them. Key events are bananas. The <input> element is unpredictable and grumpy. Have you ever tried to fill in one of those credit card forms where you can’t figure out what format the phone number should be in? Yeah, that’s what we’re talking about. Forms? Forms are magic, and not in a good way. Web Components let you stand up to browsers and build your own DOM elements that work the way they should, and Polymer is a new library that makes it easier than ever to do this.
If you're a developer in a large organization, it can often seem like Ops thinks their job is to STOP you from actually getting work done. In places like this, words like "Agile", "DevOps" and "Innovation" are paid lip service to, while projects struggle through multi-year release cycles.
Is DevOps in a large company even possible? We'll examine some of the technical and cultural barriers to DevOps in large companies, how technologies like PaaS, microservices, and Docker fit in, and what you, as a developer, can do to change things.
Today, every smart device in your home has it's own app. That's fine if you have 2 or 3 but what if there are many more? If we believe in Moore's law at all, the number of smart devices is going to explode, not just in our homes, but in our work and in public spaces. Apps are fine for things you use everyday but what about things that you just once, like a poster, or a vending machine? We are trapped by apps as they are too much work for a simple 'walk up and use' scenario. We need an open standard, one based on the web to allow any device to have it's own web page. This talk will show how this standard is being built and we, as a community need to make it happen. It will also discuss how transformative this new standard will be as allowing any device to have it's own virtual notecard of information opens up entirely new product concepts.
The Square Register Android app has few crashes. Getting there requires a systematic approach: coding defensively, gathering information, measuring impact and improving architecture.;This talk presents our concrete steps towards lowering the crash rate, from the general philosophy to the tools we use, together with real crash examples.
Don't let you testing efforts fall behind. In this session I share insight gleaned from my TestTalks podcast interviews with some of the top thought leaders in the automation space (as well as my own personal experience) about some upcoming trends I believe all testers and developers need to be made aware of. Also discover what you need to know to stay employable in a changing dev/test world.
How do you remain agile when working on a large application? How do you keep feedback cycles short and ship features quickly? How do you adapt rapidly to changing requirements?
Somehow, you need to break the big application into smaller, more manageable chunks. Microservices are a growing trend for splitting up monolithic applications into independently deployable services. Although there are many good things about microservices, it's not all roses: keeping them reliable and consistently performant can take serious effort.
In this talk, we'll discuss a different approach to breaking down a big application into smaller chunks: stream processing. Many applications can be designed as a cascade of jobs that consume and produce real-time data streams. When you build applications this way, streams are not just an implementation detail — they become the interface from one team to another.
Cynefin is a framework for making sense of the world and its problems; for understanding where outcomes are predictable, where they might emerge in time, and where urgent action is required. In Cynefin's complex domain, problems defy analysis and cause and effect can't be correlated. We're used to the idea that we make discoveries as we progress... but how can we usefully plan for those discoveries? What can we do to reduce the risk of the biggest impacts? And where are they likely to happen?
In this talk, we look at thinking tools and philosophies which help us to navigate uncertainty, including Real Options, Deliberate Discovery, the Shallow Dive into Chaos, and the art of really good Experiment Design.
Designing an elegant interface and local APIs for developers to communicate with your Android app is crucial for building a platform for your product: in this talk, you’ll find out how to allow third party developers to seamlessly interact with your users’ local data and shortcut more expensive server operations. Topics will include creating and exporting your content provider, constructing a well defined Intent interface, use deep links, and bind services for programmatic communication. Ty will walk you through how to create a well-defined interface in your app – if that’s something you want to know, don’t miss it!
Custom Elements and Custom Attributes in Aurelia allow you to create your own HTML elements, all without the drudgery of dealing directly with Web Components. Join Ashley Grant (Core Team Member) as we explore how to work with them. You'll come to learn about how easy it is to create Aurelia Custom Elements and Attributes. You'll stay to see how just how powerful Custom Elements and Attributes can be. You'll leave basking in the glow of the awesomeness that is Aurelia Custom Elements and Attributes.
A five year journey from idea to reality and how to hack away 4.5yrs by ignoring conventional wisdom.
Getting certainty of your success
Verifying it's worth doing
Building your team
MVP isn't for me (everyone).
Essentially, I'm going to talk about why it took so long to get going. All the things that held me back. How I figured out what the problem really was and how consumer's wanted it solved (not the same things). Shortcuts to believing in yourself and simple strategies to convincing others to join you.
Web accessibility is concerned with ensuring people with disabilities can participate online in an equitable way. Creating content is key to participating, and for true inclusion, people with disabilities must be able to contribute as well as consume content. Often the tools we provide and design patterns we adopt to support content authoring have significant accessibility limitations that make them difficult or impossible for people with disabilities to use. In this talk, we’ll focus on some common design patterns that support user content creation, including online forms, discussion forums, and WYSIWYG text editors, and walk through how we can optimise their accessibility.
A significant part of the life of a developer is spent gluing other people’s code together rather than writing their own code . This is both a blessing and a curse. On the one hand, we use more robust, more flexible, and maybe even faster software. However, when the honeymoon stops and the library does not work as expected, the time spent debugging might exceed the time we would have spent had we written things ourselves. A major reason for this is that most developers only use libraries, yet don't read them. Reading and understanding other people's code is an important virtue every developer has to obtain. Could Dostoevsky be the author he was had he not read Pushkin? Can we reach for the skies if we don't understand how the giants we are standing on the shoulders of work?
Mortimer Adler, editor for Encyclopædia Britannica, outlined the rules of reading other people's work in his influential book "How to Read a Book". Reading code is different. It is neither as linear nor as polished as the edited version of a book. It seems more like a random walk rather than a guided journey. Can we do any better?
This talk proposes to do what Adler did for prose; outline the principles of reading other people's code, using React.js as an example. We will dive into the internals of this exciting user interface library by Facebook that has transformed how people are doing web applications over the last couple of years.
Logic programming is a technique applicable to solving a wide variety of tasks in an elegant fashion and makes an attractive addition to any programmer's toolbox. But what if logic programming isn't available in your favorite language? We will show how to implement a relational-programming DSL in about 50 lines. Along the way we will provide guidance for those in the audience who wish to roll their own.
Writing maintainable test automation code is today as important as being able to design good customer-facing systems, yet very few teams do it well. If you think that your test automation often costs too much, takes too long and does not give you the return on investment you expected, this is a talk for you. Hear about the five key design patterns that will make the pain go away and allow you to get the most out of your automated tests.
The battle between native and web rages on. The browsers are fighting hard to tear down the benefits that native developers have relied on since the inception of mobile platforms. Geolocation, sorted. Accelerometer, done. Performance, we'll come back to that. But one of the greatest draws for native developers has been push notifications, for the web, email alerts just don't cut it.
But now, new in browsers for 2015, is the Service Worker. Born out of the struggle to make the Appcache work for offline capable sites it has also brought the advent of push notifications to the web. Through building up an example application live we will see how to implement the Service Worker to not only serve up an app when we're offline but enhance the online experience with push notifications.
The battle may continue, but the web is definitely pushing back.
You've spent time and effort to build a website, and you must verify that it works correctly. But you might be tired of manually testing webpages, which is also an error prone process in itself. Have you ever asked yourself if there must be an easier way? There are! There are many ways! We have Coded UI tests in Visual Studio, and a 3rd party automation tool called WebDriver. In this session, you'll learn how to write a few lines of code that can replace all the manual Web UI testing that you've been doing. Save yourself and your testers time and money by automating the process. You'll learn how to write a UI test one time that will test again and again. We'll discuss how to automatically fill in forms, navigate, and do anything that the user might do, but automatically, with no user! UI automation tests are a great way to help ensure a higher quality of your software.
God views, highly coupled classes, untested activities... the Fragment lifecycle!!;I've been working in Android since 2008 and lately, as the platform matures, the apps codebase is getting bigger. In these big codebases there is legacy code all over the place. Working on that environment is hell, without applying the right strategies to refactor this smelly code. ;First you will learn the design principles, patterns and how to apply them on Android and the payoff.;Second, you will learn how you could apply these to legacy code. Testing will play a huge role in this second part.;The talk will be really pragmatic. The idea is to show a pattern and how to apply it to a real piece of code. ;The knowledge of principles and patterns and how to apply them on Android, will show the benefit on them.;Having a strong test suite is key for refactoring and improving your code. Testing takes a key role it gives you the ability to make changes faster without breaking existing features.
Security in applications is a never-ending story. Most of the knowledge about how to build secure applications is derived from knowledge and experience. And we've all done the same mistakes every Java EE developer does over and over again. But how to solve the real business requirements behind access and authorization with Java EE? Can I have a 15k rights matrix? Does that perform? How to secure the transport layer? How does session binding works? Can I implement 2-Factor-Authentication? And what about social integrations? This talk outlines the key capabilities of the Java EE platform and introduces the audience to additional frameworks and concepts which do help by implementing all kinds of security requirements in Java EE based applications.
Want to roll out a database active active over multiple datacenters? Want to be able to do rolling upgrades and software releases without downtime? How about scale to millions of durable writes a second with single digit millisecond response times.;These requirements really cut down your database choices, and any database you’re considering are probably heavily influenced by Amazon’s 2007 paper: Dynamo: Amazon’s Highly Available Key-value Store. ;In this talk we’ll go through the main parts of Dynamo and discuss them in the context of how Apache Cassandra has implemented them. We’ll cover:;+ Consistent hashing;+ Strategies for replication;+ Working out distributed state with Gossip;+ Recovering from failure with Hinted handoff and Anti-entropy repair;We’ll also talk about why picking a masterless architecture, and trading availability and partition tolerance for consistency really can lead to a linearly scalable database.
Java EE 7 is here and the horizons for Java EE 8 are emerging. In order to solidly kick start Java EE 8, the GlassFish team conducted a series of community surveys. This session shares the content, results and analysis of these surveys. We will also share the detailed progress of Java EE 8 technologies already underway. The goal is to foster interest, discussion and participation around Java EE 8.
Some of the items covered include HTTP 2, Server-Sent Events (SSE), JSON binding, JCache, CDI/EJB alignment, cloud, PaaS, multitenancy/SaaS, JMS 2.1, JAX-RS 2.1, CDI 2, security simplification, REST management/monitoring, an action-oriented Web framework and much, much more.
You are encouraged to bring your questions, comments and ideas. The time to get involved in shaping the future of Java EE is now!
Forms. Without them, the web would not be what it is today, but they are challenging from a markup and styling standpoint.
In this session, we will explore forms from top to bottom, examining how they work and how their components can be incorporated with other elements to maximize accessibility, improve semantics, and allow for more flexible styling. You’ll get to see the complete picture with forms, including
* new HTML5 field types;
* validation, error messages & formatting hints;
* how to mark up and style forms for the greatest flexibility in responsive designs; and
Stack Overflow is developed with a hands-on approach, where practical facts always trump theoretical concerns and this allows us to have a unique blend of techniques and approaches to coding.
In this talk you'll learn about Stack Overflow's usage of application architecture, coding abstractions, continuous deployment, methodology. I will give demos of our extensive performance monitoring infrastructure.
Smartphones have become essential to modern life. They keep us connected with our social groups and provide us with instant access to all of human knowledge. As app developers, we have the opportunity to gather a wealth of information about each user that can be used to customize the experience in our applications.
However, with this wealth of information also comes great responsibility. How are we protecting this data from prying eyes? Are we collecting too much data? Are we transmitting and storing this data safely? If our data was compromised, what is our mitigation plan?
in this talk we’ll discuss the critical security aspects of sensitive customer information, and how we can protect our (and our customers’) data. We’ll also explore ways to ensure that the applications you use are safely handling the data that you send for yourself, your app and your company.
There's a debate raging in the Agile world: should we estimate, or not? Lost in the noise are more important questions: When should we estimate, and why? When should we not estimate, and why not?
As with so many Agile questions, the answer to "should we estimate?" isn't a clear-cut "yes" or "no." Instead, the answer depends on what your team is capable of, what your organization needs, and how to best balance the two.
We'll take a deep look at how estimates work, why they work, and when and why to discard them. Along the way, we'll encounter surprising insights about the nature of Agile development and the teams that use it.
What makes a good software developer and how do we bring new people with the talents that we need into our industry?
In this presentation we will talk about the programming training that we are providing in a rural town in Pennsylvania, which has been hit by redundancies within the coal mines, the dominant industry in the area. Many people aren’t aware that software development is an option for them, but when a real opportunity is given, we have the chance to develop a diverse group of programmers that are forward-thinking, language-agnostic, and that are versatile in their approach. We will discuss the skills we have been teaching, techniques that we have used, the people involved, and the many lessons that we have learnt along the way.
If you think it’s important to give something back to the community, and you see the value of inspiring and teaching people from diverse backgrounds, then this talk will be of interest to you.
One of the problems we face in automated system testing is how to setup and manage the lifecycle of the included applications. Traditional virtualisation technologies can provide solutions to these problems, but at the price of heavy resources requirements and unacceptably long startup times. Docker on the other hand, with lower resource requirements and shorter application startup times, has seen a lot of interest lately for looking like a better fit for automated system testing. In this session, I’ll showcase some neat ways in which Docker can be used in this area and challenge the common assumption that the costs of automated system testing outweigh the benefits.
Some testers are always leaders. Others see a project challenge that demands positive action and step into a leadership void because somebody has to. You may never seek or be given a formal role as a test leader, and yet be a trusted leader in the minds of your co-workers and managers.
What is test leadership? What are the specific personal qualities and skills that distinguish a true leader in testing?
In this interactive workshop, we’ll share some experiences and attempt to answer those questions. Together, we’ll explore the characteristics of a test leader and learn how to begin developing a set of positive heuristics that can help us become more effective leaders in our daily work
This mini-workshop is for testers, test managers, test leads—anyone who is or wants to become a test leader.
Machine learning methods are being applied in many different areas – from analyzing financial stock markets to movie recommender engines. But the same methods can be applied to other areas that also deal with big messy data. In bioinformatics I use similar machine learning methods, only this time to help find the underlying mechanisms of cancer.
The problems in bioinformatics might seem opaque and confusing – sequencing, DNA, methylation, ChIP-seq, motifs etc. But underneath, the same algorithms that are used to find groups of customers based on their buying behavior can be used to find subtypes of cancer that respond differently to treatments. Algorithms for text analysis can be used to find important patterns in DNA strands. And software verification tools can help analyze biological systems.
In this talk, I’ll show you the exciting world of machine learning applications in bioinformatics. No knowledge of biology is required, the talk will be mostly in developer-speak.
Using Kotlin for Android development has grown in popularity over the last year. Even to those who are not currently using it, the value proposition of the language immediately resonates. There already are a lot of introductory talks to the language and its extensions for use on Android. This talk will cover advancing the usage and design patterns of the language for Android development to solve larger problems. While the content is targeted at mobile development, there will be value for all Java developers interested in Kotlin.
Prior knowledge or use of Kotlin is not required to attend this talk. Some concepts of the language will be used without introduction but they are intuitive and/or quickly learned. Even if you don't fully understand every language concept on which each example is built, the resulting functionality will be clear.
Java is one of the most popular programming languages in the world, but it wasn't always that way. Java had its early roots in embedded systems, a quirky avatar with no mouth, and a truly geeky name ("C++ ++ --"). Who would have imagined that Java would become the driving technological force behind the web, mobile devices, consumer electronics, and even putting an unmanned vehicle on Mars. In this presentation hear from the folks who participated in the Java revolution and lived to tell their tale - on video!
But why do you want to write extensions in C++? First, accessing low-level ressources and system calls can be a requirement, and second you might need the performance of a compiled language like C++. Third but not least, interfacing to legacy code (often written in C, C++ or even Fortran) is a necessity.
Service Workers are a new shiny for the web platform. They let you get offline experiences, background syncs and push notifications. By default, they do not let you get cats. We will fix that.
Animation often needs some space to move in, but with responsive design we know the space we have is ever-changing. Balancing those two factors can lead to some tricky design problems for web animation, especially when you throw performance and design concerns into the mix! In this session Val will break down examples and show you how to design animations that work well at all viewport sizes without driving yourself crazy.
We rarely consider our builds as an area worthy of our own engineering attention. Our needs are usually met by the vast array of complex but "standard" tools. To the pragmatic engineer their complexity is a warning: don't try this yourself, it's too hard!
What if it wasn't? What if the capabilities of computers and the affordances of modern languages invalidated the assumptions made by the "standard" tool authors a long time ago?
These are the questions we raise, and try to answer, with Boot: "build tooling" written in Clojure. Boot is an executable, a Clojure library, and a mental model that can be used to deconstruct, and solve programmatically, nearly any build scenario. Boot has abstractions for command-line DSLs, the filesystem, and the classpath that users can combine simply and on their own with small, concise Clojure programs.
I will explain Boot's central concepts and demonstrate its use in a variety of build situations involving at least Java, JRuby, and Clojure.
No longer does one-size-fit-all when it comes to data technology. At least not for many of today’s use cases. Will this ever change? Will we continue to diversify? Will we go full circle? Certainly ours is an industry in flux. NoSQL, Big Data and stream technology, containerisation, commodity PCIe storage, non-volatile memory and a host of other forces will shape the data technologies of the future. ;In this talk will make a case for what the future may look like, what challenges we’ll encounter and how it will likely change the applications we build.
Progressive enhancement sounds practical, but not for your current project, right? Good news: you’re wrong!
In this session, Aaron will debunk the myths that often preclude individuals and organizations from embracing progressive enhancement and demonstrate solid techniques for applying progressive enhancement in your work.
By the end of this session, you’ll walk away with
* a better sense of the devices people are using to access the Web,
* a framework for envisioning experience as a continuum, and
* a solid understanding of how to improve the accessibility and reach of your Web projects.
Come find out why progressive enhancement isn’t just for “content” sites (whatever those are).
In iOS 9, Apple has opened up its system search APIs to developers. Learn how to use these new APIs to make your application data searchable directly from the home screen.
So what do we mean by always on? Five 9s, ten 9s? This talk is about the hardest part of the stack to make available: the database.;Do you remember CAP theorem from University? How many AP systems have you built or used? Trading off consistency for being always on is a decision some companies have had to make (we can’t live without Netflix or Amazon can we?). ;Most of the talk will be about Apache Cassandra. However we'll first go through the general requirements of any database system when you want to remain online 24/7, this will help you to evaluate any database technology. ;What you’ll learn is if you want to build an AP systems with a database like Cassandra, we as developers need to get out of a relational mindset (no free lunch). We need to model our data differently and develop with fault tolerance in mind to handle things like: concurrent updates from multiple datacenters, hardware and network failure and throughputs in the millions of transactions a second.
Google recently introduced new documentation and guidelines on how to design beautiful user interfaces called Material Design. Unlike frameworks like Twitter Bootstrap or Foundation, these guidelines are comprehensive enough to ensure they meet multiple scenarios and ensure applications retain their own character and uniqueness.;In this talk, Ben will explore the guidelines and the different ways they can be implemented on both mobile and desktop. Based on his experience of working with the guidelines he will look at real-world examples of how they’ve been utilised correctly along the common mistakes and misunderstandings made. Ben will show research of how users engage with applications built around the guidelines and where improvements could potentially be made. ;At the end of the session, attendees will understand the different aspects of Material Design and how to apply them to their own applications to increase user happiness.
Most people consider themselves to be rational. Indeed, to tell someone that they are irrational is considered an insult. But, what does it mean to be rational? Are we really rational? Is it rational to believe that we are rational?
In this presentation I will make the case that we are not only irrational in some cases, but almost all the time. The human mind is much more effective when it is making decisions without thinking consciously!
"Facts are useful; they give the conscious mind something to do while the emotions decide what's true!" -- Dale Dauten
This presentation will give you a fresh view on how to make the most out of your brain.