Learn about HTTP/2 and its relationship to HTTP 1.1 and SPDY through an open source project from Square called okhttp. Understand how HTTP/2 works at a network level and how things like header compression matter. Leave with a solid understanding of what HTTP/2 buys you and how it impacts how to design HTTP Apis.
Developers choose HTTP for its ubiquity. HTTP’s semantics are cherry-picked or embraced in the myriad of apis we develop and consume. Efficiency discussions are commonplace: Does this design imply N+1 requests? Should we denormalize the model? How do consumers discover changes in state? How many connections are needed to effectively use this api?
Meanwhile, HTTP 1.1 is a choice, as opposed to constant. SPDY and HTTP/2 implementations surface, simultaneously retaining semantics and dramatically changing performance implications. We can choose treat these new protocols as more efficient versions HTTP 1.1 or buy into new patterns such as server-side push.
This session walks you through these topics via an open source project from Square called okhttp. You’ll understand how okhttp addresses portability so that you can develop against something as familiar as java’s HTTPUrlConnection. We’ll review how to use new protocol features and constraints to keep in mind along the way. You’ll learn how to sandbox ideas with okhttp’s mock server, so that you can begin experimenting with SPDY and HTTP/2 today!
Many people are drawn to the ideas of REST but aren't sure how to take the next steps. This workshop will help get you to a comfortable place by introducing the concepts and walking through a series of exercises designing REST APIs from a variety of domains.
This workshop will span two session periods but is one effort. Please plan on coming to both.
We will break up into teams and tackle the various aspects of a solid, stable, evolvable REST API design. This will not be a tutorial in particular REST implementations (Jersey, Restlet, etc.). The ideas will transcend specific technologies although we will talk about some particular choices.
Many people are drawn to the ideas of REST but aren't sure how to take the next steps. This workshop will help get you to a comfortable place by walking through a series of exercises. Bring your computers and bring your brains we will be designing, building and testing REST APIs from a variety of domains.
This workshop will span two session periods but is one effort. Please plan on coming to both. Please bring a computer with a late model Java VM on it and a text editor. curl will also be useful. I will provide the remaining bits.
We will break up into teams and tackle the various aspects of a solid, stable, evolvable REST API design. This will not be a tutorial in particular REST implementations (Jersey, Restlet, etc.) but if you have one you are familiar with, you are free to use that for the code portion of the solutions. I will provide a NetKernel-based framework as it is a self-contained, REST-savvy environment that is easy to get going with. The ideas will largely transcend specific implementations though.
At the intersection of Big Data, Data Science and Data Visualization lives a programming language that ranks higher on the TIOBE index than Scheme, Fortran, Scala, Prolog, Erlang, Haskell, Lisp and Clojure. The R language and environment is an open source platform that has quickly become THE language for analyzing data and visualizing the results. This workshop will introduce you to the language, the environment and how it is being used with Big Data and Linked Data.
In the first part of the workshop, we will learn:
At the intersection of Big Data, Data Science and Data Visualization lives a programming language that ranks higher on the TIOBE index than Scheme, Fortran, Scala, Prolog, Erlang, Haskell, Lisp and Clojure. The R language and environment is an open source platform that has quickly become THE language for analyzing data and visualizing the results. This workshop will introduce you to the language, the environment and how it is being used with Big Data and Linked Data.
In the second part of the workshop, we will learn about:
HotSpot promises to do wonders for us by Just-in-Time (JIT) compiling the “right” code for us, but how does it makes those decisions? And, perhaps more importantly, what happens when it's wrong?
In this talk, you'll learn through real code examples just how the JVM decides to compile your code, deoptimize your code, and stop-the-world for a GC.
In this session you will learn to strategically introduce technology innovations by applying specific change patterns to groups of individuals. Using these patterns and related techniques will not only benefit your organization but will ultimately benefit your career as a technologist by making you a better influencer, writer, and speaker.
The rapid pace of technological innovation has enabled many organizations to dramatically increase productivity while at the same time decrease their overall headcount. However, the vacillating global economy combined with “change fatigue” within organizations has resulted in a risk averse culture. In such an environment how can one possibly introduce and inculcate the latest technology or process within an organization? The answer is to have a solid understanding of Diffusion Theory and to leverage Patterns of Change.
Prezi Location: http://prezi.com/b85wwmw7hccn
“Docker is an open-source engine that automates the deployment of any application as a lightweight, portable, self-sufficient container that will run virtually anywhere.” Docker creates containers that provide running process with:
It does this by leveraging low-level Linux kernel primitives like cgroups and namepaces. The end result is a portable application container that can run anywhere Docker can run, including on VMs, bare-metal servers, OpenStack clusters, public instances, or combinations of the above.
Containers are an excellent way to package your application such that it can run consistently everywhere you want to run it, a fantastic step toward Continuous Delivery. In this session we'll look at how to use Docker to package, deploy, and run Java applications and other services. We'll also compare Docker to another container solution, Warden, which is a key component of the Cloud Foundry PaaS.
BOSH was originally developed to be the toolchain that installs and manages the Cloud Foundry runtime, which is a large distributed system consisting of multiple components running on multiple virtual machines. In order to deploy and manage such a system, you need elements of:
Fortunately, BOSH was written in such a way that it can be used to deploy not just Cloud Foundry, but any distributed system. Teams in multiple organizations are using it today to deploy:
In this session we'll learn how to develop a BOSH release using the bosh-lite tool. We'll then learn how to create a deployment manifest, which maps our release to a specific infrastructure environment. Finally, we'll deploy our release to Amazon Web Services.
Many software developers point their career towards ascending to the gilded rank of Architect…but what does it mean to actually be one? While many of us labor under false pretense of abject technical decision making, the reality is often very different. You'll code less, spending more time on activities that lack an objective green/red bar. But you'll also an opportunity to impact far more than one project.
In this talk, I'll speak to my own journey. We'll touch on influencing coworkers, the importance of communication and the importance of cup of coffee.
Many software developers point their career towards ascending to the gilded rank of Architect…but what does it mean to actually be one? While many of us labor under false pretense of abject technical decision making, the reality is often very different. You'll code less, spending more time on activities that lack an objective green/red bar. But you'll also an opportunity to impact far more than one project.
In this talk, I'll speak to my own journey. We'll touch on influencing coworkers, the importance of communication and the importance of cup of coffee.
Architecting and developing user interfaces used to be relatively easy, pick a server side framework, define a standard monitor resolution and spend your days dealing with browser quirks. But today, the landscape presents us with a plethora of screen sizes and resolutions covering everything from a phone to a tablet to a TV. How does a team embrace this brave new world knowing that the future will introduce even more volatility to the client space?
This talk will walk you through this brave new world. We'll discuss the deluge of devices the typical application must deal with today as well as looking at the plethora of client side rendering technologies. This isn't strictly a front end problem though, we need to reconsider how we've built our server side solutions as well; modern applications rely on RESTful web services delivering data to a diverse set of clients. The development landscape has changed, this talk will prepare you to face these challenges.
By now, the importance of having a mobile solution is obvious to just about every seat in the organization…but how do develop expertise? How do we work through the inevitable politics and organizational issues? What about the technical questions about hybrid vs. web vs. native?
Before you think about a mid life career change, spend some time listening to what we did in one large company. We may not have had all the right answers, but we learned a few things along the way.
A Technology Radar is a tool that forces you to organize and think about near term future technology decisions, both for you and your company. This talk discusses using the radar for personal breadth development, architectural guidance, and governance.
ThoughtWorks Technical Advisory Board creates a “technology radar” twice a year, a working document that helps the company make decisions about interesting technologies and where we spend our time. ThoughtWorks then started conducting radar-building exercises for our clients, which provides a great medium for technologists company-wide to express their opinions about the technologies they use every day. For companies, creating a radar helps you document your technology decisions in a standard format, evaluate technology decisions in an actionable way, and create cross-silo discussions about suitable technology choices. This session describes the radar visualization and how to conduct a radar building session for yourself. After a brief introduction, the bulk of the workshop consists of attendees building a radar for the group, following the same procedure you'll use when you do this exercise at your company. At the end, we'll have created a unique Radar for this event and practiced doing it for yourself.
Clojure is the most interesting new language on the JVM, both from a syntactic and capabilities standpoint. This workshop teaches attendees Clojure syntax, Java interoperability, and how to build applications, both Swing and Web, using Clojure.
After spending time with Clojure, you gradually realize that it isn’t really a new language, but rather a vision for how to write robust applications that could only be realized via a new language — called Clojure.
Clojure is the most interesting new language on the JVM, both from a syntactic and capabilities standpoint. This workshop teaches attendees Clojure syntax, Java interoperability, and how to build applications, both Swing and Web, using Clojure.
Come see why there is so much buzz around the most innovative new language in a decade.
Clojure is the most interesting new language on the JVM, both from a syntactic and capabilities standpoint. This workshop teaches attendees Clojure syntax, Java interoperability, and how to build applications, both Swing and Web, using Clojure.
Continues the topics introduced in Part 1 of the workshop
Come see why there is so much buzz around the most innovative new language in a decade.
The world of hardware hacking has been gaining popularity recently. With the advent of open-source hardware, there's been tremendous interest in hacking hardware again. In this session, we'll look at two popular hardware platforms: Arduino and RaspberryPi. We'll also look at how to integrate the Arduino with Android to build a cheap, complete hardware hacking platform, all written in Java!
We'll go over the current open hardware scene first. Then we'll look at how to setup these two platforms. Of course, we'll write some code and deploy them onto the hardware!
Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages - once you know regular expressions you will find a use for them in almost every programming context.
In this session we will attempt to unriddle the mystery that regular expressions pose. We will start at the basics and work our way towards more complex expressions.
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.
A nice alternative to relational databases, graph databases are being used in a number of applications from social networking to data analysis. Neo4J is a powerful, high performance industrial strength database that is highly scalable. It provides nice integration with Java.
In this presentation we will learn the fundamentals of using this graph database, visualize data, navigate and work with a graph of relationships.
Moderns IDEs are great, they let us get our work done, focus on solving problems, provide code prompts, and more. On the flip-side, they hide of lot of details and often do not provide everything to help get our work done. Learning to effectively use the command line, can help us navigate around, write script to automate certain routine tasks, isolate and understand issues, and more.
In this presentation we will lear some ticks and tips we can do on the command line, using some common editors, and general navigation, both for unix-like machines and Windows.
Multiple languages on the JVM offer the ability to write concise and expressive code. One thing that sets Groovy apart, more distinctively than a few others, is its ability to extend the program at runtime.
Classes are open in Groovy and we can not only add methods, but we can synthesize methods as well, at runtime. This ability provides for quite an interesting set of flexibilities, paving the way to create highly dynamic applications, domain specific languages, lightweight configurable components, all with less code.
In this workshop we will dive into metaprogramming in Groovy, using practical hands-on examples and make use of it to create some dynamic behavior. We will focus on concepts and techniques you can readily put to real use on your next project.
Multiple languages on the JVM offer the ability to write concise and expressive code. One thing that sets Groovy apart, more distinctively than a few others, is its ability to extend the program at runtime.
Classes are open in Groovy and we can not only add methods, but we can synthesize methods as well, at runtime. This ability provides for quite an interesting set of flexibilities, paving the way to create highly dynamic applications, domain specific languages, lightweight configurable components, all with less code.
In this workshop we will dive into metaprogramming in Groovy, using practical hands-on examples and make use of it to create some dynamic behavior. We will focus on concepts and techniques you can readily put to real use on your next project.
Get your skills up to speed for JavaScript, the oft-misunderstood language of the web, in this 2 part workshop. We'll start from the very basics and learn the ins-and-outs of JavaScript. We'll look at the (many) quirks in JavaScript, and work through advanced features that make this language so powerful. Come with an open-mind and ready to dig into code!
This 2 part workshop requires a laptop, and assumes the attendee has ZERO knowledge of JavaScript. We'll break down your bad habits, and build upon known patterns and best practices to raise your JavaScript-fu.
JavasScript workshop part II
Get your skills up to speed for JavaScript, the oft-misunderstood language of the web, in this 2 part workshop. We'll start from the very basics and learn the ins-and-outs of JavaScript. We'll look at the (many) quirks in JavaScript, and work through advanced features that make this language so powerful. Come with an open-mind and ready to dig into code!
This 2 part workshop requires a laptop, and assumes the attendee has ZERO knowledge of JavaScript. We'll break down your bad habits, and build upon known patterns and best practices to raise your JavaScript-fu.
Jasmine is a browser centric testing framework. It's the default test framework in Jasmine and is the most popular framework among JavaScript developers. It takes a BDD testing approach.
Mocha is a popular testing framework for JavaScript - for any JavaScript environment, including the Web Browser, NodeJS, and Titanium. It allows for simple asynchronous testing, test coverage, and integration to CI tools. In this session, learn all you need to know about getting started for writing beautiful tests in JavaScript for these environments. We’ll discuss a number of add-ons for Mocha to make testing a breeze. We’ll talk about “should” and “chai” for expectation matching. We’ll discuss “simon” for mocking in your test cases. We’ll also talk about test automation with Grunt.
This session is a code-driven class that covers the Jasmine and Mocha JavaScript testing library. It is an introductory level session.
JavaScript has a mixed heritage: OO and Functional. To date, us developers have focused on the OO side of JavaScript and not much mind-share has been given to the other, more powerful side. In this session we'll explore how to use the power of functional Javascript.
JavaScript has elements of two distinct programming languages: Self and Scheme. These two languages are very different - and some of JavaScript's weirdness is due to this mixing of very different language designs. The conceptual models are also very different between Self and Scheme - one is a prototypical object based language, while the other is a functional language. In this session, we'll discuss the elements of how the Scheme functional programming language manifest in JavaScript. We're going to explore how you can write JavaScript in a more elegant and powerful way by applying functional concepts.
We've come a long way down the JavaScript road. Gone are the days of 'just hack it' for the web - architecting even a small project in JavaScript can be a challenge. Thankfully, there are several frameworks to help you; the most popular currently is Backbone.js.
Before you start using a framework in JavaScript, you will want to understand the techniques expert JavaScript programmers use to build them. In this session, we'll dive into design patterns in JavaScript, and do live coding so you can see these patterns applied. Even if you're not using a framework, you can use these design patterns to make your code more maintainabile, elegant, and concise.
Transitioning the citizen services completely open source - utilizing Java. Migrating and restructuring existing services and departments into a single cohesive scalable resource for delivering online information for services such as, vehicle information, civil service, judicial and anything else a government entity will require. A complete SOA restructuring of disparate systems, languages and services built on proprietary systems, integration of non standards compliant web services, databases, regionally distributed system while increasing uptime, scalability, response time and management of a single master data source.
A case study of the transition from disparate government entities, various forms of delivering data, lack of a uniform schema and several political boundaries. During this session we will look at setting up a message driven asynchronous infrastructure to rapidly integrate legacy systems requiring web services, JPA, JDBC into a common dictionary, structure and cluster ready system. All based on existing and open Java API's, technologies and easy to use frameworks. We will show how to effectively combine SOA techniques with modern Key Value stores, effectively use OSGi and JPA, rely on proven api's as JMS and combining all of these with existing and well proven Apache Java offerings. We will address scalability, security, systems design and rapid development of highly robust web services and stateless interfaces for high load systems. In the end of the session you'll have a complete overview of a big data system based on Camel, Karaf, CXF and Cassandra. A completely message driven design that interacts with legacy systems encompassing many commercial and open source offerings commonly used.
Time is very precious and is often threatened by phone calls, emails, co-workers, bosses, and most of all, yourself. The Pomodoro Technique reigns in unfocused time and gives your work the urgency and the attention it needs, and it's done with a kitchen timer.
In this presentation we discuss how to set up, estimate time, log time, deal with interruptions, and integrate with Agile as a team. We discuss timer software and even some of the great health benefits of the Pomodoro Technique.
Angular is a new JavaScript framework from Google. If you are looking into developing rich web applications, Angular is your friend. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test. In this workshop we will start from the ground up, and build our way through a simple application that will let us explore the various constructs, and the familiarize ourselves with some of the new terminology in Angular.
In this workshop we will get down and dirty with Angular. In this workshop we will start with the very basics of how to boostrap our AngularJS application, and work slowly towards making REST-ful AJAX requests to a backend. List of topics include
ng-appng-init and the evaluation {{ }} directive$rootScopeng-modelng-repeatng-form, form validation and submission in AngularJS$http$routeProvider and $routeParamsIf time permits we will discuss a few good practices when working with AngularJS applications.
This is a hands on tutorial so bring your laptops!
brew install gitMake sure Git is available on your path
Open up a new terminal window
$ git --version
> # Anything greater than 2 will do
> git version 2.1.3
Make sure leiningen is available
$ lein --version
> Leiningen 2.5.1 on Java 1.8.0_40 Java HotSpot(TM) 64-Bit Server VM
If you have an account on Github, feel free to fork the repository and then clone it.
Clone the repository on Github
At a terminal, cd into a directory and run git clone git@github.com:looselytyped/angudone-workshop.git. Note that if you did fork the repository under your account your URL will be something like git@github.com:<YOUR-ACCOUNT-NAME>/angudone-workshop.git
Wake up the application
# at the terminal
# cd to where you cloned the repository above.
$ git checkout master-1.4
$ lein ring server
# This will download a whole bunch of files from Maven Central
# and will end with
# Started server on port 3000
http://localhost:3000/ (If it does not just go to that URL). You should see a HTML page announcing AngudoneEnsure that the REST endpoints are active
Right-Click -> Inspect Element (this will open the Inspector) and then go to the Console tabRight-Click -> Inspect Element (this will open the Chrome Inspector) and then go to the Console tab (right most)Both Consoles give you the ability to run JavaScript code. Run the following
http.get("todos")
.success(function(data, status, headers, config) {
console.log("There are " + data.length + " todos");
}).error(function(data, status, headers, config) {
console.error("Oh Noes! Something went wrong" + data);
});
You should see a a valid response indicated by There are 0 todos
The Web is changing faster than you can imagine and it is going to continue to do so. Rather than starting over from scratch each time, it builds on what has succeeded already. Webs of Documents are giving way to machine-processable Webs of Information. We no longer care about data containers, we only care about data and how it connects to what we already know.
Roughly 25% of the Web is semantically marked up now and the search engines are indexing this information, enriching their knowledge graphs and rewarding you for providing them with this information.
In the past we had to try to convince developers to adopt new data models, storage engines, encoding schemes, etc. Now we no longer have to worry about that. Rich, reusable interface elements like Web Components can be built using Semantic Web technologies in ways that intermediate developers don’t have to understand but end users can still benefit from. Embedded JSON-LD now allows disparate organizations to communicate complex data sets of arbitrary information through documents without collaboration.
Perhaps the concepts of the Semantic Web initiative are new to you. Or perhaps you have been hearing for years how great technologies like RDF, SPARQL, SKOS and OWL are and have yet to see anything real come out of it.
Whether you are jazzed or jaded, this workshop will blow your mind and provide you with the understanding of a technological shift that is already upon us.
In this workshop, we will:
Explain the Web and Web architecture at a deeper level
Apply Web and Semantic Web technologies in the Enterprise and make them work together
Integrate structured and unstructured information
Create good, long-lived logical names (URIs) for information and services
Use the Resource Description Framework (RDF) to integrate documents, services and databases
Use popular RDF vocabularies such as Dublin Core, FOAF
Query RDF and non-RDF datastores with the SPARQL query language
Encode data in documents using RDFa and JSON-LD
Create self-describing, semantic Web Components
Model and use inferencing with the Web Ontology Language (OWL)
When we run into issues with our programs we often run to the debugger. While that's a powerful tool, there are problems far beyond what a debugger can expose. We often want to profile code, take a look at the memory usage or where a bottle neck may be.
In this presentation we will take a look at a few tools that are pretty useful to help us take a peek at the code and proactively improve the performance of our applications.
Please ensure you've installed the latest version of Java 7 JDK or Java 8 JDK on your systems. We will be using a number of tools that ship with either of these two installations.
Learn Groovy from a Java developer's perspective. Use Groovy features like native collections, operator overloading, and the Groovy JDK. Additional topics will include closures, builders, AST transformations, and basic metaprogramming.
Tests using both JUnit and Spock will be provided, as well as a Gradle build file. All code will be made available through a git repository.
You need:
Optional:
Note: If you can run a bash shell, consider http://gvmtool.net
Spend a day learning how to develop native apps on the world's most popular smartphone platform. You'll get hands on experience developing a native Android app that will use most of the major components available in the framework.
The workshop will be taught using Android Studio with the new Gradle build system.
Use Android Activites to create the User Interface. Learn how to run background services. Create broadcast receivers to react to changes in the phones state. You'll even learn how to interact with the location services and display Google maps.
We'll take a deep dive into the details. You'll write code to interact with Android's built-in SQLite database. You'll add logging to your app and you'll even learn how to do unit testing in the Android environment.
Leave the class with hands-on skills and a working application that will be ready to publish to the Android Market.
Don't miss out on this excellent opportunity. Register now!
Please install Android Studio before arriving at the workshop.
We'll be using Android Studio for this workshop.
Java (if you don't have it)
http://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase6-419409.html#jdk-6u45-oth-JPR
Android Studio
The website has version 0.8.14 - which can be upgraded to 1.0 once you install it.
http://developer.android.com/sdk/installing/studio.html
Android SDK
Note: The SDK is a separate download from the Android Studio Bundle
Click on the link for “GET THE SDK FOR AN EXISTING IDE” to download the SDK
http://developer.android.com/sdk/index.html
Labs
Download all files
http://goo.gl/RjItQn
To make the best use of our time during the one day tutorial, it is very helpful if you can have the IDE installed
and working by the time class starts.
Also, make sure that you have installed the most recent versions of the following components using the SDK manager:
Tools
Android SDK Tool
Android SDK Platform-tools
Android SDK Build-tools
Android 4.4.2 (API 19)
Documentation for Android SDK
SDK Platform
Intel x86 Atom System Image
Source for Android SDK
Extras
Android Support Repository
Android Support Library
Google Repository
Intel x86 Emulator Accelerator
Try to complete the first lab in the file “labs/Lab02-1.pdf”
Note: The Android labs must be run on an emulator or a real device. The most time consuming part of the workshop is getting the emulator running. Try to set up a working emulator before arriving.
Please feel free to contact me with any setup questions:
During the all day iOS hands-on tutorial, we will do soup to nuts iOS development. We will start with how to use XCode and build a universal application for iPhone and iPad using a variety of common APIs. We will finish up talking about and demoing how to prepare and deploy to the app store.
The app we build will allow us to experiment with a bunch of APIs including Core Data, Camera, and more.
Minimum:
- Mac
- Yosemite
- Xcode 6
- iOS 8.0 or greater
- Free Apple developer account
Preferred:
- Device (iPhone, iPod Touch or iPad)
- Paid Apple developer account
Please come prepared with the software downloaded and install as they are very large downloads.
As a web application developer, most of the focus is on the user stories and producing business value for your company or clients. Increasingly however the world wide web is more like the wild wild web which is an increasingly hostile environment for web applications. It is absolutely necessary for web application teams to have security knowledge, a security model and to leverage proper security tools.
This training workshop on security will provide an overview of the security landscape starting with the OWASP top ten security concerns with current real world examples of each of these attack vectors. The first session will consist of a demonstration and labs using hacker tools to get an understanding of how a hacker thinks. It will include a walk through of the ESAPI toolkit as an example of how to solve a number of these security concerns including hands-on labs using the OWASP example swingset.
The workshop will include several hands on labs from the webgoat project in order to better understand the threats that are ever so common today.
Attendees will come away with the following skills / capabilities:
Don't be the weakest link on the web!
Getting software released to users is often a painful, risky, and time-consuming process. This workshop sets out the principles and technical practices that enable rapid, incremental delivery of high quality, valuable new functionality to users. Through automation of the build, deployment, and testing process, and improved collaboration between developers, testers and operations, delivery teams can get changes released in a matter of hours–sometimes even minutes–no matter what the size of a project or the complexity of its code base.
In this workshop we take the unique approach of moving from release back through testing to development practices, analyzing at each stage how to improve collaboration and increase feedback so as to make the delivery process as fast and efficient as possible. At the heart of the workshop is a pattern called the deployment pipeline, which involves the creation of a living system that models your organization's value stream for delivering software. We spend the first half of the workshop introducing this pattern, and discussing how to incrementally automate the build, test and deployment process, culminating in continuous deployment.
Monolithic applications are difficult to understand, maintain, and extend with new features and functionality. Modularity helps achieve these goals. Unfortunately, few applications have been designed with modularity in mind. In this workshop, we take a deep dive into modularity.
We'll start developing a software system using several of the patterns of modular architecture. We'll explore the patterns and then apply them to develop a sample application. Along the way, we'll discuss implementation variations and the consequences of our decision. When finished, we'll have a simple but useful application that you can take home with you and easily extend with new functionality. This session is all pure Java, and you'll be able to apply the techniques you learn immediately.
A full day, Scala hands-on workshop, that takes your typical Java code that you use day after day, and transforms into idiomatic functional Scala code. The result? Cleaner and more concise code.
We cover the “scala-fication” of:
We will also cover new topics if you are new functional programming like:
Hello! Welcome to Scala for Java Developers!
This is a fairly straightforward workshop. Being as it may, there are a few things you need before you arrive.
Make sure that the following commands work on your command line:
javac -version
java -version
scalac -version
scala -version
This is a premier conference for Java developers so I will leave it up to you to make sure that javac and java work as expected.
As for Scala, which you may not be familiar with, the rule a similar.
Download Scala zip or .tar.gz from http://www.scala-lang.org/download
Uncompress the zip or .tar.gz into your favorite location for JVM binaries and note the location
Map a SCALA_HOME environment variable to the location where you just unzipped the Scala binary
Append to your pre-existing PATH environment variable; %SCALA_HOME%\bin for Windows and $SCALA_HOME/bin for MacOSX and Linux.
Editors
Though it is not mandatory, you may want to set up your editor or IDE of choice with a plugin that will enhance your experience with syntax highlighting and additional tools in the Scala programming language. Here are some options:
Eclipse - The Eclipse has an IDE plugin for Scala called aptly scala-ide. All the information about the plugin can be found at http://scala-ide.org including an easy to follow along video located at http://scala-ide.org/docs/current-user-doc/gettingstarted/index.html
IntelliJ - IntelliJ has a Scala plugin that can be found by going to Settings -> Plugins, clicking on 'Browse Repositories' button and searching for the 'Scala' plugin on the left. Right click on the 'Scala' and choose 'Install'. IntelliJ will prompt you to restart the IDE, do so, and enjoy.
NetBeans - Currently, Github user 'dcaoyuan' hosts a NetBeans Scala plugin at the address: https://github.com/dcaoyuan/nbscala. I have not tried this out since the number of NetBeans users has shrunk in recent years. If you are an avid NetBeans user, and wish to try it, you can let me know the results during the session. There is additional information at: http://wiki.netbeans.org/Scala
Emacs - Github user 'aemoncannon' has created 'ENSIME' (ENhanced Scala Interaction Mode for Emacs) at the address and has a great following. https://github.com/aemoncannon/ensime with some documentation at http://aemoncannon.github.io/ensime.
VIM - For VIM users you can use https://github.com/derekwyatt/vim-scala as a VIM plugin that offers Scala color highlighting
That's all and see all of you real soon.
Wonder what all the Cloud Computing hype is about? Want to know how to deploy a standard Java web application to the cloud and get limitless scalability? Well, this hands on tutorial will answer all your questions and provide confidence by walking you through the process of deploying a sophisticated Java web application to the Amazon Web Service (AWS) Cloud.
During this tutorial you will provision clustered servers (EC2), relational database (EC2 and EBS), load balancer (Elastic Load Balancing), content delivery (Cloud Front) and how to monitor your whole infrastructure. Other Amazon Web Services will be demonstrated and discussed as appropriate.
Note: An Amazon Web Services Account is a nice to have and will incur a minimal cost during the tutorial but is not a requirement. Access to AWS will be provided to you if you don’t already have access.
Wonder what all the Cloud Computing hype is about? Want to know how to deploy a standard Java web application to the cloud and get limitless scalability? Well, this hands on tutorial will answer all your questions and provide confidence by walking you through the process of deploying a sophisticated Java web application to the Amazon Web Service (AWS) Cloud.
During this tutorial you will provision clustered servers (EC2), relational database (EC2 and EBS), load balancer (Elastic Load Balancing), content delivery (Cloud Front) and how to monitor your whole infrastructure. Other Amazon Web Services will be demonstrated and discussed as appropriate.
Note: An Amazon Web Services Account is a nice to have and will incur a minimal cost during the tutorial but is not a requirement. Access to AWS will be provided to you if you don’t already have access.
You spend your precious time building the perfect application. You do everything right. You carefully craft every piece of code and rigorously follow the best practices and design patterns, you apply the most successful methodologies software engineering has to offer with discipline, and you pay attention to the most minuscule of details to produce the best user experience possible. It all pays off eventually, and you end up with a beautiful code base that is not only reliable but also performs well. You proudly watch your baby grow, as new users come in bringing more traffic your way and craving new features. You keep them happy and they keep coming back. One morning, you wake up to servers crashing under load, and data stores failing to keep up with all the demand. You panic. You throw in more hardware and try optimize, but the hungry crowd that was once your happy user base catches up to you. Your success is slipping through your fingers. You find yourself stuck between having to rewrite the whole application and a hard place. It's frustrating, dreadful, and painful to say the least. Don't be that guy! Save your soul before it's too late, and come to learn how to build, deploy, and maintain enterprise-grade Java applications that scale from day one.
Topics covered include: parallelism, load distribution, state management, caching, big data, asynchronous processing, and static content delivery. Leveraging cloud computing, scaling teams and DevOps will also be discuss. P.S. This session is more technical than you might think.
Java 8 brings support for lambda expressions and functional style of programming. With that, the design concepts and the patterns we're used to in Java enjoy a makeover.
Come to this presentation to learn about how the familiar patterns transform and shine in Java 8.
Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.
Almost every example of an agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale agile beyond a single team? What practices translate and which ones don't? In this talk we'll discuss some of the issues you'll encounter as you move agile beyond a single group and how you can keep multiple stakeholders happy. While it isn't as simple as having a “scrum of scrums” it isn't as hard as replacing every line of COBOL.
Modularity is coming to the Java platform! Java 9 will introduce the Jigsaw module system. OSGi is here today. But don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!
In this session, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.
Despite our wishing it were so, software architecture is not static throughout a project. Yet, we make many of our software architecture decisions early in the software development lifecycle. In today’s volatile technology and business climate, big architecture up front is not sustainable. In this session, we will explore several techniques that help us create more flexible and adaptable software systems. But first, we’ll expose the true essence of what’s meant when we say “architectural agility.”
What’s the goal of architecture? To serve as a blueprint of the system? Possess the flexibility to evolve as new requirements emerge? To satisfy the architectural qualities, including performance, security, availability, reliability, and scalability? Yes. Yes. Yes. But how do we create software architectures that achieves all of these goals? And how do we ensure no disconnect occurs between developers responsible for implementation and architects responsible for the vision? Especially in a volatile technology climate where organizations seek to move their applications to the cloud, expose application capabilities to new endpoints, and deliver new capabilities quickly? In this session, we’ll explore techniques to increase architectural agility and provide some actionable advice that will help you get started immediately.
Technology changes, it's a fact of life. And while many developers are attracted to the challenge of change, many organizations do a particularly poor job of adapting. We've all worked on projects with, ahem, less than new technologies even though newer approaches would better serve the business. But how do we convince those holding the purse strings to pony up the cash when things are “working” today? At a personal, how do we keep up with the change in our industry?
This talk will explore ways to stay sharp as a software professional. We'll talk about how a technology radar can help you stay marketable (and enjoying your career) and how we can use the same technique to help our companies keep abreast of important changes in the technology landscape. Of course it isn't enough to just be aware, we have to drive change - but how? This talk will consider ways we can influence others and lead change in our organizations.
Enforcing the cloud presence of an organization by exposing a RESTfull API is of extreme importance. It is a demanding and formidable task that can turn out to be either a great asset or a dire liability. This challenge is amplified by the vagueness of what a REST architecture is, and the diversity in approaches and opinions among the leading Web APIs.
This session attempts a balance between the spirit and philosophy behind REST, and the practicality and elegance inspired by the principles of modern API design. This very idea is highlighted through a series of concrete issues that frequently surface while building or evolving a mature REST interface whose goal is not only to be complete and feature-rich, but also intuitive and practical.
The rise of NoSQL is characterized with confusion and ambiguity; very much like any fast-emerging organic movement in the absence of well-defined standards and adequate software solutions. Whether you are a developer or an architect, many questions come to mind when faced with the decision of where your data should be stored and how it should be managed. The following are some of these questions: What does the rise of all these NoSQL technologies mean to my enterprise? What is NoSQL to begin with? Does it mean “No SQL”? Could this be just another fad? Is it a good idea to bet the future of my enterprise on these new exotic technologies and simply abandon proven mature Relational DataBase Management Systems (RDBMS)? How scalable is scalable? Assuming that I am sold, how do I choose the one that fit my needs best? Is there a middle ground somewhere? What is this Polyglot Persistence I hear about?
The answers to these questions and many more is the subject of this talk along with a survey of the most popular of NoSQL technologies. Be there or be square.
There is nothing better than looking at real-world examples to understand project failures and project successes. This session is intended to be an open conversation, based closely to a birds of a feature (BOF) session, however it will have a series of “that happened to me” topics throughout discussed from the perspective of technology.
Discussed will be a clients dating back from 2005. The actually client and there name will not be revealed, but the industry, the contraints and some of the outcomes will.
Over the years, Java developers have learned through trial-and-error the best ways to use Java's type system. But certain parts of the type system like wildcard generics and covariant return types are
under used; in-part, because they are not well understood.
Fortunately by going back to the mathematical roots of type systems, we can understand not only wildcard types and covariance, but also why we should prefer composition over inheritance and even how compilers perform some of their optimization magic.
Just like you need to understand execution plans to write efficient SQL, it helps to understand the JVM's execution engine to write efficient Java code.
In this talk, you'll learn how Java's Just-in-Time (JIT) compiler dissects your code, and by doing so you'll learn how to write efficient code more efficiently, but also gain a better understanding of concurrency challenges as well.
Early releases of Java performed poorly, but those issues largely disappeared long ago with the introduction of HotSpot. However, much of the performance advice for Java persists through hearsay from those early days.
In this talk, we'll forget the hearsay and take an objective look using benchmarking and profiling tools to find out which optimizations matter today and just as importantly those that don't.
Metaprogramming is the dirty little secret behind the success of many Java frameworks such as Spring and Struts2, and forms the backbone of many of the most fundamental APIs across the JEE technology stack. This session aims to introduce the topic and highlight, with code examples, the different mechanisms and techniques to take advantage of this underused feature of the Java Programming Language.
This session will adopt a learn-by-example approach that combines the philosophy and theory behind metaprogramming with concrete code examples. No previous knowledge or exposure to the topic is required, but an intermediate understanding of Java SE is expected.
Java EE 7 is around the corner and the horizons for Java EE 8 are emerging. This session looks into the key changes the community can expect. The goal of this session is to foster interest and discussion around these changes.
Some of the changes discussed include retiring EJB 2 entity beans and JAX-RPC, greater alignment with CDI, WebSocket/HTML 5 support, a standard API for JSON processing, the next version of JAX-RS, an overhaul of JMS, long-awaited concurrency utilities, batch processing in Java EE and much, much more.
JMS is the Java standard for accessing enterprise messaging systems. This session introduces JMS 2 (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 is a new API that makes JMS much easier to use, especially in a Java EE application. JMS 2 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 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.
The surge of interest in the REpresentational State Transfer (REST) architectural style, the Semantic Web, and Linked Data has resulted in the development of innovative, flexible, and powerful systems that embrace one or more of these compatible technologies. However, most developers, architects, Information Technology managers, and platform owners have only been exposed to the basics of resource-oriented architectures.
This talk, based upon Brian Sletten's book of the same name, is an attempt to catalog and elucidate several reusable solutions that have been seen in the wild in the now increasingly familiar “patterns” style. These are not turn key implementations, but rather, useful strategies for solving certain problems in the development of modern, resource-oriented systems, both on the public Web and within an organization's firewalls.
Searching is an integral part of many applications today and yet it can still be difficult to integrate search into an application well. Search becomes even more challenging when you consider searching across an enterprise or need to support a large scale.
This presentation will explain how you can simplify searching with the open source enterprise search engine, Apache Solr. By the end of the presentation you will understand the relationship between Apache Lucene and Solr, how to create search documents, populate search documents all using Solr's easy REST-like HTTP/XML and JSON APIs. We will also look at some of the more interesting document mapping strategies and maybe even at some of the geo spacial searching capabilities.
Google Guava is an open-source library for Java developed and supported by Google engineers. Use it to simplify Java coding - things that use to take 20 lines of code can now be done in 1 or 2 simple statements with Gauva. You can add it to any Java project but it is especially useful in Android because of its small footprint.
In this session you'll find out what's in Guava. Some people refer to it as “the missing java package” because it contains replacements and enhancements for so many of the most common things a Java programmer has to do - things like file i/o, string manipulation and checking for null objects. And you'll see side by side code comparisons between Java and Gauva.
Here are some of the key features of Guava we'll be exploring
Here are some other important questions we'll answer to maximize your use of Guava
Join me and learn how to use Gauva to write less code that does more! That'll impress your family, friends and especially your manager - all while leaving your more time to check out the Netflix back catalog and improve your “Settler's of Caton” skills.
As an industry we are collecting more and more data. At some point we have to be able to make sense of the data. Unfortunately many of the tools we have historically used can not scale up to the terabytes and petabytes we have captured. Hadoop is one of those relatively new technologies that is taking the industry by storm since it has proven to scale by taking advantage of the MapReduce pattern and distributed computing.
During this hands-on tutorial you will provision a Hadoop cluster, write MapReduce jobs and learn how to store and access data via Hadoop Distributed File System (HDFS). You will also learn how cloud providers such as Amazon Web Services’ Elastic MapReduce (EMR) and Microsoft’s Azure HDInsight provide Hadoop as a service.
As an industry we are collecting more and more data. At some point we have to be able to make sense of the data. Unfortunately many of the tools we have historically used can not scale up to the terabytes and petabytes we have captured. Hadoop is one of those relatively new technologies that is taking the industry by storm since it has proven to scale by taking advantage of the MapReduce pattern and distributed computing.
During this hands-on tutorial you will provision a Hadoop cluster, write MapReduce jobs and learn how to store and access data via Hadoop Distributed File System (HDFS). You will also learn how cloud providers such as Amazon Web Services’ Elastic MapReduce (EMR) and Microsoft’s Azure HDInsight provide Hadoop as a service.
Whether you attended the Introduction to Hadoop pre-compiler or have some experience with Hadoop, this pre-compiler will take you to the next level with Hadoop by showing you how to utilize Hadoop's powerful accessorial tools such as Hive, Pig, Flume, HBase and Mahout. You will learn how to organize your data, get analytics, and even invoke machine learning to drive a recommendation engine like those used by Netflix, Amazon, and countless dating sites.
You will tour these technologies in a pre-configured environment to make large scale data transformations and queries using the power of MapReduce without the need for Java code. You will also explore the world of machine learning by writing (Java) code that finds patterns and relationships in data through clustering and classifying strategies as you harness the power of MapReduce to elicit informed recommendations from data.
Whether you attended the Introduction to Hadoop pre-compiler or have some experience with Hadoop, this pre-compiler will take you to the next level with Hadoop by showing you how to utilize Hadoop's powerful accessorial tools such as Hive, Pig, Flume, HBase and Mahout. You will learn how to organize your data, get analytics, and even invoke machine learning to drive a recommendation engine like those used by Netflix, Amazon, and countless dating sites.
You will tour these technologies in a pre-configured environment to make large scale data transformations and queries using the power of MapReduce without the need for Java code. You will also explore the world of machine learning by writing (Java) code that finds patterns and relationships in data through clustering and classifying strategies as you harness the power of MapReduce to elicit informed recommendations from data.
Some come to Agile assuming it involves less discipline than their traditional methods, but this is a misperception. Today, the need for discipline in software development is greater than it ever was. Agile answers that need, arriving at discipline through the Team. Agile Teams must collaborate to develop strong discipline in both planning and execution.
We'll discuss how teams can obtain Agile discipline to achieve one of our core principles of delivering “working software” frequently. We'll explore some of the key Agile planning and engineering practices like continuous planning, Test-Driven Development, Continuous Integration and Acceptance testing. We'll look at the discipline involved in these practices, their inter-relationship, and the benefits they realize in delivering value to the customer.
cloud architecture… an architectural walk through cloud services and components
high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security
low level
HAProxy
Nerve
synapse
queues
compute
dns
cloud architecture… an architectural walk through cloud services and components
high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security
low level
HAProxy
Nerve
synapse
queues
compute
dns
cloud architecture… an architectural walk through cloud services and components
high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security
low level
HAProxy
Nerve
synapse
queues
compute
dns
cloud architecture… an architectural walk through cloud services and components
high level
Data Centers / VDC
CDN
Monitoring
Load Balancing
Queue
Storage (s3, etc)
DNS
Search
Routing
(Amazon + Open Source) example: CloudSearch vs ElasticSearch
Security
low level
HAProxy
Nerve
synapse
queues
compute
dns
Becoming more agile
Becoming more agile
Build a Grails application from start to finish in this half-day workshop. We'll start with domain classes, apply constraints, add controllers and services, apply both unit and integration tests, and then add additional functionality through plugins.
This rapid introduction to Grails will take advantage of the newest features of Grails 2.0 using the interactive scripts and db console. In addition to building an application, existing samples will be reviewed as a source of good practices and plugins.
Some knowledge of Groovy is assumed but not required.
Software:
Unzip the Grails distribution, set a GRAILS_HOME variable to its location, and add the bin subdirectory to your path.
As an alternative installation mechanism, please consider GVM, located at http://gvmtool.net . That will allow you to switch Grails version with a single command. It works for Macs and Unix flavors, as well as Windows through Cygwin.
No IDE is required, but if you want to use one, consider Groovy and Grails Tool Suite. The current version is 3.3.0 and can be downloaded from http://grails.org/products/ggts. IntelliJ IDEA has Grails support in its Ultimate edition only. NetBeans also has Grails support.
Build a Grails application from start to finish in this half-day workshop. We'll start with domain classes, apply constraints, add controllers and services, apply both unit and integration tests, and then add additional functionality through plugins.
This rapid introduction to Grails will take advantage of the newest features of Grails 2.0 using the interactive scripts and db console. In addition to building an application, existing samples will be reviewed as a source of good practices and plugins.
Some knowledge of Groovy is assumed but not required.
Software:
Unzip the Grails distribution, set a GRAILS_HOME variable to its location, and add the bin subdirectory to your path.
As an alternative installation mechanism, please consider GVM, located at http://gvmtool.net . That will allow you to switch Grails version with a single command. It works for Macs and Unix flavors, as well as Windows through Cygwin.
No IDE is required, but if you want to use one, consider Groovy and Grails Tool Suite. The current version is 3.3.0 and can be downloaded from http://grails.org/products/ggts. IntelliJ IDEA has Grails support in its Ultimate edition only. NetBeans also has Grails support.
Although Agile has proven to provide incredible benefits in software development and delivery, it is not foolproof, nor a “Silver Bullet.” Plenty of factors need to be considered before attempting this highly disciplined approach.
Learn from the mistakes other organizations have made and discover which pitfalls to avoid to ensure that your first attempt at applying an Agile approach will be met with a successful outcome. This hour-long web seminar will explore these areas and provide clear steps your team and organization should consider to provide a clear set of tools to maximize the opportunity for best results possible.
Today’s interconnected world requires that organizations rapidly deliver flexible-integrated solutions. The conventional approach is to integrate heterogeneous applications using web services but unfortunately that tends to tightly couple those applications. In this session we will explore several alternatives for achieving Enterprise Integration Agility.
Public Web APIs are increasing at an exponential rate resulting in an ever more connected web. This connected contagion is not just relegated to the domain of Web 2.0 but has infected the corporate world. In fact, companies are becoming more reliant on Software as a Service (SAAS) to provide key business functions.
Combating this contagion requires an approach that provides a type of insurance against constant change and lays the foundation for evergreen enterprise solutions. In this session we will explore three popular architectural styles including Message Oriented, Service Oriented, and Resource Oriented Architecture that are used to achieve Enterprise Integration Agility. In addition, I will provide examples of each architectural style using ActiveMQ/Camel, Mule ESB, and NetKernel.
Domain-Driven Design (DDD) promises to simplify enterprise application development and is gradually gaining traction as an alternative to traditional four-tier architectures originally popularized by J2EE. As the name implies, DDD is an architectural approach that strongly focuses on materializing the business domain in software. This session demonstrates first-hand how DDD can be implemented using Java EE via a project named Cargo Tracker.
Part of the Java EE Blue Prints, Cargo Tracker seamlessly maps concepts like bounded contexts, layered architectures, entities, value objects, aggregates, services, repositories and factories to realistic code examples. The Cargo Tracker project also embraces popular practices adopted by the DDD community such as Object Oriented Analysis, Domain Models, Test Driven Development, Agile Refactoring, Continuous Integration, Object Relational Mapping, Dependency Injection and Cross-Cutting Concerns, incorporating these concepts into a realistic Java EE application.
Domain-Driven Design (DDD) promises to simplify enterprise application development and is gradually gaining traction as an alternative to traditional four-tier architectures originally popularized by J2EE. As the name implies, DDD is an architectural approach that strongly focuses on materializing the business domain in software. This session demonstrates first-hand how DDD can be implemented using Java EE via a project named Cargo Tracker.
Part of the Java EE Blue Prints, Cargo Tracker seamlessly maps concepts like bounded contexts, layered architectures, entities, value objects, aggregates, services, repositories and factories to realistic code examples. The Cargo Tracker project also embraces popular practices adopted by the DDD community such as Object Oriented Analysis, Domain Models, Test Driven Development, Agile Refactoring, Continuous Integration, Object Relational Mapping, Dependency Injection and Cross-Cutting Concerns, incorporating these concepts into a realistic Java EE application.
Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging. We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.
In this workshop, we'll discuss the various tools that you can assemble into your own full fledged JavaScript development pipeline from code to deployment and more importantly, get them up and running on your machine.
Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging. We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.
In this workshop, we'll discuss the various tools that you can assemble into your own full fledged JavaScript development pipeline from code to deployment and more importantly, get them up and running on your machine.
For this workshop you should have:
If you are on a Windows machine, you may want to use Console2, PowerShell, Cygwin or Babun.
Before the workshop, take a minute to setup the code and the instructions somewhere on your laptop. The code is on GitHub:
https://github.com/ntschutta/bulletproof-js
The instructions are also on GitHub:
https://github.com/ntschutta/bulletproof-js-workshop
You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!
Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging. We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.
In this workshop, we'll discuss the various tools that you can assemble into your own full fledged JavaScript development pipeline from code to deployment and more importantly, get them up and running on your machine.
Back in the day, web developers had to rely on their wits and a plethora of alert statements - to say our toolkit was spartan would be an understatement. But with the increased importance of web front ends and the rise of JavaScript MVC frameworks, a modern web developer toolkit is finally emerging. We've evolved from text editors to full fledged IDE's with code completion and refactoring tools but our toolchain doesn't end there. With multiple testing libraries, mocking frameworks, test drivers and even code coverage tools, today's web developer gets to walk downhill on a sunny day.
In this workshop, we'll discuss the various tools that you can assemble into your own full fledged JavaScript development pipeline from code to deployment and more importantly, get them up and running on your machine.
For this workshop you should have:
If you are on a Windows machine, you may want to use Console2, PowerShell, Cygwin or Babun.
Before the workshop, take a minute to setup the code and the instructions somewhere on your laptop. The code is on GitHub:
https://github.com/ntschutta/bulletproof-js
The instructions are also on GitHub:
https://github.com/ntschutta/bulletproof-js-workshop
You can clone the repo from there or simply download a zip if you prefer. That's it! See you in Florida!
This two-session workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include hands-on exercises using Apache ActiveMQ and Camel.
Agenda
Environment Setup
Messaging Foundation
Network Topologies
Advanced Messaging
Download Prior to Workshop:
This two-session workshop will cover everything from messaging basics to advanced messaging techniques leveraging Enterprise Integration Patterns. In addition, the workshop will include hands-on exercises using Apache ActiveMQ and Camel.
Agenda
Environment Setup
Messaging Foundation
Network Topologies
Advanced Messaging
Download Prior to Workshop:
This multi-disciplinary session takes a deep dive into
the confluence of topics required to fully understand the intersection
of Continuous Delivery and architecture, including evolutionary
architecture and emergent design, with an emphasis on how
architectural decisions affect the ease in changing and evolving your
code, the role of metrics to understand code, how Domain Driven
Design's Bounded Context reifies in architecture, how to reduce
intra-component/service coupling, and other techniques.
Continuous Delivery is a process for automating the production
readiness of your application every time a change occurs – to code,
infrastructure, or configuration. In the Continuous Delivery world,
rather than hone skills at predicting the future via Big Design Up
Front, Continuous Delivery emphasizes techniques for understanding
and changing code with less cost during the process. Some architectures
and engineering practices yield better designs for this
environment. This multi-disciplinary session takes a deep dive into
the confluence of topics required to fully understand the intersection
of Continuous Delivery and architecture, including evolutionary
architecture and emergent design, with an emphasis on how
architectural decisions affect the ease in changing and evolving your
code, the role of metrics to understand code, how Domain Driven
Design's Bounded Context reifies in architecture, how to reduce
intra-component/service coupling, and other techniques.
In this session, we'll see how to build real Spring applications using Spring Boot. We'll also look under the covers to see what makes Spring Boot tick.
Spring offers a number of configuration options: XML configuration, Java configuration, and Groovy configuration to name a few. To some degree, component-scanning and autowiring help eliminate some explicit configuration. But in general most Spring applications require some essential “bootstrap” configuration to enable key functionality. What's the right way to build Spring applications when there are so many choices?
What if I told you that configuration was optional?
Spring Boot is an exciting new programming model for Spring that makes it extremely easy to create stand-alone, production-ready Spring applications. Rather than writing lots of code to satisfy the needs of a framework, Spring Boot helps you focus your coding efforts on your application. Spring Boot takes an opinionated approach to configuring Spring, making it possible to create Spring applications with little or, in some cases, no Spring configuration at all!
Technical Debt can creep up on a project very quickly and ultimately create a technical crisis. Sonar can help you see how far gone your project may be and if you are continuing to head toward a crisis.
In this workshop we will discuss how the simple act of making technical debt visible to the developer, team, manager and organization can have a positive affect on the reversal of technical debt.
We will look at how to measure & visualize the seven axes of code quality:
Architecture & Design
Comments
Complexity
Coding Rules
Duplications
Potential Bugs
Unit Tests
We will show how to visualize measures these seven axes of code quality. These measures can help identify where to focus our limited time and attention to make the biggest impact on technical debt.
Used appropriately these measures can drive powerful conversations on reversing the current negative trends in your technical debt.
Sonar has strong roots in measuring, visualizing, and reporting code quality in Java projects. We will quickly recap our seven axes of code quality from the “Reducing Technical Debt with Sonar” talk.
Using those same measures we will look at how you can customize Sonar to work with more heterogeneous environments. We will explore how to utilize the extensive plugin ecosystem to extend Sonar base
capabilities to examine and report on projects in various languages. We will explore how to integrate with a wide range of analysis, developer, and continuous integration tools to incorporate Sonar into
your existing processes to gain faster feedback, visibility and transparency across all of your projects.
Enough with the darn JavaScript frameworks already! There's nothing wrong with a judicious use of this ubiquitous programming language, but it's gotten a little out of hand. What if there were an evolvable future state of declarative and encapsulated user interface elements that was available today in most modern browsers?
There is! The Polymer Project is a young but impressive glimpse into where things should go.
It's goals are:
This talk will introduce you to:
Beyond our typing skills, physical prowess is rarely part of our job qualifications but recent studies prove exercise is a key to a healthy brain. While we don't need to train like an Olympic athlete we can't be the stereotypical sedentary heliophobic programmer and expect to excel at our jobs. In this talk, we'll discuss the implications of research connecting exercise and brain health. We'll look at ways to weave activity into your day, see how technology can help us “geek out on our workouts” and touch on how diet fits into the picture. The impact a mere 20 minute walk can have our our abilities can be astounding; don't worry, the Internet will still be there when you get back!
Beyond our typing skills, physical prowess is rarely part of our job qualifications but recent studies prove exercise is a key to a healthy brain. While we don't need to train like an Olympic athlete we can't be the stereotypical sedentary heliophobic programmer and expect to excel at our jobs. In this talk, we'll discuss the implications of research connecting exercise and brain health. We'll look at ways to weave activity into your day, see how technology can help us “geek out on our workouts” and touch on how diet fits into the picture. The impact a mere 20 minute walk can have our our abilities can be astounding; don't worry, the Internet will still be there when you get back!
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs.
In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done.
The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs.
In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done.
Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code.
In this presentation we will discuss the actor based concurrency and also the software transaction memory. We will then develop examples using AKKA and compare the power of these approaches in contrast to the traditional approach.
In this session, we’ll look at some of the options for storing application and user data, such as simple JSON and SQLite. We’ll discuss the details of deciding to use SQL or a NoSQL solution. We’ll look at how to architect a data-driven web / mobile app, strategies for server synchronization, and take a deep dive into working with datasets in JavaScript.
Working with data in Web browsers can be tricky - fortunately the IndexedDB standard has come forward to help developers organize and store data. On mobile platforms, Phonegap allows the use of both IndexedDB and SQLite. Titanium, and open-source native platform for mobile based on JavaScript, also has a host of options for storing application and user data. We'll look at utilizing IndexedDB in Web Browsers, Phonegap and Titanium. We'll also see how to leverage SQLite in Phonegap and Titanium. This is a code-heavy session and all the code will be in JavaScript.
JAX-RS 2 is the new standard Java API for RESTful Web services and a major leap forward in the features and use cases covered by the API. The purpose of this technical session is to elaborate on all the new features being introduced as part of this major API revision.
This session explores the new client API, concepts behind filters and interceptors API, and asynchronous processing support. Other new features it covers include data validation support and improved support for hypermedia and server-side content negotiation. The last part of the session also briefly outlines future plans and focus areas.
“Self-organizing team” may be the most over-used, mis-understood, vague, and mis-leading term of the decade. So what is a self-organizing team? How are self-organizing teams different from other teams? How can managers and team members get the self-organizing mojo going? What are the challenges that self-organizing teams face?
In this workshop, we'll explore all these questions and get beyond the buzzword.
Agile methods depend on effective cross-functional teams. We’ve heard many Agile success stories…at the team level. But what happens when a product can’t be delivered by one team? What do you do when the “team” that’s needed to work on a particular product is 20 people? Or 20 teams? One response is to create a coordinating role, decompose work, or add layers of hierarchy. Those solutions introduce overhead and often slow down decision making. There are other options to link teams, and ensure communication and integration across many teams. There are no simple answers. But there are design principles for defining workable arrangements when the product is bigger than a handful of agile teams.
In this talk, I'll cover principles and practices and explain how they work together to address coordination, integration, and technical integrity.
Language shapes thought, and thought shapes action. People talk about installing change, driving change, making change happen. When change doesn't happen as fast as they'd like, the people who want change talk about resistance, and try to kindle a sense of urgency.
What if the language we use makes it harder to bring about the differences we want to see?
I was educated to be logical, objective, “stick to the facts” and rely on reason. But that’s not the only way our brains work. Metaphors pervade our lives and thinking–so much so that we often don’t notice them. Metaphors “shape what we think,” what we see, and therefore affect our choices and options.
Consider the title “Agile Evangelist.” Evangelists are people who are imbued with The Truth–and want to convince everyone else of it. Sometimes evangelists succeed–through persuasion or harsher means. Would you welcome an evangel, come to tell you how wrong you’ve been?
In this talk I'll explore the words we use when we talk about change–and how they may get in our way. I'll look at the nature of change in a complex environment. And we'll try on some different words that might open different possibilities.
Managers want teams to be empowered….but don’t want to give up decision making authority. Teams want empowerment, but may not know how to act on the power they already have. Executives want to drive engagement and action, but see only half-hearted compliance.
In all of these examples, power dynamics are at play. Words won’t matter until people acknowledge power. Once people acknowledge the fact of power, it’s possible to look at how it is affecting people and actions. When we see power, we can see how power can make it harder–not easier–to achieve desired results.
In this session, we’ll explore different definitions of power, where power comes from, and how people respond to power.
You will learn:
Two definitions of power, and how each affects leadership
Seven sources of power
How the use of power impacts peoples core concerns
How to boost creativity and productivity by addressing sources of power and core concerns
In this session we will look to see how we can refactor our learning - what tools, and methodologies can we use to help us learn quicker and better - how we can create a store that gives us quick access to information when we really need it.
We all work in an industry in which not only do the tools that we use change ever few years, but one in which we have to shift the very paradigms these tools are built on! Even the most trivial of projects entails tens of different toolkits, frameworks, and languages coming together, and somehow we need to know how to leverage each one. How does one keep up? Despite all our years in schools, and our in-born nature to learn, we often are never taught how to learn. How can we learn faster, and retain even more?
In this session we will take a look at various tools and techniques available to us and see how we can make our learning effective.
Robert Martin assembled the SOLID family of principles to provide a useful guide to help us create object-oriented software designs that were resilient in the face of change. In recent years, the need to write highly-concurrent software in order to leverage increasingly ubiquitous multicore architectures, as well as general interest in more effectively controlling complexity in large software designs, has driven a renewed interest in the functional programming paradigm. Given the apparent similarity in their goals, “What is the intersection of SOLID with functional programming?” is a natural question to ask.
In this talk, we'll explore this intersection. We'll begin with a tour of the evolutionary patterns associated with enterprise software and programming paradigms, as well as take a look at the ongoing quest for best practices, the goal being to elucidate the motivation for examining this intersection of SOLID and functional programming. We'll then walk through each of the SOLID principles, examining them in their original object-oriented context, and looking at example problems and solutions using the Java language. Then for each principle, we'll examine its possible intersection with the functional programming paradigm, and explore the same problems and solutions using the Clojure language. We'll close by examining the transcendent qualities of the SOLID principles and how they can make any design simpler, regardless of the programming paradigm employed.
I have yet to meet a software engineer who jumps out his or her chair in excitement at the thought of fixing one of his or her bugs let alone other people's. It can be one frustrating of a task, and sometimes “twice as hard as writing a program in the first place” in the words of Brian Kernighan who needs no introduction. In this session, you will be exposed to a more systematic and rigorous approach to debugging, and will be introduced to a number of techniques and methods inspired by modern studies in cognitive psychology, the philosophy of science, and other fields. A survey of the available tooling will also be conducted.
Come to the session to join the coalition forces on the war on bugs. You never know, you might end up changing your mind about your favorite part of being a software engineer after all.
After over 10 years and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?
In this 2-part workshop, you'll get a hands-on feel for the current best approaches in Spring development. We'll see how to take advantage of some of the latest tricks Spring has to offer to build an application with minimal boilerplate and none of the cruft that is often carried around in Spring applications.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
After over 10 years and several significant releases, Spring has gone a long way from challenging the then-current Java standards to becoming the de facto enterprise standard itself. Although the Spring programming model continues to evolve, it still maintains backward compatibility with many of its earlier features and paradigms. Consequently, there's often more than one way to do anything in Spring. How do you know which way is the right way?
In this 2-part workshop, you'll get a hands-on feel for the current best approaches in Spring development. We'll see how to take advantage of some of the latest tricks Spring has to offer to build an application with minimal boilerplate and none of the cruft that is often carried around in Spring applications.
For maximum benefit, please come to this workshop with a laptop prepared. We won't allot any time for setting up your environment during the workshop.
Here's what you'll need: A laptop setup with…
In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.
With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.
In this 2-part workshop, we'll dig in with a hands-on exploration of a variety of data stores, including Redis, MongoDB, Neo4j, and traditional RDBMS. In doing so, you'll experience first-hand how Spring Data simplifies working with these data stores.
Prerequisites:
For maximum benefit, please come to this workshop with a laptop setup and ready. We will not allot any time for environment setup during the workshop.
What you'll need: A laptop setup with:
In recent years, there has been a renewed interest in how data is stored. Although RDBMS has long been treated as a one-size-fits-all solution for data storage, a new breed of datastores has arrived to offer a best-fit solution. Key-value stores, column stores, document stores, graph databases, as well as the traditional relational database are options to consider.
With these new data storage options come new and different ways of interacting with data. Even though all of these data storage options offer Java APIs, they are widely different from each other and the learning curve can be quite steep. Even if you understand the concepts and benefits of each database type, there's still the huge barrier of understanding how to work with each database's individual API.
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose. In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA.
In this 2-part workshop, we'll dig in with a hands-on exploration of a variety of data stores, including Redis, MongoDB, Neo4j, and traditional RDBMS. In doing so, you'll experience first-hand how Spring Data simplifies working with these data stores.
Prerequisites:
For maximum benefit, please come to this workshop with a laptop setup and ready. We will not allot any time for environment setup during the workshop.
What you'll need: A laptop setup with:
If you're like most developers, you can get through most of your projects with just lists and maps. Then every once in a while you read a blog post about a mind-blowing problems that can only be solved efficiently because of a data structure you've never heard of, and you wonder where long years of computer science education really got you. Or better yet, maybe you never
The world is full of interesting data structures like Merkel Trees, Bloom Filters, k-d Trees, Ropes, Tries, and just plain old heaps and graphs. Come to this talk for a fun walk through the composition, purpose, and implementation of a few of the data structures you think you need to know–and might actually be able to use!
Gradle is a compelling new build tool that incorporates the lessons learned from a decade of Ant and Maven. More than just a compromise between declarative and imperative build formats, or between convention and configuration, Gradle is a sophisticated software development platform that simple builds easy and complex, highly automated continuous software delivery pipelines possible to build. Using its extensible APIs and expressive DSL, you're equipped to build your next build.
Bring your laptop to this session for the following:
Gradle is a compelling new build tool that incorporates the lessons learned from a decade of Ant and Maven. More than just a compromise between declarative and imperative build formats, or between convention and configuration, Gradle is a sophisticated software development platform that simple builds easy and complex, highly automated continuous software delivery pipelines possible to build. Using its extensible APIs and expressive DSL, you're equipped to build your next build.
Bring your laptop to this session for the following:
The sea change in HTML 5 is likely to shift the pendulum away from today's thin-client based server-side web frameworks like Struts 2 and JSF to JavaScript powered next generation rich clients. With strong support for REST, WebSocket and JSON, Java EE 7 is well positioned to adapt to this change.
In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript rich client technologies like AngularJS, Backbone, Knockout and Ember to utilize the core strengths of Java EE using JAX-RS, JSR 356/WebSocket, JSON-P, CDI and Bean Validation.
This session explores how NoSQL solutions like MongoDB, Cassandra, Neo4j, HBase and CouchDB can be used in a Java EE application with or without a JPA centric facade.
Although the primary focus is on EclipseLink NoSQL, we will also cover Hibernate OGM, EasyCassandra, Morphia, etc as well as seeing how NoSQL can be used natively via basic CDI injection.
Introduction to Go
Introduction to Go… language of the cloud
In the words of John Gage, “The network is the computer”. At the heart of everything we do is a complex system of infrastructure from which we are often abstracted. For general application development this abstraction provides the convenience of simplifying our efforts. With a growing number of mobil applications with intermittent connectivity and higher latency, and with increased hostility on the network from a security standpoint, there is great value in pulling back the curtain and understanding the details of this computer.
This session will start with the underlying understanding of networking at a low level. At this level we will discuss, IP, MAC, ARP, DNS and DHCP. As we walk up an abstraction level, we discuss sockets, NAT, gateways and firewalls along with the use of TCP and UDP. Spending some time at this layer can make network developers more productive, as we look at tools which help us answer the question, “who owns this port?“, “where is this packet going?” and “What is my latency and why?“.
The session will end with a little fun looking at wifi, where will we sniff, snort, crack:) From a security stand point we will look at the challenges of wifi and how it has become the weakest component on the net.
This session is extremely fast-pace. The attendees will come away with a more enhanced understanding of the this thing we call the internet. It will include through discussion or demonstration tools such as tcproute, tcpdump, nemesis, nmap, tcpmon and wireshark.
Learn how Kanban can lead your team or organization to a sane approach to dealing with too much work while addressing problems quickly in a collaborative environment that drives continuous improvement.
Kanban can be used as a lightweight process to manage the process of a small development team or production support team. It is also used as the engine of a large-scale Agile Enterprises. We will explore the simplicity of Kanban and discipline required to adhere to the basic principles and practices of Kanban. Learn how Kanban can lead your team or organization to a sane approach to dealing with too much work while addressing problems quickly in a collaborative environment that drives continuous improvement.
Java 8 sports the latest and greatest features of the JVM platform, and introduces new concepts
of asynchronous programming and Lambdas, amongst other syntactic improvements to the
language. Many of the language's upcoming features are concepts and constructs that Groovy
programmers have been familiar with for years.
This talk will discuss the upcoming features of Java 8, their practical implementations, and will discuss the new features in terms that developers familiar with Groovy can understand and immediately relate to.
Ratpack is an asynchronous web framework for the JVM that was inspired by the simplistic
nature of Ruby's Sinatra framework. Written in Java, optimized for Groovy and Java 8, Ratpack
sports a high throughput, simplistic interface for rapid development of rich, real-time web
applications.
This talk will discuss the methodologies that support the framework's core
development, and will showcase some of the rapid development and real-time web features that
make up a Ratpack application's architecture.
We want you to leave UberConf with a working cloud account, including supporting infrastructure that Amazon DOESN’T provide but that will make your cloud life way more manageable! Once your account is bootstrapped with Asgard and Aminator, we’ll be baking some of the myriad of @NetflixOSS apps. This workshop will be meaningful for anyone getting started with or currently using AWS.
This workshop provides a detailed hands-on experience to bring up the necessary components to run the @NetflixOSS stack. This includes priming your Amazon account (IAM Profiles, Security Groups, etc) and setting up Asgard and Aminator. Together they can be used, time permitting, to launch many more @NetflixOSS services, like Edda, Eureka and Ice.
To make best use of the time please bring a laptop, installed with JDK 7, an SSH client, Git, and Python (2.6 or higher with pip). Alternatively you can use a provided VirtualBox image. Also please have your AWS account created before arriving.
We want you to leave UberConf with a working cloud account, including supporting infrastructure that Amazon DOESN’T provide but that will make your cloud life way more manageable! Once your account is bootstrapped with Asgard and Aminator, we’ll be baking some of the myriad of @NetflixOSS apps. This workshop will be meaningful for anyone getting started with or currently using AWS.
This workshop provides a detailed hands-on experience to bring up the necessary components to run the @NetflixOSS stack. This includes priming your Amazon account (IAM Profiles, Security Groups, etc) and setting up Asgard and Aminator. Together they can be used, time permitting, to launch many more @NetflixOSS services, like Edda, Eureka and Ice.
To make best use of the time please bring a laptop, installed with JDK 7, an SSH client, Git, and Python (2.6 or higher with pip). Alternatively you can use a provided VirtualBox image. Also please have your AWS account created before arriving.
An overview of the Continuous Delivery pipelines at Netflix. Using a combination of open source
software, AWS, and custom tools Netflix deploys changes to production multiple times a day.
The talk will touch on Netflix culture, Ant and Gradle to build, Jenkins and the Job DSL plugin to
automate on push to git, Aminator to bake images, Asgard to deploy to AWS, the Simian Army to
build resiliency, and other tools to help the CD pipelines and monitoring of running services.
In recent years, the cloud has gone from Larry Ellison's “Maybe I'm an idiot, but I have no idea what anyone is talking about,” to Microsoft's “TO THE CLOUD!” to a central part of many companies IT strategy. At the same time, the way that we consume the cloud has continued to evolve. Many of today's cloud efforts revolve around utilization of various “infrastructure as code” products (e.g. Puppet and Chef) and homegrown automation to create deployment pipelines. When we start at this level, we often end up reinventing many of the same wheels as we climb the abstraction ladder.
Platform as a Service (PaaS) offerings are positioned to allow developers (and operators) to start climbing the abstraction ladder from a higher rung, shifting the model from machine-centric deployment to application-centric deployment. This session will focus on life as an application developer using Cloud Foundry as a PaaS, with demos using Pivotal's Hosted CF at http://run.pivotal.io.
We'll cover the following topics:
All parts will require:
Needless to say you'll need a laptop! For best experience, a Mac or Linux environment is ideal (it's technically possible to get most of this working on Windows, but it's VERY DIFFICULT). Also, you'll need at least 8 GB of RAM to support running Cloud Foundry locally without too much of a performance hit.
Part one of the workshop will require a free account on Pivotal Web Services. You can create a 60-day trial with no credit card at https://run.pivotal.io.
Parts two and four will require the use of BOSH Lite. More instructions will be provided at the conference. But, to ease setup, please install the following dependencies (in addition to those for part one!):
An alternative to setting up BOSH Lite if you have trouble with the environment (or you are stuck on Windows!) is to use TryCF. This only requires an AWS account (obviously a credit card required) and an email address, and eliminates the need for this entire dependency list. The estimated cost is 28 cents per hour, so you won't run up a huge bill!
Part Three will require the use of a FREE Cloudbees account. Create one at https://grandcentral.cloudbees.com. Once you're set up, click on “Get Started with Builds” to provision your Jenkins instance. We'll complete the remainder of the setup during the lab, but it's important to get the Jenkins instance provisioned in advance so that you don't lose 10 minutes of workshop time!
It will also require the use of a FREE TRIAL account of Artifactory Online from JFrog. You can obtain an account at https://www.jfrog.com/registration/registration.html. This one is a bit quicker, but you still should try to create it before the workshop.
This session will focus on how you can build your very own Cloud Foundry private PaaS running in your own data center or on AWS or even on OpenStack on your own Mac mini. You will learn how the Cloud Foundry BOSH tool constructs a full Cloud Foundry instance from a bare bones virtual machine and continues to coordinate and manage the entire PaaS cloud once it is operational.
If you want the convenience of developing against your own private custom PaaS within your company, then this session will give you all the steps you need to get started.
All parts will require:
Needless to say you'll need a laptop! For best experience, a Mac or Linux environment is ideal (it's technically possible to get most of this working on Windows, but it's VERY DIFFICULT). Also, you'll need at least 8 GB of RAM to support running Cloud Foundry locally without too much of a performance hit.
Part one of the workshop will require a free account on Pivotal Web Services. You can create a 60-day trial with no credit card at https://run.pivotal.io.
Parts two and four will require the use of BOSH Lite. More instructions will be provided at the conference. But, to ease setup, please install the following dependencies (in addition to those for part one!):
Part Three will require the use of a FREE Cloudbees account. Create one at https://grandcentral.cloudbees.com. Once you're set up, click on “Get Started with Builds” to provision your Jenkins instance. We'll complete the remainder of the setup during the lab, but it's important to get the Jenkins instance provisioned in advance so that you don't lose 10 minutes of workshop time!
It will also require the use of a FREE TRIAL account of Artifactory Online from JFrog. You can obtain an account at https://www.jfrog.com/registration/registration.html. This one is a bit quicker, but you still should try to create it before the workshop.
One of the great features of a PaaS platform like Cloud Foundry is the simplicity that it brings to the deployment. This simplicity aids us in creating powerful continuous delivery pipelines, which allow us to prove our ability to deliver working software at any time. In this session will examine specifically how to leverage Cloud Foundry as part of such a pipeline, looking at tools and techniques such as:
One of the most powerful features of Cloud Foundry is its extensibility. Cloud Foundry has two primary extension points:
1) Buildpacks - by following the buildpack model first popularized by Heroku, the Cloud Foundry platform was designed to be application runtime agnostic, and the platform provides the same services to an application regardless of it being implemented using Java and Spring, Ruby and Rails, JavaScript and Node.js, or any other language/framework combination. Cloud Foundry users can easily implement their own buildpacks by following a specification that exposes three basic scripting endpoints.
2) Services - the Cloud Foundry platform exposes to developers a consistent user experience for external service interaction through the idea of “creating” and “binding” services. This is easiest to see through the idea of first “creating” a database and user role within an existing PostgreSQL or MySQL cluster and then “binding” the proper credentials to my application's environment so that I can connect to and consume that database instance. This is made possible by the Cloud Foundry service broker API, a set of REST endpoints that are consumed by the Cloud Foundry Cloud Controller to orchestrate the necessary steps for a given service.
In this session we'll learn how to:
Finally, the Java 8 Date Time API will be in our grasps and now we will celebrate gleefully in the streets! ISO8601 and UTC standards! Immutability! Time to set attention to stun as this presentation will cover all the goods about the new Date/Time API that makes Java programming safe.
Finally, the Java 8 Date Time API will be in our grasps and now we will celebrate gleefully in the streets! ISO8601 and UTC standards! Immutability! Time to set attention to stun as this presentation will cover all the goods about the new Date/Time API in Java 8 that will finally make our code safer than before.
We cover in 90 Minutes:
ISO 8601 & UTC
Instants
Periods
Durations
Parsing
Time Zone Manipulations and Updates
Conversion from Old Java Date Times
Whatever else we can cram into the presentation
This will interactive for the most part with few slides. Bring on your questions.
Presentation on Akka. A set various tools to write concurrent, fault-tolerant applications using immutable data, asyncronous message passing using local and remote actors, software transactional memory, and supervised systems.
Akka is a middleware, but it is not your 1990s middleware. Akka is a set of various tools to write concurrent, fault-tolerant applications using immutable data, asyncronous message passing using local and remote actors, software transactional memory, and supervised systems. Akka is also part of the Typesafe stack, a stack that include the Play web framework and the Scala programming language. This Akka presentation will cover both Scala and Java style usage of Akka and give the audience a 30k view of how it comes together. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.
Scala is known for both its clarity in some cases, and its obscurity in others. Well, this presentation sticks with the obscurity. We will cover abstract types, the Predef, implicit conversions, creating infix types, singleton types, type variance, type bounds, type variance, partially applied functions vs. partial functions, type projections, and overcoming type erasure using Manifests.
This presentation is geared in at the programmer level and not at a scientific level, with no type theory or calculus. Basic knowledge of Scala is preferrable, though not required. Asking tough questions is mandatory.
Most introductory programming books include a chapter on testing, seemingly as an afterthought. For the test-driven developer, that's a little too late. Some programmers approach a new programming language with a few test-cases to understand a concept. Others thrive under fire and want to hit the ground running in a new programming language by creating an application.
It just so happens that testing code in Scala is a great way to learn Scala, but also really good at testing Java code. This presentation started a book on how to use some of the greatest tools that you can use to test. This presentation will cover ScalaTest, Specs2, ScalaMock and ScalaCheck all in a triggered execution environment using SBT. For those that do not wish to use SBT, we will cover other options as well. Using these tools you may never want to use those plain jane java testing frameworks ever again. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.
The presentation will cover an introduction on the framework by creating a basic web application in both Java and Scala to get you started.
The Play Framework is a lightweight and stateless web framework that is part of the TypeSafe stack, a stack which includes Akka middleware and the Scala programming language. The presentation will cover an introduction on the framework by creating a basic web application in both Java and Scala to get you started. The presentation will also cover javascript library integration and explain the philosophy behind the framework and give an honest analysis on the advantages and disadvantages of the framework. While this presentation is not interactive, all demos will be available on github for those that want to “play” along with their laptops.
Reactive programming is gaining some good attention recently. If you wonder what this is all about come to this presentation for a practical introduction.
Reactive Programming, what is it, what does it solve, how to use it today?
In this session, we will take a look at Angular - a new MVC framework by Google. We will discuss some of the terminology that Angular offers, and see how we can use that to develop highly interactive, dynamic web applications. See “Detail” for a list of topics I cover and the Github repo URL
This is an intro-level talk we will take a look at Angular and developing rich web applications. Angular embraces HTML and CSS, allowing you to extend HTML towards your application, and uses plain JavaScript which makes your code easy to reuse, and test.
Note: This is an intro level talk. It is targeted towards developers who are curious about Angular and want to learn about the fundamental features and concepts in Angular.
Topics Covered -
ng-appng-init and the evaluation {{ }} directive$rootScopeng-model$scope)ng-repeatng-form, form validation and submission in AngularJS$httpGitHub URL - https://github.com/looselytyped/angudone-backend/tree/solutions
In this session we will look at some JavaScript patterns, and how you can use them within your code.
No longer can you think of JavaScript as a kiddie-scripting language. JavaScript has now been promoted to a first-class citizen within your application - and with this, comes the need to think of better abstractions, code re-use - even thinking of establishing a common vocabulary to discuss approaches to writing better, cleaner and ultimately more maintainable JavaScript code.
In this workshop, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.
In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.
Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.
Please bring your laptop and perform the following steps before arriving for the workshop:
In this workshop, we'll look at Cujo.js, an “unframework” that provides dependency injection that takes Javascript's unique needs into consideration to create loosely-coupled code. We'll also see how, although Cujo.js isn't strictly a UI framework, elements of Cujo.js can be brought together to elegantly build client-side UIs.
In modern applications, Javascript is increasingly prevalent both on the client-side and to some degree on the server-side. As we continue to crank out more Javascript code, we're finding that many of the same hard-lessons we learned in writing decoupled Java code are equally desirable in Javascript code. Without the benefit of dependency injection and AOP, both Java and Javascript code can quickly become an unnavigable and untestable mess.
Where frameworks like Spring have helped us gain control over our Java code, Cujo.js similarly aims to give our Javascript code more structure and testability.
Please bring your laptop and perform the following steps before arriving for the workshop:
Early releases of Java performed poorly, but those issues largely disappeared long ago with the introduction of HotSpot. However, much of the performance advice for Java persists through hearsay from those early days.
In this talk, we'll forget the hearsay and take an objective look using benchmarking and profiling tools to find out which optimizations matter today and just as importantly those that don't.
HotSpot promises to do wonders for us by Just-in-Time (JIT) compiling the “right” code for us, but how does it makes those decisions? And, perhaps more importantly, what happens when it's wrong?
In this talk, you'll learn through real code examples just how the JVM decides to compile your code, deoptimize your code, and stop-the-world for a GC.
This 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 dynamic language competitors like Scala, Ruby, and Clojure.
This presentation focuses on the following topics: how to make Predicates and Functions; how to use new collection constructs that make life easier, including MultiMap, BiMaps, and MultiSets; how to set up and use Guava preconditions; and how to create truly immutable collections, and more. All of this is done with Java.
Find yourself overwhelmed with hundreds of to-dos? Is your hard-drive littered with dozens of killer ideas that you started with enthusiasm and then just fizzled away? Do you feel like you are moving as fast as can but only getting to the wrong place quicker? Well perhaps this session will help.
There are various techniques and strategies available to us today that aim to help with exactly this conundrum - from Getting Things Done ™ to Personal Kanban. Unfortunately it is often easy to be extremely productive using these systems, but not very effective. After all, it's not about getting things done, but getting the RIGHT things done. In this talk we will discuss not only how to get things done, but also attempt to figure out what it is you actually need to be doing.
In this session, I will attempt to show you how you can leverage various strategies to be more effective, knock to-dos out and have fun while doing it. If time permits we will close with an overview of the tools that are available to you, and how you can use these to become a to-do list ninja :)
Most of us don't want to go back to the days of malloc and free, but the garbage collector isn't always our friend.
In this presentation, you'll learn about the different garbage collection strategies used in JVMs, how to monitor garbage collection, analyze memory dumps, and why you might want to use one collection strategy instead of another.
Groovy isn't designed to replace Java – it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.
Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.
Groovy has a very easy learning curve for Java developers, so many people become Groovy users without realizing all it can do. This presentation will examine features of Groovy that can make your life easier once you're past the initial adoption stage.
Examples will include closure coercion, mixins, simple runtime metaprogramming, operator overloading, drop and take, a tour through some of the overlooked methods in the Groovy JDK, and more.
Statistics is hot lately, due in part to the easy availability of large data sets and the successes of people like Nate Silver. These aren't your father's statistics, however. A quiet revolution has swept through the field, shifting it from traditional frequentist methods toward a more Bayesian approach. This talk will discuss Bayes' Theorem and show you how to do simple, back-of-the-envelope calculations to apply it to a wide variety of problems.
In addition, we'll also talk about common errors non-experts make when dealing with statistical conclusions, ranging from small sample size issues to the use of arbitrary endpoints to the problem of overfitting and more.
looking to improve your design. Maybe you're new to REST on your project. In any case, you have questions:
In this presentation, we’ll cover:
RESTful API Design Best Practices
Documenting Your RESTful API
Available RESTful Web Service Guidelines
Well-Designed RESTful APIs
RESTful API Repositories
Service Architecture
Service Design Patterns
REST Frameworks
Example Code
We will look at a single business problem to design a RESTful Web Service. Along the way, we'll walk through several well-known RESTful Web Service APIs and show some examples with Spring MVC. Attendees will gain a solid foundation in RESTful Web Service design.
JSON is more than just a simple replacement for XML when you make an AJAX call. JSON is becoming the backbone of any serious data interchange over the Internet. All modern languages have excellent JSON API support. There are emerging standards and best practices that can be used to harness the energy and enthusiasm around JSON to build truly elegant, useful, and efficient applications. You’re already using JSON, and you may be thinking:
In this presentation, we’ll cover:
JSON Overview
The JSON Ecosystem
Attendees will learn the basics of JSON and how to leverage this exciting technology in new ways to enhance their RESTful architecture and development efforts.
There are these two young fish swimming along and they happen to meet an older fish swimming the other way, who nods at them and says “Morning, boys. How's the water?” And the two young fish swim on for a bit, and then eventually one of them looks over at the other and goes “What the hell is water?“
David Foster Wallace, from This is Water
A fish is swimming along, having some breakfast, when suddenly he's snatched out of his world by his food, abruptly ejected into a bright world where it's hard to breathe, landing on the bottom of a boat, where strange alien creatures make strange sounds. Overhead, he sees an airplane flying at 500 mph. Suddenly, one of the creatures picks him up, removes the hook, and, just as suddenly, he's back home. Yet, when he regales his friends with this tale, no one can believe such a strange world could exist.
This keynote describes the water you swim in but cannot see anymore, like relational databases and application servers. And, it jerks you out of this water (briefly) to describe a strange, fantastical world with things like immutable database servers and phoenix machines. You may have trouble getting your friends who didn't attend to understand.
WildFly 8 (nee JBoss Application Server) is Red Hat's open source Java EE 7 compliant application server. It contains robust implementations of WebSocket, Batch, JSON, Concurrency, JMS2, JAX-RS 2, CDI 1.1, and all Java EE 7 technologies. A new cutting-edge web server, Undertow, is designed for maximum throughput and scalability, including environments with over a million connections. The number of
ports is reduced used by multiplexing protocols over HTTP using HTTP Upgrade.
Role Based Access Control support organizations with separated management responsibilities and restrictions. Roles represent different sets of permissions such as runtime operation execution,
configuration areas that can read or written, and the ability to audit changes and manage users. In addition a new restricted audit log can be enabled including the ability to offload to a secure syslog server.
WildFly also provides a “core” distribution that is ideal for framework authors that want to build their own application runtime using the powerful WildFly 8 architecture.
NetBeans, IntelliJ, and Eclipse allow WildFly to be used for development, deployment, and debugging.
The Java EE 7 platform focuses on Boosting Productivity and Embracing HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints. JMS 2 has undergone a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency Utilities are now added to make the platform richer. A new API to build WebSocket driven applications is added. JSON parsing and generation is now included in the platform itself. JavaServer Faces has added
support for HTML5. There are several other improvements in this latest version of the platform. Together these APIs will allow you to be more productive by simplifying enterprise development.
This hands-on lab will provide a comprehensive introduction to the updated Java EE 7 platform using WildFly. The attendees will learn the design patterns of building an application using Java EE 7.
Please bring a laptop, download and install the following software for the lab:
The Java EE 7 platform focuses on Boosting Productivity and Embracing HTML5. JAX-RS 2 adds a new Client API to invoke the RESTful endpoints. JMS 2 has undergone a complete overhaul to align with improvements in the Java language. Long awaited Batch Processing API and Concurrency Utilities are now added to make the platform richer. A new API to build WebSocket driven applications is added. JSON parsing and generation is now included in the platform itself. JavaServer Faces has added
support for HTML5. There are several other improvements in this latest version of the platform. Together these APIs will allow you to be more productive by simplifying enterprise development.
This hands-on lab will provide a comprehensive introduction to the updated Java EE 7 platform using WildFly. The attendees will learn the design patterns of building an application using Java EE 7.
Please bring a laptop, download and install the following software for the lab:
Spock Intro Workshop - 2 sessions hands on (basics and mocking)
Spock Intro Workshop - 2 sessions hands on (basics and mocking)
Spock Intro Workshop - 2 sessions hands on (basics and mocking)
Spock Intro Workshop - 2 sessions hands on (basics and mocking)
For decades object-oriented programming has been sold (perhaps over sold) as the logical programming paradigm which provides “the way” to software reuse and reductions in the cost of software maintenance as if it comes for free with the simple selection of the an OO language. Even with the renewed interests in functional languages, the majority of development shops are predominately using object-oriented languages such as Java, C#, and Ruby. So most likely you are using an OO language… How is that reuse thing going? Is your organization realizing all the promises? Even as a former Rational Instructor of OOAD and a long time practitioner, I find great value in returning to the basics. This session is a return to object-oriented basics.
This session is intended to balance the often-touted theoretical object-oriented practices with lessons from the real world. The session will start with a review of some of the basics regarding abstractions and encapsulation. Although simple concepts, we will push the boundary of how these techniques are applied. We will discuss the difference between analysis and design and how that is reflected in our code. We will also look at the limitations of Java the language as outlined in Josh Block’s book “Effective Java”. The session will go past the basics of object-oriented principles and into what our true goals of development really are.
JavaScript has regained quite a bit of popularity, not just on the client side, but also on the server side.
In this presentation we will take a look at serverside JavaScript and explore Nashorn's capabilities and strengths.
Java is statically typed, but often there are debates about how the typing gets in our ways. Haskell has largely been credited for its static typing and for enforcing the functional programming paradigm. Learning about Haskell can help us program in Java better and even borrow some nice pattern of programming.
In this presentation we will learn about some of the fundamentals of Haskell and also take a look at using Haskell on the JVM.
What do you need to know about combinatorics, number theory, and the underpinnings of public key cryptography? Well, maybe more than you think!
In this talk, we'll explore the branch of mathematics that deals with separate, countable things. Most of the math we learn in school deals with real-valued quantities like mass, length, and time. However, much of the work of the software developer deals with counting, combinations, numbers, graphs, and logical statements: the purview of discrete mathematics. Join us for this brief exploration of an often-overlooked but eminently practical area of mathematics.
What do you do when your data is not only big, but also needs to be fast? Apache Cassandra is a scalable, fault-tolerant database that has found its way into more than 25% of the Fortune 100 and continues to enjoy significant adoption in the marketplace.
In this workshop, we’ll explore Cassandra’s internals, its flexible data model, its SQL-like query language, some deployment scenarios, and some common language bindings. You’ll leave ready to begin exploring Cassandra on your own.
Laptop that can run VMware or VirtualBox. Please have one or the other installed before the conference. About 20GB free disk space and 8GB total RAM usually work best.
What do you do when your data is not only big, but also needs to be fast? Apache Cassandra is a scalable, fault-tolerant database that has found its way into more than 25% of the Fortune 100 and continues to enjoy significant adoption in the marketplace.
In this workshop, we’ll explore Cassandra’s internals, its flexible data model, its SQL-like query language, some deployment scenarios, and some common language bindings. You’ll leave ready to begin exploring Cassandra on your own.
Laptop that can run VMware or VirtualBox. Please have one or the other installed before the conference. About 20GB free disk space and 8GB total RAM usually work best.
The net has cracks and crackers are among us. With all the news of security failures, it can be a challenge to know what is FUD and what is really at risk and to what extent. This session isn’t about hacking an application together nor is it about coding a solution. It is about looking at the network and network infrastructure and understanding some of its weaknesses. This workshop is a 50% mix of lecture / discussion and hands on attacking in order to best understand the challenges.
The labs will require the use of:
We will have ISO installations of BackTrack 5 for you to install on your VM. It is best if you have this pre-installed, it can be downloaded at http://www.backtrack-linux.org/ . In order to run backtrack, you will want to install this to a virtual machine, if this is new to you, pick up virtualbox or vmware.
The wifi adaptor needed is an Alfa AWUS036H or Alfa AWUS036NHA. You will need 1 of these external adaptors. There are ~ $30 at amazon.
Through the labs we will:
The net has cracks and crackers are among us. With all the news of security failures, it can be a challenge to know what is FUD and what is really at risk and to what extent. This session isn’t about hacking an application together nor is it about coding a solution. It is about looking at the network and network infrastructure and understanding some of its weaknesses. This workshop is a 50% mix of lecture / discussion and hands on attacking in order to best understand the challenges.
The labs will require the use of:
We will have ISO installations of BackTrack 5 for you to install on your VM. It is best if you have this pre-installed, it can be downloaded at http://www.backtrack-linux.org/ . In order to run backtrack, you will want to install this to a virtual machine, if this is new to you, pick up virtualbox or vmware.
The wifi adaptor needed is an Alfa AWUS036H or Alfa AWUS036NHA. You will need 1 of these external adaptors. There are ~ $30 at amazon.
Through the labs we will:
For much of the last two years I've delivered a two-part series at NFJS shows entitled “Effective Java Reloaded.” For all pracical purposes, it is an ala carte style rehash of the book Effective Java, written by Josh Bloch. One of my favorite parts of the discussion is of Item #15, which tells us to “Minimize Mutability.” If we turn this inside out, we're actually saying that we want to MAXIMIZE IMMUTABILITY. When we do this, we reap many benefits, such as code that is easier to reason about and that is inherently thread-safe. This can carry us a long way in the direction of program correctness and decreased complexity. However, when we start to program with immutability, several major questions arise.
First, the necessity of using a separate object for each distinct value, never reusing, or “mutating” an object, can quickly cause performance concerns. These concerns are amplified when we're talking about large collections such as lists and maps. These problems are largely solved by what we call “persistent data structures.” Persistent data structures are collections from which we create new values, not by copying the entire data structure and apply changes, but by creating a new structure which contains our changes but points at the previous structure for those elements which have not changed. This allows us to work with data structures in a very performant way with respect to time and resource consumption. We'll examine persistent data structures, their associated algorithms, and implementations on the JVM such as those found in the TotallyLazy library.
Second, because all of an immutable object's state must be provided at the time of construction, the construction of large objects can become very tedious and error prone. We'll examine how the Builder pattern can be applied to ease the construction of large objects, and we'll examine Builder implementations in Java and Groovy.
Third, we run into problems when we start to use frameworks that expect us to program in a mutable style. A prime example is Hibernate, which expects our persistent classes to follow the well-worn JavaBean convention, including a no argument constructor and getters and setters for each property. Such a class can never be mutable! So how do we program with frameworks such as Hibernate and yet still minimize mutability? The key is found in not letting frameworks dictate the way that you design your code. Just because the framework require something, don't let it force you to make the wrong decision. Use the framework as a tool to write your code, don't let your code be a tool of the framework. We'll examine strategies for doing exactly that.
You should come away from this talk better equipped to program in a way that minimizes mutability and maximizes immutability.
Unlike earlier languages, Java had a well-defined threading and memory model from its inception, and over the years additional packages have been added to the standard library to help solve concurrency problems.
Despite all this, Java's memory model still remains poorly understood and
its concurrency libraries under utilized.
In this talk, we'll discuss concurrency in detail starting from the low-level
of the hardware up to the high-level of concurrent collections and Java 7's
new parallel fork join library.
The Cloud Foundry engineering teams have steadily increased their use of the Go programming language (http://golang.org) for building (or rebuilding) components, starting with the Router, and progressing through Loggregator, the “cf” CLI, and more recently the Health Manager 9000.
As a Java-developer-turned-DevOps-junkie focused on helping our customers and community succeed with Cloud Foundry, it's become clear to me that I need to add Go to my knowledge portfolio.
Go is a very interesting language, open-sourced by Google in late-2009, that takes a “less is more” (http://commandcenter.blogspot.de/2012/06/less-is-exponentially-more.html) approach to language design, but that also bakes in a powerful concurrency model.
This talk will introduce Go, delve into its distinctives, and contrast its approach with that of Java (where appropriate). We'll also write a fair amount of Go code along the way. This talk will be of particular interest to Java developers looking to add Go to their toolkits, but will also be of interest to anyone looking to learn a little bit more about Go.
Even taking into account everything that we've learned about operating at “web scale” in the last several years, most applications are designed and implemented to be, as Michael Nygard highlights in his book Release It!, “feature complete” not “production-ready.” Unfortunately, the architectural patterns associated with operating at scale – notably the move toward “micro-services” – introduce an order of magnitude more ways in which our applications can fail. If we do not plan well for failure, we will experience the ultimate failure. But if we do plan well for failure, we have a fighting chance at success.
This talk will take a tour through the James Chiles' book Inviting Disaster: Lessons From the Edge of Technology, and examine what we can learn from engineering fields in the physical world, applying those learnings to the way in which we develop fault tolerant applications.
This is a revised and updated version of the previous talk, with current thinking from practice and the literature. The talk presents why conflicts with your manager are inevitable based on differences in priorities and perspectives, and how to plan for them. The goal is to show you how to build the loyalty relationship that allows you to get what you need when you need it.
Topics covered will include diagnosing communication styles, lessons from game theory, working within the organizational hierarchy, and lessons on how to build a relationship with your manager that still allows you the freedom to express yourself and what you really want.
Encryption is a powerful tool for privacy. At least that is what we're meant to think.
If you consider encryption to be a black box of magic, you should probably attend this talk.
If you think encryption will protect your secrets, you should probably attend this talk.
If you have (or haven't) been following the news, you should probably attend this talk.
The truth is, encryption can be an effective way of making it harder for people to steal your secrets. But it isn't magical, it isn't fool proof and, depending on how you are using it, may be completely useless. It is a hard topic that we'll only touch the surface on, but there are very few topics that are more crucial for our industry and profession to understand better than encryption. You don't have to understand the math (although that will help), but you do have to understand what it will and won't do for you*.
*and how implementations of it may have been intentionally compromised
Spock brings fluency, nice DSL like syntax for writing unit tests. Spock leverages JUnit, but helps makes tests a lot more expressive. Mocking is baked in as well.
In this presentation we will take a look at Spock to unit test both Java and Groovy code. We will build an example, test driven, and along the way explore the features of this powerful tool.
Learn about HTTP/2 and its relationship to HTTP 1.1 and SPDY. Understand core features and how they benefit security and browser efficiency. More that a “what's new” this talk will leave you with an understanding of why choices in HTTP/2 were made. You'll leave knowing what HTTP/2 is and why it is better for clients and servers.
HTTP/1.1 was released 1999 through years of interoperability driven largely by browsers of the time. HTTP/2 will be a proposed standard by the end of this year, driven largely by browsers of our time.
This presentation will overview interoperability with HTTP/1.1, and how security and efficiency is improved from both the client and server side. We'll also review sources of overhead and some circumstances where efficiency could be perceived worse! We'll then deep dive into topics that cover aspects relevant to browsers, such as how cache push works, how connections are negotiated, and priority. Then, we'll circle around and dive into a server-centric view, discussing connection features such as flow-control and ping, as well how error states are addressed.
We'll wrap up with an example of how you can test http/2 using a current web browser and how to participate in HTTP/2 community. You'll leave knowing what HTTP/2 is and why it is better for clients and servers.
If a book as horrible as Twilight can sell millions of copies and be made into an even worse movie, how many copies can a book with Groovy vampires sell? (Spoiler: Not as many.) Yes, this topic may be silly, but the technologies used (Groovy, Ratpack, MongoDB, Grails, REST) are (un)deadly serious.
This talk uses a Groovy REST client to download movie data in JSON format, stores the data in a Mongo database, and serves it up later using both Ratpack and Grails. Learn a wide range of Groovy techniques to make your applications sparkle! (No, please, please don't do that.)
In this session, I will demonstrate several concurrent processing techniques including Fire and Forget, Fork-Join, Producer-Consumer, and Asynchronous Web Services using the Java Concurrency Library, the Akka Framework and the Spring Framework.
Traditional concurrent development on the Java Platform requires in depth knowledge of threads, locks, and queues. Fortunately, new languages and frameworks that run on the Java Platform have made concurrent processing easier. This session apply concurrent processing patterns and techniques using several popular libraries and frameworks.
So your server is having issues? memory? Connections? Limited response? Is the first solution to bounce the server? Perhaps change some VM flags or add some logging? In todays Java 6 world, with its superior runtime monitoring and management capabilities the reasons to the bounce the server have been greatly reduced.
This session will look at the Java monitoring and management capabilities, which includes the ability to make VM argument changes on the fly. This session will dive into the different memory compartments and how they are used by the JVM. Final this session will explore the different GC options and how they affect response times and throughput.
JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.
In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.
JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.
In this session we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.