Learn Android development from the ground up. We’ll start with the SDK and the Android Studio IDE and build, test, and deploy applications on both emulators and (if available) physical devices. Several examples will be provided that cover a range of topics from basic activities to the SQLite database to accessing RESTful web services.
Functional Design By Example
Maybe you have heard the name “functional programming” and you’re interested to learn what it is. Well there is no better way to learn a new paradigm than by actually seeing it implemented. In this workshop we’ll take a working code example and transform it into the functional paradigm all in Java 7. We’ll step through everything from higher-order functions, function purity and even to some levels of immutability. At the end, we’ll show how we can make use of Java 8’s lambdas by very simple changes to the code that we’ve already refactored.
At the end, you should be able to take the concepts that you learn from this workshop and start using them the next day at work!
Down and Dirty with Java EE 7
This is a hands-on workshop/extended lab to introduce the Java EE 7 platform.
The main theme of Java EE 7 is boosting productivity and embracing HTML 5. The changes include APIs like JAX-RS 2, JMS 2, Java Batch, Java EE Concurrency, WebSocket, JSON-P and JSF 2.2. The workshop will introduce these changes in a step-by-step fashion using a realistic end-to-end application deployed on GlassFish 4 using NetBeans.
Although the primary focus will be on the new APIs and features, we will take a holistic approach to the workshop and also cover the features introduced in Java EE 5 and Java EE 6 such as the ones in EJB 3, CDI, JPA, Bean Validation and JSF focused on annotations, intelligent defaults, type-safe, powerful, fluent APIs.
At the end of the workshop, you will have a broad introduction to Java EE 7 and will be ready to write your own applications having already written quite a bit of code in the workshop.
Spring XD: Big Data Integration's perfect solution is at your service.
Whether your project is big data or enterprise integration, Spring XD makes it easy to solve common big data integration problems such as data ingestion and export, real-time analytics, and batch workflow orchestration. In this workshop we will cover stream creation, batch job execution and high availability. You will learn how to create streams to capture live data from various sources (hdfs,tcp, no sql, RDBMS), filter and modify the data as well as capture counts then output this data to various sinks (hdfs,tcp, no sql, RDBMS). Also covered is how to create batch workflow solutions that span traditional use-cases such as moving data between flat files and relational databases as well as Hadoop use-cases.
The best news is that you don’t need to code anything up to get going, no build scripts, no IDE, no maven coordinates. If you are working on a big data, Spring Integration, Spring Batch project this workshop is for you. This is a hands-on workshop so bring your laptop!
Hacking Web Components and Polymer
Component-oriented UI development has been popular for over twenty years, with the introduction of Visual Basic. The promise is simple: packaged reusable code that makes powerful widgets like grids, toolbars, menus, smart input controls, panels, media players, charts, graphs, trees, image viewers, and so on, easy to integrate into applications.
Finally, there is: Web Components, an emerging standard from the Web Applications Working Group (WAWG). Web Components consists of five different standards: Templates, Decorators,
Since the standards are not fully supported in all browsers, you need a library to support them in non-compliant browsers. Google’s Polymer does just this, and more.
Come to this workshop to learn about these exciting new technologies hands-on.
Managing Your Manager
As developers, we deal with management all the time but aren’t normally interested in becoming managers ourselves. In fact, we take a perverse pride in being difficult to manage and being more interested in being right than doing what is politically expedient.
Unsurprisingly, this leads to difficulties when business crises arise, like reorganizations, layoffs, or simply new opportunities that we would like to pursue. It’s hard to get what you want when we’re viewed as part of the problem rather than the solution.
This talk is about understanding the world of your manager and how you can take simple steps to build a relationship that you can rely on when you need it.
JMS.Next(): JMS 2.0 and Beyond
JMS is the Java standard for accessing enterprise messaging systems. This session introduces JMS 2.0 (JSR 343), the first update in more than a decade and easily the longest-awaited component of the forthcoming Java EE 7 standard. The biggest new feature of JMS 2.0 is a new API that makes JMS much easier to use, especially in a Java EE application. JMS 2.0 also provides API features to support greater scalability as well as additional messaging features and a long list of minor enhancements and clarifications. With JMS 2.0 final with Java EE 7, now is an ideal time to find out more about it.
In this session, we will also discuss what might be next for the JMS specification.
ZombieTime - JSR 310 for the Undead
Surviving as a zombie is tough… with the constant risks of sunlight, fire, and pesky mobs, doing your job of infecting the local villagers can be deadly. Fortunately, with the new JavaFX ZombieTime app, powered by the JSR 310 Date and Time API, you can rest easy. With built-in time zone and DST support you no longer have to worry about roaming around under the scorching hot sun. Accurately calculate out how long you have to infect the villagers before you decompose using Durations. And coordinate global attacks on the humans by syncing with your undead brethren on Instants. With the power of Java 8, eradicating the human race with a highly infectious virus has never been easier!
This presentation is designed to teach Java Date and Time APIs to the undead, but the living are welcome to be our “guests”. You may also learn some JavaFX in the process – that is entirely my fault. Any correlation between the characters and events in this presentation and the impending extinction of mankind is purely coincidental.
Raspberry Pi with Java 8
This session is designed to help you use your Java programming skills to create hobby projects using the Raspberry Pi as an inexpensive (35 euros) interface to the physical world. We will teach the concepts by demonstrating examples with working projects and source code. Some of the topics we will cover include:
* Unboxing your Raspberry Pi and setting up Java
* Electrical circuit design for GPIO
* Using the Java 8 Device Access API
* Programming common I2C devices
* Device communication over HTTP, MQTT, and Web Sockets
* Creating visual and touch UIs
* 3D Printing custom hardware
Coming out of this session you will have the knowledge you need to start building your own embedded projects for your home or office, and can leverage your Java programming skills to connect it to the Internet of Things. Start building the future now with Java 8 Embedded technology!
Programming with Streams in Java 8
We all have heard about lambda expressions in Java 8. The real unsung hero of Java 8 are the Streams. In this presentation we will take an example driven approach to explore streams, their core capabilities form the application development point of view, and how to explore these capabilities for improve performance and efficiency.
Making Java Bearable with Guava (2015 Edition)
This 2015 presentation covers the Guava library developed by Google (http://code.google.com/p/guava-libraries/).
Guava provides collection extensions to the Java Collection API and, along with this, a cornucopia of time-saving
utilities that bring Java as close as possible to some of the more functional
and/or dynamic language competitors like Scala, Ruby, and Clojure. Why a brand spanking new 2015 version of this presentation? Well, there more new stuff to learn and use!
This presentation covers briefly on functions, predicates and how they interact with Java 8. It covers how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets, immutable collections, handling Futures with callbacks and shutdowns, caches, and then we will dwell on tons of the newer features that came with Releases 16, 17, and 18.
Java Persistence API
Still not sure about JPA? Or maybe you’ve been using it for a while already. Refreshers are always good to have! We’re all at different skill levels, but this presentation looks to have something for everyone.
Why shouldn’t I always use a List for a collection? Should I use a ManyToMany or a OneToMany? How should I do this dynamic query with the Criteria API? Learn some tips and tricks from the Expert Group Members, implementers and power users. We’ll cover some advanced use cases, some gotchas, and some solutions for success.
Building "Bootiful" Applications with Spring Boot
Alright, so maybe “bootiful” won’t ever work, but I tried, and it was worth it too because you’re reading this. Spring Boot, the new 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! Join Spring developer advocate Josh Long @starbuxman 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.
AAHH! There's a leak in my App!
So you know that Java is a Managed language and us, as Java developers don’t worry about mundane things like memory allocation (PFFFT!), and sometimes we get into a sense of the secure, letting the super incredible JVM take care of everything for us. But alas, with complacency we can get in trouble. Memory leaks are real (–Insert horror scream here–), and we must understand how these happen!
In this session we will go into how the JVM allocates and keeps “things around”, and then how memory leaks are inadvertently created. Not just that, but we will also deep dive in how to find and fix these leaks by using Free tools like VisualVM. We will walk through Strong/Weak and Phantom references and review unintended leaks (like using anonymous inner classes that have strong references). If you program in the J2SE space, or if your are an Android app developer, or even a Java EE who has to do a lot of Session and/or Batch processing this session is for you!
The title is a reference to Cloudy with a Chance of Meatballs 2 (https://www.youtube.com/watch?v=4c1dqJPsSa4)
Life Without Domain Objects: An Experience Report
What does a Java code base look like when you have no domain objects? A project I worked on for over a year did just that - not a single domain object. Why did we choose this route? What problems did we face? What tools and patterns did we follow to maintain and write good code? In this talk I’ll discuss the decisions we made, some of the lessons learned and the successes we had while using this approach.
Gimme Caching, the Hazelcast JCache Way
Hey lads, lemme tell ya a story.
Once upon a time, we’re talking about the year 2001, a few people had an amazing idea. They were thinking about something that would change the world. It would make the world easy and give programmers almost unlimited power! It was simply referred to as JSR 107, one of the least things to change in the upcoming future. But those pals were way ahead of their time and nothing really happend. So time passed by and by and by and over the years it was buried in the deep catacombs of the JCP. Eventually, in 2011, two brave knights took on the fight and worked themselves through all the pathlessness, to finalize it in 2014. Lads you know what I’m talking about, they called it the “Java Caching API” or in short “JCache”. Yes you heard me, a Java standard for Caching!
A software system cannot possibly imagined without Caching today and it was time for a standard. No matter if you want to cache database queries, generated HTML or results of long running calculations, new systems have to reach a critical mass to be successful. Therefore caching becomes a First-Class-Citizen of application landscape, the principle of Caching First. JCache has grown for 13 years to it’s final success and had an amazing Co-Spec-Lead, Greg Luck - the inventor of EHcache.
Functional Programming—Technical Reasons to Adapt
Functional programming is receiving much attention recently. Most mainstream languages, including C++, Java, and C# now support lambda expressions and functional style. Why is there a sudden interest in adapting something that was largely ignored for decades? What are the technical reasons, how do we benefit, in what ways can using these techniques make our applications better and our development efforts easier as well? In this technical presentation we will learn about the technical underpinnings of functional programming, the fundamental problems they address, and the large impact of those on application development.
A Gentle Introduction to Reactive Extensions
Programming with Lambda Expressions in Java
Programming with Lambda Expressions in Java
Now that Java is supporting lambda expressions, it’s time to hone our skills to make use of them. Lambda expressions can help create concise code, however, it takes more than learning the syntax to put them to good use. In this presentation we will learn the idiomatic use of lambda expressions, explore the ways in which we can use them to solve common tasks, and look into libraries and APIs that make use of them in Java.
Refactoring to Functional
How many times have been told how functional programming is so much better than imperative, and then being presented with a functional approach to calculating a fibonacci sequence, leaving you wondering how that can be even remotely useful when working in real world applications? Yep, we’ve all been there. It seems that every time someone wants to explain functional programming to us, it’s around how to solve some mathematical problem. But how does that provide us value? How do we deal with things like grouping functionality, loose coupling or dependency injection?
Join this journey where we’ll look at code we usually write when developing business applications and how to refactor this using functional paradigms, and more importantly, see if these provide us with any value.
Design Patterns in the light of Lambdas
Design patterns are common place in OO programming. With the introduction of lambda expressions in languages like Java, one has to wonder about their influence on design patterns. In this presentation we will take up some of the common design patterns and rework them using lambda expressions. We will also explore some other patterns that are not so common, but are quite useful ways to apply lambdas.
Learning 5 JVM Languages in the Next 5 Years
Take control of your knowledge portfolio and be in demand! Your command of the top JVM languages; Java 8, Groovy, Scala, JRuby, and Clojure; will set you apart from the rest. This presentation will introduce each of these languages, highlight common ground, and show some stark differences.
This presentation will cover:
* How to install each of the JVM languages
* Describe the “functionality” of each of the languages
* Expressiveness vs. Terseness of each language
* How each language handles mutability
* How each language handles concurrency
* Amazing tricks of each language
* Comparison of language typing
* Comparison and contrast of language performance
* Each language’s killer app
* Analysis of the language culture and where to get help?
* Tips on how to start learning and keep learning with a busy schedule
Groovy - getting started and practical in hours
Love and know Java? Feel that it’s sometimes gets in your way? A bit of too much boilerplate? Too much effort required to get some work done? Groovy is here to help! You’re gonna love it, we promise. Feeling at home while being more productive, what else can you ask for? We’re going to cover the basics, the syntax differences between Java and Groovy, the data types, the object orientation, the Groovy truth and, of course, closures and the functional aspects of Groovy. We’ll also review some of the advanced features, like compile time and runtime metaprogramming, builders and slurplers and more, as time allows.
Spring Integration Java DSL - A Deep Dive
Spring Integration is becoming an increasingly popular integration framework within the enterprise; it was recently recognized as the most popular such framework (even outscoring other integration solutions such as ESBs) in a recent DZone survey of integration solutions.
The most recent addition to the framework is a fluent Java DSL.
The Spring Integration Java DSL provides a set of convenient Builders and a fluent API to configure Spring Integration message flows from Spring @Configuration classes. The Java DSL for Spring Integration is essentially a facade for Spring Integration. The DSL provides a simple way to embed Spring Integration Message Flows into your application using the fluent Builder pattern together with existing Java and Annotation configurations from Spring Framework and Spring Integration as well. While not requiring Java 8, the use of Java 8 Lambda expressions in the DSL makes for even more succinct configuration.
This session takes a deep dive into using the DSL to define a reasonably complex integration application. While concentrating on the use of Java 8 Lambda expressions we will also cover pre java 8 constructs for those users not yet ready to make the move.
What is new in Spring Integration 4?
Releases 3 and 4 of Spring Integration have brought a whole slew of new features, ranging from components to configuration options, all tailored to increase the power of the framework and its ease of use.
The most significant enhancement being, of course, the ability of writing completely XML-free enterprise integration applications, using Spring Integration, and Spring Boot, a significant amount of time will be dedicated to that, and you will see a few demos that illustrate the power of the new facilities.
But certainly, the new additions amount to more than that, and you are welcome to learn about it all!
Creating Our Robot Overlords: Autonomous Drone Development with Java and the Internet of Things
Who wants a mindless drone? Teach it to think, and it can do so much more. But how do you take it from Toy Story to Terminator? This session’s speaker discusses a new open source library, Autonomous4j, for autonomous drone development. Combining this library and some components from his mad science toolkit, he demonstrates how to get your Internet of Things off the ground and do some real cloud computing. In the session, you’ll learn how to write an autonomous drone program with Java 8; deploy it to the drone’s positronic brain, an onboard Raspberry Pi; have the Pi guide an AR.Drone to accomplish a task; monitor it via a JavaFX console; and create your own robot overlord. Demos are included: you’ve been warned! This presentation will feature an AR Drone flying autonomously
Continuous Delivery with JBoss Fuse and OpenShift PaaS
Struggling to deploy your integration middleware/services?
In this talk, we’ll get a deep dive on improving your time to production so your business can delivery value quicker using powerful integration and cloud technology.
Come see how JBoss Fuse (an opensource ESB based on Apache Camel and ActiveMQ) can be used to integrate applications on premise or in the cloud combined with a automated continuous delivery model based on Jenkins and OpenShift.
Introduction to ElasticSearch
ElasticSearch is an open source search and analytics engine that is easy to configure and deploy. This talk will explore some of the differentiating and compelling features that Elasticsearch offers, as it becomes the defacto full-text provider for the enterprise. Deploying Elasticsearch is a trivial endeavor, but knowing how to configure your cluster initially for optimal performance, is an art. In this presentation, I will share much of what I’ve learned in deploying and scaling-out massive Elasticsearch clusters that were designed from the ground up, optimized for performance with a specific use in mind. Some of the topics covered will focus on optimizing clusters, organizing and retrieving data, disaster recovery, and avoiding failure and performance degradation in a running cluster. Common and not-so-common deployment scenarios will also be investigated, such as: Log aggregation, Full-Text search, and its use in a CQRS architecture.
IoT Realized - The Connected Car
For this session we will explore the power of Spring XD in the context of the Internet of Things (IoT). We will look at a solution developed with Spring XD to stream real time analytics from a moving car using open standards. Ingestion of the real time data (location, speed, engine diagnostics, etc), analyzing it to provide highly accurate MPG and vehicle range prediction, as well as providing real time dashboards will all be covered. Coming out of this session, you’ll understand how Spring XD can serve as “Legos®” for the IoT.
Spring Data REST - Data Meets Hypermedia
Spring Data REST bridges the gap between the convenient data access layers provided by Spring Data’s repository abstraction and hypermedia-driven REST web services. This removes all that boilerplate needed during implementation. This talk will give a quick overview of the project, explain fundamental design decisions and introduce new features of the latest version (namely service documentation, discoverability and integration with Spring Security).
We will then look at the Spring-A-Gram sample application (built using Spring Data REST) with the following rich front ends:
HTTP 2.0 comes to Java. What Servlet 4.0 means to you.
It’s hard to overstate how much has changed in the world since HTTP 1.1 went final in June of 1999. There were no smartphones, Google had not yet IPO’d, Java Swing was less than a year old… you get the idea. Yet for all that change, HTTP remains at version 1.1.
Change is finally coming. HTTP 2.0 should be complete by 2015, and with that comes the need for a new version of Servlet. It will embrace HTTP 2.0 and expose its key features to Java EE 8 applications. This session gives a peek into the progress of the Servlet spec and shares some ideas about how developers can take advantage of this exciting
update to the world’s most successful application protocol on the world’s most popular programming language.
Vaadin and Web Components
The upcoming web components standard promises encapsulation and isolation between web UI components so that they can be reused. The standard is built on shadow DOM, customer HTML elements, HTML import and CSS sandboxing. While each of these is interesting by its own right, the combination of these tools has a potential to simplify web platform and empower developers building larger applications.
The value proposition is really close to that of component based frameworks like Vaadin: Make building good quality user interfaces easy with a powerful encapsulation. Are Java frameworks on a crash course with web components or could they complement each other?
In this session we will demo what Vaadin team has been building on top of web components standards for a while. Differences between and vision for convergence of web development and Java is discussed.
Spring 4 Web Applications
Spring MVC is among the most active areas of the Spring Framework with plenty of community-driven features and refinements. The 4.x generation (including 4.0, 4.1 and the upcoming 4.2) are no exception. This talk provides an overview of the areas in which the framework has and continues to evolve.
Microservices with Spring Cloud
Do you want to build an application using microservices and don’t know where to start? How do services find each other? How do I configure many instances of each service? How do I see what’s going on with my services?
If you’ve ever asked any of these questions, this session will give you some answers using Spring Cloud and Netflix OSS to create microservices that are robust, discoverable, scalable and configurable.
Learn basic concepts about Spring Cloud and Netflix OSS and how they are integrated. See demos of and learn how to use the following:
Think Small To Go Big - An Introduction To Microservices
Monolithic applications may be the norm on-premise but in the cloud they spell trouble. The cloud is all about flexibility, your app needs to handle all types of unpredictable conditions while still functioning like nothing is wrong. To be flexible in the cloud you need to think small, really small, one app per component small. These small highly specialized apps are called microservices, and when combined, provide the ultimate cloud based application that scales, is fault tolerant, and is easy to maintain and deploy. In this session you will learn all about microservices and why this architectural pattern is the way to go when building cloud applications.
How to Quickly Connect Internet of Things Devices to the Cloud
9 billion devices around the world are currently connected to the Internet, the number of connected devices is expected to increase dramatically within the next decade with estimates ranging from 50 billion devices to 1 trillion.
IBM Internet of Things Foundation is a fully managed, cloud-hosted service that makes it simple to derive value from the Internet of Things (IoT) devices. It allows for the secure collection of data from both sensors, devices and gateways. When combined with the IBM Bluemix™ platform, IBM IoT Foundation provides simple, but powerful application access to devices and data. You can rapidly compose analytics applications, visualization dashboards, mobile apps and applications. These can feed your back-end enterprise with IoT data to generate new business models and insights.
Internet of Things Foundation provides capabilities including device registration, connectivity, control, rapid visualization and storage of data derived from the Internet of Things:
• Connect: Easily register and connect devices and apps
• Collect: Collect and manage a time series view of data from IoT devices
• Assemble: With Bluemix, visually assemble events from IoT into logic flows
• Manage: Manage connections and subscriptions with a highly scalable service
Synchronizing State in a Multi-Device World
Once upon a time, we used one computer at a time. Today is different. We find ourselves in a world where we use many devices simultaneously. As users, we expect all of our data to be available, and up to date on every device. As developers we know this means that we have to brave the complexity of synchronization and concurrency across many platforms.
Modern cloud development platforms provide a solution to this challenge. In this session, Jenny Tong, a Developer Advocate at Firebase, shows you how to use some of these technologies to make your real time, multi-platform development easier.
Kubernetes: An open container scheduling framework
Kubernetes is an open framework for scheduling Docker containers by Google. It was written from the start to be a lean, portable and extensible framework that lets developers actively manage containers the same way Google does. Containers back all of Google’s internet services from Search to Gmail and offer tremendous advantages in terms of efficiency and manageability. Google has been working closely with the broader software community to make containers accessible, and major companies like Microsoft, Red Hat and IBM are also backing the technology and making sure that it runs in a multi-cloud world. During this session we will provide an overview on the Kubernetes framework, discuss how it works to bring active management to the containers world, and give a glimpse into the future as we talk about what is coming next with the project.
Docker for Java Developers: Hands-On Lab
Containers are enabling developers to package their applications (and underlying dependencies) in new ways that are portable and work consistently everywhere—on your machine, in production, in your data center, and in the cloud. And Docker has become the de facto standard for those portable containers in the cloud, whether you’re working with Amazon Web Services, Google Cloud Platform, or Microsoft Azure.
Docker is the developer-friendly Linux container technology that enables creation of your stack: OS, JVM, app server, app, and all your custom configuration. So with all it offers, how comfortable are you and your team taking Docker from development to production? Are you hearing developers say, “But it works on my machine!” when code breaks in production? And if you are, how many hours are then spent standing up an accurate test environment to research and fix the bug that caused the problem?
This lab offers developers an intro-level, hands-on session with Docker, from installation (including boot2docker on Windows/Mac), to exploring Docker Hub, to crafting their own images, to adding Java apps and running custom containers.
This is a BYOL (bring your own laptop) session, so bring your Windows, OSX, or Linux laptop and be ready to dig into a tool that promises to be at the forefront of our industry for some time to come. Prerequisites for the session will be published at burrsutter.com and announced via Twitter @burrsutter prior to the session.
Durandal Aurelia: Next Generation Web Apps
Want to see what the future of web development will be like? Looking for a simple framework or set of libraries that can help you build complex web or cross platform apps? You’re going to want to see this. In this talk we’ll introduce you to Durandal Aurelia, a new framework with a rich heritage. You’ll learn about the fundamental features of the framework, such as Dependency Injection, Templating, Databinding and Routing, while we build a simple application. You’ll leave with all the knowledge you need to get started building your own applications with Aurelia.
WebRTC, Narwhals and Unicorns
This talk is about taking a pragmatic look at WebRTC. In it, we examine the history of WebRTC. The good, the bad and the ugly of WebRTC. And finally, How can we leverage WebRTC NOW to build the next SnapChat or Google Hangout? Think you know WebRTC? Believe me, you’ve never seen it like this.
Responsive Design using the Zurb Foundation Framework
I will share a modern workflow using Grunt, Yeoman, and Bower to build a foundation based project using Sass. I will then show responsive design techniques using foundation and Sass. The goal is to provide some common uses of Sass and Foundation to quickly and more efficiently create responsive websites.
Making Payments Fun
Who ever said payments were complicated/boring? This will be an introduction into the world of online payments and how to make it fun and enjoyable for your customer. Whether it be on your smartphone or website, we’ll show you how you can get setup and accept payments quickly. We’ll also show you some cool tricks, tips and best practices and ways to get started. At the end of this expect to be able to make the most fun, enjoyable and seamless shopping cart checkout experience ever.
Visualizing Data with D3.js
Make sure your notebook has a fully-charged battery, and come prepared to create some compelling data visualizations.
Ionic Framework: The Missing SDK for Hybrid apps
For years, developers have tried to find an easier way to create mobile apps; they discovered hybrid mobile apps but soon found out that hybrid wasn’t ready for prime-time. Developers encountered problems with speed, building good-looking UIs, and a plethora of hardware differences that forced them to go back to the land of native development. AngularJS changed the way developers built apps for the web, and now Ionic has changed the way developers build hybrid apps on mobile.
Easy-to-use, beautiful, and ready to perform, Ionic is an open source framework made for hybrid apps. In this talk, see how to use AngularJS and how to supercharge it with Ionic to create an SDK for the web.
Building a Leap.js App
Keeping It Clean - Lessons learned from Open Source on how to polish code
Creating clean, consistent, readable code is not easy. It’s especially difficult with Open Source where many different contributors can add code. This talk covers some of the techniques that we use in the Spring project to keep Java code clean, and shows how you can apply them within your own team.
We’ll discuss some of the formatting, refactoring and naming techniques that we use, and show some real examples of how code has been changed and improved over time. We’ll also talk about how you can use Git inside your organization, how you can run internal projects in a similar way to Open Source and how applying disciplines and constraints can really enhance your code!
Consulting vs. Industry: Charting a Professional Technical Career Path
For technical professionals, there are distinct differences between a career in Consulting versus a career in Industry. This session will describe both, the differences between the two, the advantages of each for a technically-oriented career, and how to determine which is better for you. The discussion will be neutral and intended to ensure the participants know their option and the longer term career impacts of their decisions. The presentation will also include information on what recruiters look for in resumes across both areas and how to best position yourself for either option.
The goal of the talk will be ensure the attendees know about great options available to them, how to assess these options in terms of their own personal characteristics and goals, and make intentional career decisions that set them up for long term success.
User Experience Tricks of the Trade
Buzz. Buzz. Buzz. User Experience is certainly one of the latest buzzwords, but…what do User Experience professionals actually do?
Honestly, most UX folks, especially generalists, do a little bit of everything - from user interface design and information architecture to usability studies and market research. This workshop concentrates on one of the most important things UX professionals do: help businesses focus on the customer.
In this workshop you will roll up your sleeves and actually participate in some UX research activities. You’ll learn how even a little bit of customer interaction can lead to huge insights… and then you’ll learn how to interpret those insights and incorporate them back into your Agile project.
Information for Review Team:
In the first activity, the participants will play the role of the customer. I guide them through a couple of exercises to create an outline of what customers need and want from a product. I’ll use an accessible example, like a web application for paying a bill online.
Finally, I’ll lead the participants through an activity where they play the role of the business trying to prioritize stories. I’ll show them how they can use the personas to help guide them and how to help avoid common the trap of thinking that just because they know the business intimately they automatically know what the customer would need or want.
General Agile knowledge, particularly SCRUM framework, is assumed.
Wait Wait, Don't Pwn Me!
“Wait, wait! Don’t pwn Me!” is a live, developer and security news game show that pits three developer luminaries against each other in a game of wits. Past participants have included Joshua Corman, Chris Eng, Space Rogue and Matt Tesauro. Host Mark Miller, selects topics from the week’s developer and security news, posing the news items as limericks, fill-in-the-blank, and audience participation questions. The panel competes against each other, and the audience, for speed and accuracy when answering the questions.
During the AppSec USA 2013 Conference, the RSA 2014 Conference and the 2014 AppSec USA, and the AppSec 2014 Europe Conference this was a rollicking, high spirited session, exposing the prevalence of developer and security issues highlighted in the main stream news. It demonstrates how hard it is to keep up to date, even for the experts. Audience members should come prepared as we test their knowledge against the panel, trying to determine what is real news and what is fake.
This is a fun filled session where panelists and audience members compete for prizes. It is sure to put you in a good mood for the rest of the conference.