The goal: Clean Code That Works, and getting there is half the fun. Working with a legacy mess can be frustrating, boring, dangerous, and time-consuming. When FIBS occur (FIBs = Fixes that Introduce Bugs) you often enter an endless Test and Fix cycle that can quickly escalate into a nightmare. I've been there, you've been there. How do we return to pleasant dreams?
In this code-centric workshop we'll look at ways to introduce sanity and calmness into the process of maintaining and improving buggy, poorly written, poorly designed code. Few slides, mostly code. Learn how to turn any project around and have fun doing it.
It is helpful to bring a laptop with either
Pycharm
Eclipse, intellij
Clion
Visual Studio + Resharper
or
webstorm
However, I will pair you, so if you don't have any of these it will still be ok.
“All the brilliant people, working on the same thing, at the same time, in the same space, and at the same computer.“ - that is Mob Programming. When the activity we mob on is exploratory testing, or the viewpoint to being a programming mob is that of an exploratory tester, we call it Mob Testing. Mob testing - a group testing activity utilizing one computer - voices out the tacit knowledge in the group of individuals on shared tasks. Facilitated by an expert, it makes a great mechanism for building habits and transferring skills over passing knowledge.
In this workshop, we amp up our testing skills by learning from one another, and learn in a mob, getting the best knowledge out of the team into the task at hand. With mob testing, we get a glimpse into the head of the testers while they test because “for an idea to go from your head to the computer, it must go through someone else’s hands”. This is a specific communication style called Strong-style pairing, and it connects the group of brilliant minds in the mob in a shared experience.
The workshop gives you ideas on:
How mobbing gets the tacit knowledge out in a team in an actionable format
How to introduce learning in mobbing format at your place of work
What would it look like to think like an exploratory tester, with intent of understanding coverage while uncovering useful information
What would it look like to apply testing skills while joining a group programming activity
How you can improve your collaboration skills in hands-on work
We will set the room up to two main roles: the mob and the observers in the fashion shown in the picture below. Observers can rotate into the mob and throughout the session play a significant role in regular retrospectives distilling learnings. Don't be afraid, you will not need technical skills to join the mob.
Like everyone else, you have a large product that is hard to work with. We're going to change that in 75 minutes. Together we will save some gnarly legacy code (one thousand-line function). We will start with something hard to read, untested, and possibly buggy. We will finish with code that is stupidly easy to modify. You'll learn 6 trivial techniques that you can apply over and over to fix 95% of the messiest code you have. You can take home this exercise to help the rest of your team learn these techniques. You'll also learn how your team can teach itself a bunch more techniques to handle the other 5%.
We are going to save some legacy code. In 90 minutes. While adding features. We will mob program; you will save this legacy code. We won't introduce any bugs along the way. We will spend the time that you would normally use reading code to instead make it readable. You can apply these techniques and reduce the cost of coding within 48 hours of getting home.
We have done this exercise with dozens of teams. They code differently now. Changing existing code is actually safer and cheaper than writing new code. Their designs get a little better each day. This session will improve your code and show you what skills to learn to gain further improvements.
Learning Outcomes:
Know the 6 refactorings required for reading code by refactoring it.
Differentiate between refactoring and micro-rewrites (code editing), and choose each where appropriate.
Have fluency in the key refactorings with one tool set and know how to spread that fluency to other tools and to broaden the skills within that tool set.
Able to start successfully saving legacy code without making major investments, even with no tests.
See an obvious path for continuing to learn design and refactoring skills - know where and how to get feedback and can create own curriculum for next 1.5-3 years of improvements.
“In order to make delicious food…. you need to develop a palate capable of discerning good and bad. Without good taste,
you can't make good food.” - Jiro Ono (World’s Best Sushi Chef)
Many of us are stuck with messy code. We know it’s not great but it works and what can we do? Where and how do you start?
We are going to use some cutting edge training to train your pattern recognition section of your brain to instantly recognize common, reoccurring anti-pattern (smells) in your code.
Then we will learn very specific techniques to start improving on these specific smells.
Once you are trained to see these anti-patterns you’ll recognize them everywhere. Now that you are equipped to handle them your code will start to transform into something beautiful and easy to work with.
Security should always be built with an understanding of who might be attacking and how capable they are. Typical threat modeling exercises are done with a static group of threat actors applied in “best guess” scenarios. While this is helpful in the beginning, the real data eventually tells the accurate story. The truth is that your threat landscape is constantly shifting and your threat model should dynamically adapt to it. This adaptation allows teams to continuously examine controls and ensure they are adequate to counter the current threat actors. It helps create a quantitative risk driven approach to security and should be a part of every security teams tools.
Join Aaron as he demonstrates how to look at web traffic to analyze the threat landscape and turn request logs into data that identifies threat actors by intent and categorizes them in a way that can be fed directly into quantitative risk analysis. Aaron will show how important this data is in driving risk analysis and creating an effective and appropriate security program.
Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.
We will cover:
Please install Anaconda for Python 3 before the workshop if possible. https://www.anaconda.com/download
The toolset for building scalable data systems is maturing, having adapted well to our decades-old paradigm of update-in-place databases. We ingest events, we store them in high-volume OLTP databases, and we have new OLAP systems to analyze them at scale—even if the size of our operation requires us to grow to dozens or hundreds of servers in the distributed system. But something feels a little dated about the store-and-analyze paradigm, as if we are missing a new architectural insight that might more efficiently distribute the work of storing and computing the events that happen to our software. That new paradigm is stream processing.
In this workshop, we’ll learn the basics of Kafka as a messaging system, learning the core concepts of topic, producer, consumer, and broker. We’ll look at how topics are partitioned among brokers and see the simple Java APIs for getting data in and out. But more than that, we’ll look at how we can extend this scalable messaging system into a streaming data processing system—one that offers significant advantages in scalability and deployment agility, while locating computation in your data pipeline in precisely the places it belongs: in your microservices and applications, and out of costly, high-density systems.
Come to this workshop to learn how to do streaming data computation with Apache Kafka!
Workshop Repo:
https://github.com/confluentinc/kafka-workshop.git
Here's what we need:
Install Docker for Windows or Docker for Mac on your machine. If you're using Linux, you probably know better than I do how to get Docker running. :)
Clone the workshop repo and perform exercise 0. This is very important, because it will do the bulk of the downloading you need to do to get the exercises running. I may make some small tweaks to the Docker Compose file between now and the workshop, but this should result in minimal additional downloading that conference wifi can accommodate. If you do the docker-compose pull on workshop day, it might be painful.
This workshop highlights the ideas from the forthcoming Building Evolutionary Architectures, showing how to build architectures that evolve gracefully over time.
An evolutionary architecture supports incremental, guided change across multiple dimensions.
For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This workshop, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how different parts of architecture interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.
The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This hands-on workshop provides a high-level overview of a different way to think about software architecture.
Outline:
No prerequisites or requirements–all exercises are done with paper, pen, and intellect.
Your goal is simple: take that is happening in your company—every click, every database change, every application log—and made it all available as a real-time stream of well-structured data? No big deal! You’re just taking your decades-old, batch-oriented data integration and data processing and migrating to to real-time streams and real-time processing. In your shop, you call that Tuesday. But of the several challenges to tackle, you’ll have to get data in and out of that stream processing system, and there’s a whole bunch of code there you don’t want to write. This is where Kafka Connect comes in.
Connect is a standard part of Apache Kafka that provides a scalable, fault-tolerant way to stream data between Kafka and other systems. It provides an API for developing standard connectors for common data sources and sinks, giving you the ability to ingest database changes, write streams to tables, store archives in HDFS, and more. We’ll explore the standard connector implementations offered in the Confluent Open Source download, and look at a few operational questions as well. Come to this session to get connected to Kafka!
It has been a while since you left the easy days of batch processing behind: the lazy ETL jobs that had all night to run, the relaxed SLAs that let you take lunches like Don Draper, the languid bankers’ hours: the salad days of your data processing career. Those days are over now, and producing real-time results on streaming data is the new order of the day. Two seconds is the new overnight.
Apache Kafka is a de facto standard streaming data processing platform, being widely deployed as a messaging system, and having a robust data integration framework (Kafka Connect) and stream processing API (Kafka Streams) to meet the needs that common attend real-time message processing.
On top of that, Kafka now offers ksqlDB, a declarative, SQL-like stream processing language. What once took some moderately sophisticated Java code can now be done at the command line with a familiar and eminently approachable syntax. Come to this talk for an updates on the latest ksqlDB features with live coding on live streaming data.
Tired of trying to manage and maintain servers? Never have a large enough operations team? Don’t have a budget for running lots of server? Don’t want to pay for servers siting idle? Afraid you might become so popular that you won’t be able to scale fast enough? Don’t worry, it is possible to alleviate these issues by moving to a serverless architecture that utilizes microservices hosted in the cloud. This type of architecture can support all different types of clients including web, mobile and IoT.
During this hands-on workshop, you will build a serverless application utilizing AWS services such as Lambda, API Gateway, S3 and a datastore.
During this session you will build a simple web application utilizing AWS services and Angular.
This course will cover the foundations of threat intelligence. It will consist of a combination of lecture and lab where we will work through the concepts of detecting indicators of attack and compromise, and building automation to process and eliminate it. This is a fully immersive, hands on workshop that will include a number of techniques, tools, and code.
It will cover the following topics:
Attendees will leave with a fully functional threat intelligence proof of concept system. This PoC can be used to design further capabilities or to evaluate larger commercial systems. Be prepared for an exciting day of code, modeling, and automation.
You will need the following tools installed and updated prior to the workshop:
Run docker pull
We've all got secrets, but nobody seems to know where to put them. This long standing issue has plagued system design for ages and still has many broken implementations. While many consider this an application concern, the foundations rest in the design of the system. Join Aaron for an in-depth workshop that will cover the following secret management solutions:
Additionally, this workshop will demonstrate tools for discovering sensitive information checked in to your project.
This is a two session workshop and is best received by attending both sessions.
You will need the following tools installed and updated prior to the workshop:
Optional
We've all got secrets, but nobody seems to know where to put them. This long standing issue has plagued system design for ages and still has many broken implementations. While many consider this an application concern, the foundations rest in the design of the system. Join Aaron for an in-depth workshop that will cover the following secret management solutions:
Additionally, this workshop will demonstrate tools for discovering sensitive information checked in to your project.
This is a two session workshop and is best received by attending both sessions.
You will need the following tools installed and updated prior to the workshop:
Optional
Too many programs (collections of projects with one business deliverable) try to use team measurement to extrapolate to the program’s status. That doesn’t work. Teams have personal status, and you can’t add them together to understand the program state. Or, your management wants to know when you will be done, and every team uses relative estimation and you can’t understand how to “add” them all together. (You can’t.)
Instead of trying to “scale” measurements, measure what you want to see and what you don’t want to see. You can use a handful of program measurements that help everyone understand where the program is and where it’s headed. In this talk, Johanna will share program measurements—qualitative and quantitative—that show everyone the program state, and maybe when the program could be done.
Do you have to estimate schedule or cost for your innovation projects? If so, do you worry about providing an accurate—never mind precise—estimate? Estimation means “guess,” and our managers want our estimates to be commitments. Instead of providing guesses, help your managers understand risks with the ways you provide estimates or forecasts.
You will learn the three ways to provide an estimate, how to recover when your estimates are off, and how to start the conversation about value instead of cost.
Many agile teams (and programs) attempt to plan for an entire quarter at a time. Something changes—a better product opportunity, or a product development problem—and the quarter’s plan is not just at risk. That plan is now impossible. Instead of quarterly planning, consider continual planning. Continual planning allows a project or a program to use small deliverables to plan for the near future and replan often to deliver the most value.
Change is often much slower than hoped for, and more painful than anticipated. In the end, you may be left with feelings of frustration and dismay rather than the benefits you hoped for. How can we make change–whether it’s adopting Scrum at the team level, or agile at the enterprise level–more successful, and more enlivening?
Through my work with many organizations, I’ve distilled six principles for successful transformation. In this talk, we’ll explore these principles and how the support profound change.
This talk shares 6 principles to guide and nurture change in complex systems. I've given it as a keynote at Agile By Example in Warsaw (2017).
Good discussions are supposed to diverge from their intended path. Free association is a feature, not a bug, and helps you see new connections between ideas. Without structure, however, it can be difficult to add context to new ideas and understand how they relate to more immediate problems. This talk discusses the technique of mental bookmarks – how to remember where you were when a discussion diverged. In addition to giving you a reputation for having an amazing memory, the skill also helps with personal awareness in general.
To give the technique context, we'll look at the fractal nature of success – the way we tend to see our current environment in relative terms, always comparing ourselves to those slightly more successful and slightly less successful.
Reactive Programming is no longer an esoteric idea. Many libraries and tools have started providing excellent support for this idea of programming. So much that Java 9 has embraced this idea by including it into the specification. In this presentation we will take a dive into what reactive programming looks like from the Java specification point of view.
Reactive Programming
What problem does it solve
How to use it from Java point of view?
What can you do to make good use of it.
Everyone (including your humble speaker) talks about Modularization. For once, let's focus on other interesting and exciting parts of Java 9 that does not involve modularization. In this presentation we will talk about key improvements and additions to the Java language and the JDK introduced in Java 9.
We will focus on first things that can be done better in Java 9 compared to previous versions on Java.
Then we will look at things we simply could not do before but we can benefit from now.
And finally, we will not talk about Modularization, well I lied, will discuss that just a bit.
After years of stagnation, Java is one of the most vibrant languages of current times. Java 8 saw several improvements and Java 9 a few more. Well, that's only the beginning. Come to this talk to learn about where Java is heading, what's brewing in the language and the ecosystem, well beyond Java 9.
We will look ahead into the next versions of Java, what you can expect, and how you can get ready.
JavaScript is a very powerful and ubiquitous language. At the same time, it is also a language that is often misunderstood and misused. Better quality code greatly reduces the effort and time to maintain software. So, there is a good incentive to improve quality of code.
In this presentation we will cover two things. We will discuss dos and don'ts for programming with JavaScript. Then we will look at a set of tools that can help keep an eye on our code and prompt us to improve the quality.
Big up front design is discouraged in agile development. However, we know that architecture plays a significant part in software systems. Evolving architecture during the development of an application seems to be a risky business.
In this presentation we will discuss the reasons to evolve the architecture, some of the core principles that can help us develop in such a manner, and the ways to minimize the risk and succeed in creating a practical and useful architecture.
Creating code is easy, creating good code takes a lot of time, effort, discipline, and commitment. The code we create are truly the manifestations of our designs. Creating a lightweight design can help make the code more extensible and reusable.
In this presentation we will take an example oriented approach to look at some core design principles that can help us create better design and more maintainable code.
Java 9 is by far the most significant update of the Java language. We can view Java 9 changes in three parts: improvements, additions, and advances. Quite a few things we could do in Java 8 or earlier have been improved, there are a few new additions, and of course the most noted change the module system or Jigsaw.
In this hands-on workshop we will give into all these three areas, discuss the significance, look at code examples, and most important practice the concepts using concrete exercises. At the end of this workshop you will be able to gauge the efforts necessary for your project to successfully adopt and make use of Java 9.
Java 9 JDK or later version
Your favorite IDE (Preferably IntelliJ IDEA Community Edition)
svn or git-svn
Augmented Reality and Virtual Reality are all the hype right now. Everyone who's anyone is talking about it. Tech giants are making huge investments on the platform and startups are popping up everyday. Where does the Web platform fall into this mix?
In this talk I'll give an introduction to AR/VR. We'll talk about where the industry is at today with these platforms. I'll share some libraries that bring the power of this technology to the web and how you can add AR/VR to your Web application.
In this example-driven presentation, you'll learn how to leverage Spring Boot to accelerate application development, enabling you to focus coding on logic that drives application requirements with little concern for code that satisfies Spring's needs.
For over a decade, Spring has sought to make enterprise Java development easier. It began by offering a lighter alternative to EJBs, but continued to to address things such as security, working with various sorts of databases, cloud-native applications, and reactive programming. And, along the way, Spring even took steps to make itself easier to use, offering Java-based and automatic component configuration. Even so, there's still a lot of near-boilerplate code required to develop Spring applications.
Enter Spring Boot. Spring Boot's primary purpose is to make Spring easier to work with. It achieves this in three ways:
All together, Spring Boot lets you focus on fulfilling your application's requirements without worrying about writing code that satisfies the needs of a framework.
In this session, you'll learn how to take your Spring Boot skills to the next level, applying the latest features of Spring Boot. Topics may include Spring Boot DevTools, configuration properties and profiles, customizing the Actuator, and crafting your own starters and auto-configuration.
TBD
Spock is a groovy based testing framework that leverages all the “best practices” of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock!
There are 3 tools I use on every Java project I control… this is one of them and with good reason.
This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. Topics include:
Unit testing
Data driven tests
Mocking and Stubbing
Partial Mocks
Spock Extensions
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 9 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.
This session will include new features in Java 9 to make it more container aware.
In the container orchestration space, one of the top contenders is Kubernetes (K8S). This session will go into detail of each component in Kubernetes along with how to use it. Anyone attending this session should be able to easy get stated with K8S and have an understanding of what they would need to do to their application to enable it to be K8S friendly.
This session will dive into different applications (stateful/stateless, data-focused/micro-service focused) and how they are managed with the different components of kubernetes:
Big architecture up front is not sustainable in today's technology climate where expectations are high for delivering high quality software more quickly than ever before. To accept change, teams are moving to agile methods. But agile methods provide little architectural guidance. Attempts to define the architectural vision for a system early in the development lifecycle does not work. In this session, we provide practical guidance for software architecture for agile projects.
We will explore several principles that help us create more flexible and adaptable software systems. We’ll expose the true essence of what’s meant when we say “architectural agility.” And we’ll explore the real goal of software architecture and how we can accommodate architectural change to help increase architectural agility.
No single architectural style solves all needs. Though microservices have taken the developer community by storm recently, they are not always the optimal solution. In some cases, a more monolithic architecture may be more suitable short term. Or perhaps a more traditional system of web services that allow you to leverage existing infrastructure investment is preferable. Fortunately, proven architectural practices allow you to build software that transcends specific architectural alternatives and develop a software system that gives the development team the agility to shift between different architectural styles without undergoing a time-consuming, costly, and resource intensive refactoring effort. Modularity is the cornerstone of these alternatives.
In this workshop, we will examine the benefits and drawbacks of several different modular architecture alternatives and we’ll explore the infrastructure, skills, and practices necessary to build software with each of these alternatives. There will be straightforward exercises and demonstrations that show the alternatives and how to create software that provides the architectural agility to easily shift between architectural alternatives.
Topics discussed include:
Pen and paper
Java 8+
Ant
Gradle
Graphviz (Optional)
Heroku account and Heroku CLI (Optional, only if you want to deploy to Heroku PaaS)
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.
An evolutionary architecture supports incremental, guided change along multiple dimensions.
For many years, software architecture was described as the “parts that are hard to change later”. But then microservices showed that if architects build evolvability into the architecture, change becomes easier. This talk, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding how architectural dimensions interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves.
The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This keynote illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.
Building Evolutionary Architectures requires identifying and creating architectural fitness functions. This hands-on workshop defines fitness functions and provides group exercises to help identify and discover them.
According to the Building Evolutionary Architectures book, an architectural fitness function provides an objective integrity assessment of some architectural characteristic(s). This hands-on workshop provides examples of fitness functions and group exercises to identify, define, and implement a variety of fitness functions: atomic, holistic, continuous, triggered, temporal, and others.
Stories and lessons from architecture, design, process, and other sources, each illustrating important principles and pitfalls for modern architects.
Those who cannot remember the past are condemned to repeat it. –George Santayana
The past is never dead. It's not even past. –William Faulkner
Most developers pursue the Latest and Greatest with intense fervor, yet the history of engineering, including software projects, contains rich lessons that we risk repeating ad nauseam. This session recounts a variety of stories of projects that failed architecturally…and why. Ranging from the Vasa in 1628 to Knight Capital in 2012, each story tells of a mistaken interpretation of some architectural fundamental principle and the consequences–some good, some less so. I I also look at the common threads for these stories, which resonates with problems many companies have but don't realize.
nullThis session covers two critical soft skills for architects:
New architects find soft skills like creating lucid documentation and building compelling presentations challenging. This presentation covers a variety of ways to document ideas in software architecture, ranging from diagramming techniques (that aren't UML) to Architecture Decisions Records and ultimately to presentations. The second part of the talk leverages patterns and anti-patterns from the Presentation Patterns book to help architects build clear and concise representations of their ideas.
Big Data is exploding into our industry and these skills are increasingly in demand. Much of our existing body of knowledge needs to be updated, however as Big Data solutions present a number of unique challenges. In this half-day workshop we start with the question “What is Big Data?” and “How do big data solutions differ from traditional data architectures.” We then dive into core Hadoop technologies to tackle your Big Data challenges and dive into several tools and technologies for distributed processing of large datasets.
The Big Data Space is rapidly changing and with a seemingly dizzying number of technology choices, one might not know where to begin. Our goal with this half-day workshop is to give you an overview of a number of technologies, their respective strengths and weaknesses, and enough knowledge to make informed decisions and built great tech!
Big Data is exploding into our industry and these skills are increasingly in demand. Much of our existing body of knowledge needs to be updated, however as Big Data solutions present a number of unique challenges. In this half-day workshop we start with the question “What is Big Data?” and “How do big data solutions differ from traditional data architectures.” We then dive into core Hadoop technologies to tackle your Big Data challenges and dive into several tools and technologies for distributed processing of large datasets.
The Big Data Space is rapidly changing and with a seemingly dizzying number of technology choices, one might not know where to begin. Our goal with this half-day workshop is to give you an overview of a number of technologies, their respective strengths and weaknesses, and enough knowledge to make informed decisions and built great tech!
Interest in MongoDB and other NoSQL platforms has waxed and waned over the years, however, Mongo remains an enormously useful tool.
In this session, you will learn everything you need to know to master MongoDB.
We dive deep into advanced topics, data architecture, tooling options, clustering, replication and sharding. You'll learn when Mongo is the perfect tool for the job (and when it isn't) and what's new in 2018
As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.
To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?
This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.
With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.
When architecting a critical system the Availability of CAP theorem becomes the most important element. Architecture measures availability in 9s with 99.99% equating less than 1 hour of unplanned downtime. This session will focus on what it takes to get there.
After establishing high availability expectations and measurements, this session will dive into what it takes to establish the highest scale possible. It includes a look at infrastructure needs with a separation between capacity and scale. A look a service discovery with pro and cons of service to service dependencies. We look at infrastructure necessary such as health checks and monitoring. The session will include a look at different layers of fault domains including cross region.
At the end of this workshop, you will be comfortable with designing, deploying, managing, monitoring and updating a coordinated set of applications running on Kubernetes.
Distributed application architectures are hard. Building containers and designing microservices to work and coordinate together across a network is complex. Given limitations on resources, failing networks, defective software, and fluctuating traffic you need an orchestrator to handle these variants. Kubernetes is designed to handle these complexities, so you do not have to. It's essentially a distributed operating system across your data center. You give Kubernetes containers and it will ensure they remain available.
Kubernetes continues to gain momentum and is quickly becoming the preferred way to deploy applications.
In this workshop, we’ll grasp the essence of Kubernetes as an application container manager, learning the concepts of deploying, pods, services, ingression, volumes, secrets, and monitoring. We’ll look at how simple containers are quickly started using a declarative syntax. We'll build on this with a coordinated cluster of containers to make an application. Next, we will learn how Helm is used for managing more complex collections of containers. See how your application containers can find and communicate directly or use a message broker for exchanging data. We will play chaos monkey and mess with some vital services and observe how Kubernetes self-heals back to the expected state. Finally, we will observe performance metrics and see how nodes and containers are scaled.
Come to this workshop the learn how to deploy and manage your containerized application. On the way, you will see how Kubernetes effectively schedules your application across its resources.
Optionally, for more daring and independent attendees, you can also replicate many of the exercises on your local laptop with Minikube or Minishift. There are other Kubernetes flavors as well. However, if during the workshop you are having troubles please understand we cannot deviate too far to meet your local needs. If you do want to try some of the material locally this stack is recommended:
Some of the topics we will explore:
These concepts are presented and reinforced with hands-on exercises:
You will leave with a solid understanding of how Kubernetes actually works and a set of hands-on exercises your can share with your peers. Bring a simple laptop with a standard browser for a full hands-on experience.
Kotlin is a language that brings the strengths and capabilities of multiple languages into one. If you have looked at two or three different languages and said “I wish I could do this, that, and that also,” well now you can, thanks to Kotlin. In this presentation we will learn the key benefits and power of this exciting language.
Ways to compile and run
Using REPL
Typing
Creating functions
Working with lambdas and functional style
Destructuring and other interesting features
Null types
Using Extension methods
Classes, objects, and inheritance
Delegation
Creating DSLs
Monoliths are out and microservices are in. Not so fast. Many of the benefits attributed uniquely to microservices are actually a byproduct of other architectural paradigms with modularity at their core. In this session, we’ll look at several of the benefits we expect from today’s architectures and explore these benefits in the context of various modern architectural paradigms. We’ll also examine different technologies that are applying these principles to build the platforms and frameworks we will use going forward.
Along the way, we’ll explore how to refactor a monolithic application using specific modularity patterns and illustrate how an underlying set of principles span several architectural paradigms. The result is an unparalleled degree of architectural agility to move between different architectural paradigms.
Microservice architecture is a modern architectural approach that increases development and delivery agility by focusing on building modular services. The framework we use has a tremendous impact on how quickly and easily we can deliver servcies. New frameworks are emerging that embrace new approaches for helping us deliver microservices.
In this session, we will explore some modern Java frameworks for building microservices (aka micro frameworks). Example frameworks you may see include Dropwizard, Ratpack, Spark, Ninja, RestExpress, Play, Restlet, and RestX. We'll demonstrate each framework by using a programming kata to build the same service using several different frameworks. Optionally, bring your own laptop, clone the github repo, and you can build the services along with me. To do this, you must have Java 8+ and Gradle.
The way we build and deliver software is changing. We must deliver software more quickly than ever before and traditional approaches to software architecture, infrastructure and methodology do not allow us to meet demand. We’ve reached the limits of agility through process improvement alone, and further increases demand we focus on improving architecture, infrastructure, and methodology simultaneously. 12 Factor is an app development methodology for building modern apps in the modern era.
Building modern apps requires modern methods and 12 Factor is an app development methodology that helps development teams build software by emphasizing development practices that meld together modern architectural paradigms with agile practices like continuous delivery for deployment to cloud platforms. In this session, we’ll examine the 12 Factors and explore how to apply them to apps built using Java.
Java 9 with the Jigsaw module system is here. In this session, we'll explore the basics of the Jigsaw module system and examine the impact it will have on how we build Java applications. We will dig into it's major features, including dependency management and Jigsaw services. Once we understand Jigsaw's basics, we will explore what it's going to take to migrate existing Java application to Java 9 and leverage Jigsaw.
Jigsaw's impact stands to be consequential. Jigsaw will restrict application code from accessing non-published JDK classes (ie. sun.com), require you to be explicit in declaring your dependencies, and more. We will explore Jigsaw basics and then dig into the impact Jigsaw will have on migrating existing Java applications to Java 9.
In this session we will take a look at building applications with Angular. We will build a very simple application from the ground up, and attempt to understand the approach of Angular, as well as understand some of the terminology that Angular introduces.
This session will focus on the Angular 10
TypeScript, Components, Annotations/Directives, Observables, Reactive Stores, Model-Driven forms … Oh my! Angular, much like AngularJs (1.x.x), despite being a powerful platform for building rich client side applications, comes laden with both new terminology, and a “newer” approach to writing client side code.
In this session, as we build a simple application, we will attempt to tease apart these concepts, slowly building our understanding towards how these pieces come together, and how we can leverage them to build rich client side application.
Details
angular-cli generatesAlong the way we will see how to use the Angular style guide to follow conventions adopted by the Angular community at large, and some ways to use the angular-cli tool.
In this session we will take a look at building applications with Angular. We will build a very simple application from the ground up, and attempt to understand the approach of Angular, as well as understand some of the terminology that Angular introduces.
This session will focus on the Angular 10
TypeScript, Components, Annotations/Directives, Observables, Reactive Stores, Model-Driven forms … Oh my! Angular, much like AngularJs (1.x.x), despite being a powerful platform for building rich client side applications, comes laden with both new terminology, and a “newer” approach to writing client side code.
In this session, as we build a simple application, we will attempt to tease apart these concepts, slowly building our understanding towards how these pieces come together, and how we can leverage them to build rich client side application.
Details
pipes in AngularAlong the way we will see how to use the Angular style guide to follow conventions adopted by the Angular community at large, and some ways to use the angular-cli tool
In this session we will explore the router that ships with Angular. We will see how to leverage its power and flexibility to build real world applications.
Angular ships with a powerful new router. One that allows you to manage your application state, allow for things like nested and child views, as well as loading modules on demand. If you have complex workflows and you wish to learn the new way of navigating your Angular application, this is the session for you.
Modern web apps have many moving parts. Setting up development environments can be tedious. Truly mirroring staging and production environments can be a nightmare (especially when including app settings, security settings, back-end services etc.)
In this session we dive deep into the Hows and Whys of using Docker for client-side development. You'll leave this session with a sound understanding of the fundamentals of docker as well as the tools that can be used to effortlessly create a full development environment.
Containers and Micro-service are like peanut butter and jelly, they just go together. However do you know how resources are managed in a container and how that affects your application. This session will dive into how Java is affected living under control groups.
This session will review containers, the underlying technology to containers along with different container runtimes such as Docker. We will look at the anatomy of a container including control groups (cgroups) and namespaces. This session will conclude with the challenges of running the JRE in a container and the impact that has on the efficiency of the process at scale.
This session will include container friendly changes to Java 9 around memory and ergonomics. It will also provide advice on how to get consistent CPU share.
VueJS is the new contender for 'best front end framework' and is running a very close second place to React in popularity amongst knowledgable developers. It is gaining mindshare and has incredible momentum, all for very good reasons!
Join us for this introductory, full day workshop in which we fully explore everything that makes VueJS the last framework you will ever learn … because you won't ever want to use anything else again!
Upon completion, you will be armed with the skills and knowledge to create sophisticated VueJS components that:
We will also explore deployment options and productionization of your application.
I look forward to sharing this amazing new contender in the front-end SPA framework space!
A basic understanding of JavaScript would be helpful. Knowledge of more ES2015/16 constructs will be reviewed for those who might be unfamiliar with them.
There are currently over two billion Android devices in the world, ranging from phones to tablets to wearables to automotive apps. Each of them supports development using the open source Android operating system. This talk will show how to create an Android project, work with Activities and Intents, and work with the underlying Gradle build system.
The talk will work with the current version of Android Studio and include tips and tricks on its use.
Building on Part 1, this talk will add REST capabilities, discuss how to work with SQL databases, and perform asynchronous methods in Android.
Code will make use of popular Android libraries, like ButterKnife, Retrofit, OkHttp, and Room.
On the 2017 tour, I introduced the notion of “serverless” and Functions as a Service (FaaS) platforms. We understood the motivation for serverless computing, compared serverless to other cloud-native infrastructure approaches, navigated some architectural tradeoffs, and took a whirlwind tour of the Big 3 FaaS providers.
In this 2018 edition of the talk, we’ll still cover a few of the same themes to bring new folks up to speed, but we’ll also look at what’s changed in this ecosystem over the past year, take a look at new or enhanced features, offerings, runtimes, and programming models, and examine what use cases are becoming popular for serverless computing. We’ll also look at how tradeoffs have evolved, and definitely throw in a few demos.
In this presentation, we'll build, test, and deploy an image-processing pipeline using Amazon Web Services such as Lambda, API Gateway, Step Functions, DynamoDB, and Rekognition.
We'll take a look at some of the following topics:
Chaos Engineering, pioneered by Netflix, is the discipline of experimenting on a distributed system in order to build confidence in the system's capability to withstand turbulent conditions in production.
In this presentation, we'll take a look at the problem of building resilient software, and discuss how applying Google's SRE principles and patterns for architectural resiliency can help us to solve it. We'll then examine how the practice of Chaos Engineering can help us to prove or disprove the resiliency of our systems.
The Gradle build tool has been adopted by the vast majority of open source projects and is growing rapidly in industry as well. Gradle provides a powerful DSL for customizing and managing your build, with flexible configuration features and sophisticated dependency management. Gradle is also actively supported by a commercial entity, and in partnership with companies like Netflix and LinkedIn is currently being optimized for performance.
Topics will include:
You need Java 1.7 or above (full JDK, not just JRE). You can install the latest version of Gradle, but we'll discuss that during the workshop. No IDE is required, but both IntelliJ IDEA and Eclipse-based tools will be discussed.
The Gradle build tool has been adopted by the vast majority of open source projects and is growing rapidly in industry as well. Gradle provides a powerful DSL for customizing and managing your build, with flexible configuration features and sophisticated dependency management. Gradle is also actively supported by a commercial entity, and in partnership with companies like Netflix and LinkedIn is currently being optimized for performance.
Topics will include:
You need Java 1.7 or above (full JDK, not just JRE). You can install the latest version of Gradle, but we'll discuss that during the workshop. No IDE is required, but both IntelliJ IDEA and Eclipse-based tools will be discussed.
An integral part to any DevOps effort involves automation. No longer do we wish to manage tens, hundreds or even thousands of servers by hand, even if that were possible. What we need is a programmatic way to create and configure servers, be those for local development, all the way to production.
This is where tools like Ansible come into play. Ansible offers us a way to define what our server configurations are to look like using plain-text, version-controlled configuration files.
Not only does this help with avoiding “snow-flakes”, but it promotes server configuration to participate in the SDLC, pulling server configuration closer to the developers.
In this session we will explore what Ansible has to offer, decipher the Ansible terminology, and run some examples to configure a local server.
Ansible, like Git, aims to be a simple tool.
The benefit here is that the level of abstraction that Ansible offers is paper-thin, with no complicated workflows, or opinions enforced by the tool itself.
The downside is that without a prescribed approach to Ansible, developing your playbooks often becomes a case of trial-and-error.
As engineers steeped in the DevOps mindset we must be able to use the tool effectively, allowing us to accelerate and shorten the lead time from development to production.
In this session we will take a look at some lessons learned when working with Ansible. Topics covered:
All software architectures have to deal with stress. It’s simply the way the world works! Stressors come from multiple directions, including changes in the marketplace, business models, and customer demand, as well as infrastructure failures, improper or unexpected inputs, and bugs. As software architects, one of our jobs is to create solutions that meet both business and quality requirements while appropriately handling stress.
We typically approach stressors by trying to create solutions that are robust. Robust systems can continue functioning properly in the presence of internal and external challenges, but they also have one or more breaking points. When we pass a robust systems known threshold for a particular type of stress, it will fail. When a system encounters an “unknown unknown” challenge, it will usually not be robust!
Recent years have seen new approaches, including resilient, antifragile, and evolutionary architectures. All of these approaches emphasize the notion of adapting to changing conditions in order to not only survive stress but sometimes to benefit from it. In this class, we’ll examine together the theory and practice behind these architectural approaches.
As an architectural style, microservices are here to stay. They have crossed the proverbial chasm, and now it’s time to get to work. Microservices provide us with the ability to create truly evolutionary architectures composed of cohesive and autonomous components using well known and characterized distributed systems patterns.
As we create and compose components across the hard boundary of the network, we become deeply interested in establishing the correct boundaries and has resulted in renewed interest in system design and decomposition. Fortunately, the tried and true practices of Domain-Driven Design are available to us.
In this presentation, we will cover a distillation of strategic (bounded contexts, subdomains, context mapping) and tactical (aggregates, domain events) DDD techniques and demonstrate how they enable us to create effective event-driven microservices.
One of the things that makes Angular so powerful is all of the tooling that it comes with. One piece of tooling is the Angular Mobile Toolkit and how it helps you easily setup Progressive Web Apps. PWAs will help you create an offline first experience, so that even users with little or no connectivity can experience your web app.
In this talk we will talk about the basics of what makes a PWA, and go through the steps of implementing a service worker. We will tie it all together with the Angular Mobile Toolkit.
Everyday our Web is growing more and more powerful. Progressive Web Apps bring the mobile web to a whole new level making it possible for the mobile web to compete with native applications.
In this talk I will give an introduction Progressive Web Apps. We will talk about Service Workers the webapp manifest etc. I'll also share how you can easily add PWAS to your Angular and React applications.
In this session, you'll learn how to use Spring Data to rapidly develop repositories for a variety of database types, including relational (JPA and JDBC), document (Mongo), graph (Neo4j), and others (Redis, Cassandra, CouchBase, etc).
For decades, relational databases and SQL have enjoyed their position as the leading choice for data persistence. Even though many alternative database types have emerged in recent years, the relational database is still a top choice for a general purposes data store and will not likely be usurped from its position any time soon. When it comes to working with relational data, Java developers have several options.
But relational databases are not a one-size-fits-all solution. Thankfully, there are many options for data persistence, including relational, document, graph, key-value, and column-store databases, each presenting their unique way of handling data suitable for different problems.
Spring Data makes it easy to work with various databases by offering a programming model that is consistent, regardless of which type of database you're working with. And regardless of the database you're dealing with, you will find that Spring Data eliminates a lot of boilerplate code.
In this session, you'll see how to take Spring Data's automatic repository generation to a whole new level. We'll look at ways to model data and manipulate Spring Data to produce repositories and APIs that are more than just CRUD layers on top of a database.
TBD
In this sessions we'll see how to use components of Spring Cloud to configure and discover microservices in a cloud native microservice-architected application. Specifically, we'll look at Spring Cloud Netflix and Netflix' Eureka and Ribbon projects for service discovery as well as the Spring Cloud Config project's configuration server to provide a central point of external configuration.
Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.
If the individual microservices are to work together in service of the greater application, then they must know about each other. Rather than hardcode the specifics of each microservice within every other microservice, it's better to provide a registry with which a service can register and other services may use to lookup those service details.
Microservices, like any application, will also likely depend on application-level configuration. It's generally a good idea to keep that configuration separate from the application itself, and this is even more true with microservices. Using a centralized configuration service, microservices can obtain their configuration details, some of which may be shared across many microservices. Because it is separate from the application/microservice code, that configuration itself can be versioned and evolve at a pace independent of the microservices it serves.
In this session, we'll look at how to monitor the health of individual services in a microservice-architected application as well as trace the path of data and processing as it flows from service to service. Specifically, we'll look at Spring Cloud Netflix and Netflix OSS' Hystrix project to not only apply the circuit breaker pattern for failure and latency protection to microservices and monitor the health of those circuit breakers in a running application. Additionally, we'll look at Spring Cloud Sleuth and Zipkin to trace processing through a microservice-based application.
Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.
Failure is always a possibility in any application. But when an application is composed of microservices, it's important for that each service contain its failure and keep its problems to itself to avoid cascading errors to other services. Likewise, latency can be a concern that is compounded when felt across multiple microservices and it's important to avoid cascading latency issues. By applying the circuit breaker pattern in your microservices, you can ensure that if anything goes wrong in a given service, it stays in that service and doesn't have any negative impacts to other services. Moreover, metrics published by those circuit breakers can provide helpful insight into the health of an application.
When things do go wrong, it may also be helpful to trace the flow and processing of information as it passes from one microservice to another. Traditionally, tracing involves following the logs of a single application. But in a microservice-based application where many services and many instances of those services are involved, tracing is much more challenging. What's needed is a way for microservices to submit timing and tracing information to a central tracing service that coordinates that data and can present the flow of data in a single, easily digested view.
In this session, we'll see how to develop microservices that are components of a flow of data, but that do not necessarily involve REST. We'll also see how to develop ephemeral microservices–microservice that are triggered to perform a job, then shutdown when that job is complete. Specifically, we'll look at Spring Cloud Stream for flow-based microservices, Spring Cloud Task for ephemeral microservices, and Spring Cloud Data Flow which orchestrates those stream- and task-based services.
Microservice-architecture presents many benefits, not the least of which include opportunities to develop, evolve, scale, test, and deploy individual modules of an application independently from the rest of the application. But once an application is broken apart, a new set of challenges arises.
Microservices are commonly thought of as small REST-based services that are assembled to form a larger, more complete application. In reality, however, REST is only the communication mechanism which is only a implementation detail and not intrinsic to the notion of microservices. Meanwhile, data processing and integration between various components of an application and external services is a key factor of many applications. In cloud native applications, this kind of data flow and processing is still relevant.
In this session, you'll learn how to take advantage of the latest features of Spring Security and Spring Boot to secure an application, both at the web layer and at the method-level.
Information is probably the most valuable item we now have; crooks are looking for ways to steal our data and identities by sneaking into unsecured applications. As software developers, we must take steps to protect the information that resides in our applications. Whether it’s an email account protected with a username/password pair or a brokerage account protected with a trading PIN, security is a crucial aspect of most applications.
Spring Security is an extension to the Spring Framework that provides security to Spring applications both at the HTTP request level as well as at method invocation.
How do you create creativity? This talk offers techniques and perspectives to discover, grow, and project your ideas.
Where do ideas for new talks, books, videos, software…ultimately, everything…come from? A common question at conference panels to the speakers is “Where do you get your ideas for talks?” This session answers that question, along with how some of us cultivate new ideas. This talk investigates three aspects of ideation:
— How do new ideas arise?<br>
I cover various ways of synthesizing new ideas: switching axiom(s), mutation, oblique strategies, and a host of other techniques to generate a germ of a new idea
— How do ideas grow into intellectual property?<br>
I cover techniques for iterating on ideas to discover deeper meanings and connections. I also cover how techniques to evolve and grow ideas.
— How do you communicate new IP?<br>
I cover various ways to convey IP: presentations, articles, books, videos, and a host of other media. I talk about how writing and presenting techniques to amplify your new idea and get it out into the world.
One key to building new IP is separating ideation, organization, and realization, which often become jumbled. By separating them, we can build practices to allow each to flourish. This talk provide concrete advice in each area to help realize new ideas.
Creativity is the reason we have all the Cool Stuff we have. This session investigates how to fan the spark of an idea into a roaring flame of intellectual erudition.
Hypothesis and data driven development ties together current thinking about requirements, Continuous Delivery, DevOps, modern architecture, and engineering techniques to help rethink building software.
Agile development claims to abhor “Big Design Up Front”…yet what is that giant backlog building session but BDUF in other clothing? Back in the olden days of software development, we were forced to speculate on what users want, then build it. We were basically running a buffet. But what if we could switch to à la carte? With modern engineering practices like Continuous Delivery, we can shift our perspective and start building by hypothesis rather than speculation. This talk shows the full spectrum of software development, from ideation through execution and deployment, through the lens of modern software engineering practices. I discuss building a platform using feature toggles, canary releases, A/B testing, and other modern DevOps tools to allow you to run experiments to see what your users really want. By building a platform for experimentation, product development shifts from up-front guessing to market driven. This talk unifies the practices of modern architecture, DevOps, and Continuous Delivery to provide a new approach to feature development. This talk also demonstrates how to undertake major architectural restructuring with zero regression failures by relying on data and the scientific method.
Refactoring imperative code to functional style is a really good way to learn. What's even better, take a series of unit tests that pass, refactor the imperative code, and verify that the tests still pass after you make the code change. In this workshop we will take on a series of problems, already solved using imperative style, refactor that to functional style, and discuss the approach, techniques, pros, and cons.
Come prepared with your Java IDE. Be ready to pair up with other attendees. Dive into functional thinking.
Refactoring imperative code to functional style is a really good way to learn. What's even better, take a series of unit tests that pass, refactor the imperative code, and verify that the tests still pass after you make the code change. In this workshop we will take on a series of problems, already solved using imperative style, refactor that to functional style, and discuss the approach, techniques, pros, and cons.
Come prepared with your Java IDE. Be ready to pair up with other attendees. Dive into functional thinking.
Developers and architects are increasingly called upon to solve big problems, and we are able to draw on a world-class set of open source tools with which to solve them. Problems of scale are no longer consigned to the web’s largest companies, but are increasingly a part of ordinary enterprise development. At the risk of only a little hyperbole, we are all distributed systems engineers now.
In this talk, we’ll look at four distributed systems architectural patterns based on real-world systems that you can apply to solve the problems you will face in the next few years. We’ll look at the strengths and weaknesses of each architecture and develop a set of criteria for knowing when to apply each one. You will leave knowing how to work with the leading data storage, messaging, and computation tools of the day to solve the daunting problems of scale in your near future.
JavaScript is no longer that scary nasty language. There are so many wonderful features in the modern versions of this language that I can't stop praising it. In this presentation we will focus on some of the most exciting features of the language that make programming in JavaScript a pleasant experience.
We will dive into beautiful parts and features from ES 6, ES 7, and ES 8.
To say the least, writing classes in JavaScript was a weird experience. It never felt right. Well the language has set it right finally. In this presentation we will learn about the different capabilities in JavaScript to do OO programming. Along the way we will dive into some advanced concepts as well.
Learn how to program with this powerful language that has matured significantly in the recent years.
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.
React is a very targeted library for creating rich front end. While React does fairly well what it intends to provide, developing a practical application requires more than using React alone.
In this presentation we will build the front end for a small application that pulls data from a backend and along the way learn how to use React and related libraries to achieve the desired results.
In this presentation, we will dig deeper into creating applications with React.
We will take a deeper look into creating components, dealing with life cycle events, managing state, when and how to use Redux, and how to approach automated testing of the front-end code you create.
Machine Learning is a huge, deep field. Come get a head start on how you can learn about how machines learn.
This talk will be an overview of the Machine Learning field. We’ll cover the various tools and techniques that are available to you to solve complex, data-driven problems. We’ll walk through the algorithms and apply them to some real but accessible problems so you can see them at work.
Documents contain a lot of information. We'll introduce you to a variety of techniques to extract them.
Machine Learning techniques are useful for analyzing numeric data, but they can also be useful for classifying text, extracting content and more. We will discuss a variety of open source tools for extracting the content, identifying elements and structure and analyzing the text can be used in distributed, microservice-friendly ways.
This open source machine learning framework from Google has taken off. Come learn what you can do with it in your own organization.
TensorFlow is a powerful data flow-oriented machine learning framework developed by Google's Brain Team. It was designed to be easy to use and widely applicable on both numeric, neural network-oriented problems as well as other domains. We'll cover the over view as well as apply it to several fun, realistic problems.
Bitcoin has roundly entered the public consciousness, but it is limited in its use beyond the specific constraints of the cryptocurrency. Ethereum is a new platform that has enabled developers to innovate in creating their own cryptocurrencies, platforms, smart contracts and more.
This talk will introduce the larger concepts of blockchains and decentralized applications as well as details on how to build running applications on the Ethereum platform.
These ideas and tools will help innovators disrupt organizations, markets, entire industries and even aspects of society. It's sounds like science fiction, but these thing are already happening. Come learn how.
We will cover:
What happens if Web applications become super fast?
What if the ability to write code once but run it on lots of different platforms was true again?
What if Desktops are no longer interesting because you can do everything in a browser?
What if JavaScript wasn't your only language choice?
These are all starting to happen now that this W3C Standard is supported widely across all major browser vendors, Node and more. It's never been a better time to dig into the future that is playing out now faster than most people realize.
WebAssembly is emerging as an exciting vision for web applications that run at native speeds by using a size and load-time efficient, compiled binary format. Anything from computationally intensive business applications to fully rendered 3D video games will benefit from the mix of speed with other Web-oriented technologies. We'll let you know what is coming and how you'll benefit from it.
We will cover:
This is a hands on workshop of a truly mind-blowing next step evolution of the Web. Don't get left behind.
please install a recent version of git
https://git-scm.com/
What happens if Web applications become super fast?
What if the ability to write code once but run it on lots of different platforms was true again?
What if Desktops are no longer interesting because you can do everything in a browser?
What if JavaScript wasn't your only language choice?
These are all starting to happen now that this W3C Standard is supported widely across all major browser vendors, Node and more. It's never been a better time to dig into the future that is playing out now faster than most people realize.
WebAssembly is emerging as an exciting vision for web applications that run at native speeds by using a size and load-time efficient, compiled binary format. Anything from computationally intensive business applications to fully rendered 3D video games will benefit from the mix of speed with other Web-oriented technologies. We'll let you know what is coming and how you'll benefit from it.
We will cover:
This is a hands on workshop of a truly mind-blowing next step evolution of the Web. Don't get left behind.
please install a recent version of git
https://git-scm.com/
For the last 20-30 years, there has been a never-ending set of solutions for building cross-platform desktop applications. Most of them suck. Electron is one that doesn't.
It is a new solution that forms the basis of the Atom Editor, Microsoft's Visual Studio Code, the Slack app and more.
Come see what happens when you combine the best of the Web, Node.js and Chromium to provide attractive, modern, flexible, useful, consistent cross-platform desktop applications.
Electron grew out of the work on the Atom Editor from GitHub. Developers familiar with JavaScript, Node and Web Development will be comfortable with an engine that uses the same technologies as they move to the Desktop. At the same time, the Chromium engine, which has support for modern technologies such as WebGL, WebRTC and desktop-integration hooks, as well as HTML 5 and CSS, rounds out the platform. The strength of the Web mixed with native desktop integration hooks and the performance and flexibility of Node strikes the right balance for avoiding sucky cross-platform applications.
While the Web itself has strong decentralized aspects to how it is used, the backend technologies are largely centralized. The naming systems, the routing systems and the traffic that all points back to the same place for a website are all centralized technologies. This creates both a liability as well as a control point.
In order to break free of some of these limitations, new technologies are emerging to provide a more decentralized approach to the Web.
This talk will walk you through some emerging technology to provide decentralized content storage and distribution, edge computing and more. We will touch upon the Interplanetary Filesystem, WebTorrent, Blockchain spin offs and more.
Firebase is a powerful set of tools to build out your application without having to manage infrastructure!
In this talk we will explore how to setup Firebase for your web application.
I will show how easy it is to add firebase to an existing Angular application with AngularFire, and to a React application with ReactFire :D
State management is essential in large scale Single Page Applications-it helps keep code easy to learn and debug.
In this talk we will introduce the concept of Redux and show how Redux can be used to managed state in your web applications.
We will also explore how to add Angular Redux to get redux bindings for state management in Angular, as well as React Redux for React apps.
Are you an engineer and not a designer?Are you too busy to waste time on styling components and making sure your css applies across all browsers? Do you need to rapidly build prototypes and iterate on the UI quickly? Then this talk is for you!
In this talk I will share some UI libraries and tools that can make prototyping your applications fast. We will briefly cover some of the popular frameworks and deep dive into Material Design. I'll share how you can apply Material Design to your Angular and React applications easily in less than 5 minutes!
Every company in today's day and age wants to build rapidly and deliver value to their customers sooner. But often we develop in a vacuum and consult our end user too late in the process.
In this talk I'll give a quick introduction to Experience Design for Engineers. We will take a deep dive into Design Thinking and understand the techniques to build prototypes quickly even before you start writing code!
Serialization is important for anything Big Data. We need to send information over the wire and we need to do so efficiently. This core concept presentation covers various serialization techniques and libraries. That way you can use Akka, Kafka, Spark, and various MQs efficiently
For this presentation, we will focus on three topics: Core Java Serialization, Apache Avro, and Google's Protocol Buffers. We will review serialization and deserialization ease of use, review performance, and how to integrate with Akka, Kafka, Spark.
Many have already seen what Reactive Streaming can do: RXJava, Akka Streams, Project Reactor. Now reactive streaming is a part of the canonical package for Java and now we can handle asynchronous pipelines with boundaries and make better well thought out applications
This presentation introduces you to the core components of Reactive Streams: Publisher, Subscriber, and Processor. We will discuss when to use Reactive Stream and how to avoid complicated scenarios like Backpressure. We will also cover some of the core problem spaces and how to overcome.
Kafka has captured mindshare in the data records streaming market, and in this presentation, we knock on its door and see what lies behind. What is the draw? What makes it an attractive addition? How does it compare to Message Queues and other message streaming services?
We will do a thorough introduction into what is Kafka. We will also discuss Consumers, Producers, Streams. Integration with ZooKeeper, and discuss the performance aspect of using Kafka.
Apache Spark is the fast data processing of large document stores and databases. Spark is highly distributed, optimized, and redundant for large clustering manipulation and aggregation.
This talk is an introduction to Apache Spark, it's architecture, and it's programming API. We start with an introduction to DataFrames, the Catalyst Optimizer, and Spark SQL. We will then venture onto DataSets, discuss the DataSet API and the functional programming aspects of it. We will touch lightly on RDD and the pros and cons of using the API. We will then finish with how to connect to data sources like HDFS, S3, Cassandra, Elastic Search, and Kafka. This presentation will have samples that you can try out at home or at the office.
Spark Streaming is one of the few additions that are available with Spark that uses its internal architecture and creates a Streaming processing framework to process data in real time.
In this presentation, we will start with a small reintroduction to Spark and it's architecture and what it does. Then we delve into streaming, what purpose does it serve, how to set up Spark Streaming and how to use it. We will discuss how to set it with time, how the internals work, and how also to integrate it with Kafka. We then will talk about some of the more high-end features like checkpointing, and windowing.
Micronaut is a modern, JVM-based, full-stack framework for building modular, easily testable microservice applications.
In this session we'll dive deep into Micronaut, it's strengths, capabilities and best practices when building & testing services, functions and reactive apps.
Learn how to use Heroku's 12 (15) Factor App methodologies to make your applications more portable, scalable, reliable and deployable.
Do you want to improve your application’s portability, scalability, reliability and deploy ability? Now you can, with Heroku’s 12 Factor App methodologies. Learn from their experience hosting and supporting thousands of apps in the cloud. During this hands-on workshop, you will learn how to incorporate factors like configuration, disposability, dev/prod parity and much more into an existing application whether it is an on premise or cloud native app. But wait, there’s more! Act now, and get an additional 3 factors absolutely free! API first, Telemetry and even Authentication and authorization will be included at no additional cost.
Learn how to use Heroku's 12 (15) Factor App methodologies to make your applications more portable, scalable, reliable and deployable.
Do you want to improve your application’s portability, scalability, reliability and deploy ability? Now you can, with Heroku’s 12 Factor App methodologies. Learn from their experience hosting and supporting thousands of apps in the cloud. During this hands-on workshop, you will learn how to incorporate factors like configuration, disposability, dev/prod parity and much more into an existing application whether it is an on premise or cloud native app. But wait, there’s more! Act now, and get an additional 3 factors absolutely free! API first, Telemetry and even Authentication and authorization will be included at no additional cost.
Docker and containers are getting a lot of attention these days but what do they mean for devs? How do they fit into DevOps and continuous delivery movements? Where do these tools fit into cloud computing? During this hands-on session we will learn how to install and configure Docker, build images and run containers in a local development environment. But we will also explore using them in a continuous deployment environment by deploying them to on premise as well as cloud services such as AWS.
Docker and containers are getting a lot of attention these days but what do they mean for devs? How do they fit into DevOps and continuous delivery movements? Where do these tools fit into cloud computing? During this hands-on session we will learn how to install and configure Docker, build images and run containers in a local development environment. But we will also explore using them in a continuous deployment environment by deploying them to on premise as well as cloud services such as AWS.
Kotlin is a practical language designed for the JVM. It focuses on pragmatism and safety, with an emphasis on interoperability and tool support. Kotlin is statically typed and includes null checks in the type system itself. The language runs anywhere Java does, from microservices to Android apps. This workshop will show how to use Kotlin to simplify anything you originally planned to do in Java.
Kotlin combines object-oriented programming with functional features like lambda expressions, functional types, and data classes. Since it comes from JetBrains, the company that produces the IntelliJ IDEA development environment, its tool support is excellent. IntelliJ even provides a Java-to-Kotlin converter to help you get started.
This presentation will cover the basic types, defining and calling functions, programming with lambdas, higher order functions, and DSLs. The goal is to give you enough background to be productive while you continue to learn and grow with the language.
Kotlin is a practical language designed for the JVM. It focuses on pragmatism and safety, with an emphasis on interoperability and tool support. Kotlin is statically typed and includes null checks in the type system itself. The language runs anywhere Java does, from microservices to Android apps. This workshop will show how to use Kotlin to simplify anything you originally planned to do in Java.
Kotlin combines object-oriented programming with functional features like lambda expressions, functional types, and data classes. Since it comes from JetBrains, the company that produces the IntelliJ IDEA development environment, its tool support is excellent. IntelliJ even provides a Java-to-Kotlin converter to help you get started.
This presentation will cover the basic types, defining and calling functions, programming with lambdas, higher order functions, and DSLs. The goal is to give you enough background to be productive while you continue to learn and grow with the language.
Web Components change the way you build web applications and think about front-end architecture. Finally, web developers have a sane way to scope and modularize not just their JavaScript, but also the HTML5 and styling. The approach is elegant, encourages compatibility between frameworks, and piggybacks on the web browser's success as an open and extensible runtime. The Polymer framework demonstrates how frameworks can and should evolve in a Web Components world.
In this session, I'll provide an overview of Polymer, and demonstrate the creation of Web Components using the framework. Data binding, true encapsulation of code and style, and dynamic HTML imports are all ready for your use. You will leave with a solid understanding of Polymer basics, and real-world examples of Polymer being used in production today. You will be able to guide your current development to better align with upcoming web standards, and to understand how they will change the way we build and deploy web applications. I'll also show you examples of a large personal project using Web Components to build an entire iOS application.
If the web browser is growing up, then Web Components are the browser leaving home. Finally.
For this workshop, you should bring a laptop with some IDE installed – Brackets (from brackets.io) works well. We'll do the rest in the session, including installing Polymer itself.
Web Components change the way you build web applications and think about front-end architecture. Finally, web developers have a sane way to scope and modularize not just their JavaScript, but also the HTML5 and styling. The approach is elegant, encourages compatibility between frameworks, and piggybacks on the web browser's success as an open and extensible runtime. The Polymer framework demonstrates how frameworks can and should evolve in a Web Components world.
In this session, I'll provide an overview of Polymer, and demonstrate the creation of Web Components using the framework. Data binding, true encapsulation of code and style, and dynamic HTML imports are all ready for your use. You will leave with a solid understanding of Polymer basics, and real-world examples of Polymer being used in production today. You will be able to guide your current development to better align with upcoming web standards, and to understand how they will change the way we build and deploy web applications. I'll also show you examples of a large personal project using Web Components to build an entire iOS application.
If the web browser is growing up, then Web Components are the browser leaving home. Finally.
For this workshop, you should bring a laptop with some IDE installed – Brackets (from brackets.io) works well. We'll do the rest in the session, including installing Polymer itself.
“There's a new JS framework every week! There's a new JavaScript feature every week! There's a new HTML5 feature every week! We are losing our minds OMG@#$HELPUS!”
Settle down everybody. Shiny new frameworks distract you from the stability offered by the web platform: ES6 is the first major update to JavaScript since 2009, and HTML5 was 18 years in the making! More importantly, few of these innovations significantly change the architecture of web applications — we owe browser innovation and frameworks for that. But since the browser evolved in to a full-blown application runtime, we now need solid front-end architecture, and front-end architects. It's not just about JavaScript, it's about the entire browser platform. And you can't pick frameworks to simplify that platform until you understand its underpinnings.
In this workshop, we will dissect the components of a modern web client into three buckets:
I'll lay the foundations to simplify the complex world of front-end tools, frameworks, and architecture. I'll share patterns to help you manage the complexity of front-end development and back-end integration for modern web clients. And I'll convince you to never again complain about how fast the world of front-end technologies is moving.
“There's a new JS framework every week! There's a new JavaScript feature every week! There's a new HTML5 feature every week! We are losing our minds OMG@#$HELPUS!”
Settle down everybody. Shiny new frameworks distract you from the stability offered by the web platform: ES6 is the first major update to JavaScript since 2009, and HTML5 was 18 years in the making! More importantly, few of these innovations significantly change the architecture of web applications — we owe browser innovation and frameworks for that. But since the browser evolved in to a full-blown application runtime, we now need solid front-end architecture, and front-end architects. It's not just about JavaScript, it's about the entire browser platform. And you can't pick frameworks to simplify that platform until you understand its underpinnings.
In this workshop, we will dissect the components of a modern web client into three buckets:
I'll lay the foundations to simplify the complex world of front-end tools, frameworks, and architecture. I'll share patterns to help you manage the complexity of front-end development and back-end integration for modern web clients. And I'll convince you to never again complain about how fast the world of front-end technologies is moving.
Vue is a new, powerful framework for building real-world applications. Enterprise ready, with a rich and diverse ecosystem, Vue is the currently ranked as the #2 front end framework and is rapidly gaining on its older brother, ReactJS. Join us for this first in a comprehensive series of session which will take you from blind novitiate to visionary VueJS expert in no time!
This first session in our VueJS series begins our journey to Vuetopia with an exploration of the basics of the framework including:
Vue is a new, powerful framework for building real-world applications. Enterprise ready, with a rich and diverse ecosystem, Vue is the currently ranked as the #2 front end framework and is rapidly gaining on its older brother, ReactJS. Join us for this second in a comprehensive series of session which will take you from blind novitiate to visionary VueJS expert in no time!
In this second presentation in our VueJS series, we dive deeper in to VueJS and explore:
Engaging your users has never been more important than it is today. Competition for user attention is fierce and ruthless. There are new players on the field, however, that are changing the competitive landsacpe: Smart Speakers and Internet Robots BOTs provide channels to engage and interact with your users in amazing new ways that we never before thought possible. Join us for this deep dive into the technologies, architectural and design patterns you will need to be successful in this new space. This is a hands-on workshop in which we will develop, deploy and secure test a number of fully functional applications and experiment engaging with them using Alexa, Google Home, Facebook Messenger and other user engagement channels.
Amazon Echo, Google Home and Apple HomePod … The Home Smart Speaker revolution has begun! Join us for an exciting workshop in which we will develop skills that can be used on each of these platforms!Learn how to design, author and publish BOT-style applications for use with chat clients, Amazon Echo, Google Home and other BOT-ready platforms. Learn why these technologies represent the future of how users will interact with merchants and services on the web. Don't be left behind! Get a head start on the next wave and add this amazing set of skills to your resume with this comprehensive, fun and exciting workshop!
In the 60s and 70s, we used heavy iron, client server applications running on mainframes, accessed through terminals. In the mid-80s, we switched to heavy-weight applications which you purchased and installed on your PC. Next, in the mid-90s, we collectively bought-in to web-based applications. The turn of the century brought us into the world of mobile apps running on hand-held devices in the mid 00s. A decade later, we are due for the next evolution in delivering knowledge and services to our end users. Enter the BOT!
Join me in this workshop as we explore this new and exciting world of internet robots (or BOTs, for short). We will cover the history of this new kid on the tech block, the tools available to assist you in building and deploying BOTs and we will design, build and deploy a number of BOTs and have them interact with you live via the Facebook messenger app, Amazon Alexa and Google Home devices.
Don't wait. Future-proof your skill set today and learn how to attract, engage, retain and amaze your users!
Engaging your users has never been more important than it is today. Competition for user attention is fierce and ruthless. There are new players on the field, however, that are changing the competitive landsacpe: Smart Speakers and Internet Robots BOTs provide channels to engage and interact with your users in amazing new ways that we never before thought possible. Join us for this deep dive into the technologies, architectural and design patterns you will need to be successful in this new space. This is a hands-on workshop in which we will develop, deploy and secure test a number of fully functional applications and experiment engaging with them using Alexa, Google Home, Facebook Messenger and other user engagement channels.
Amazon Echo, Google Home and Apple HomePod … The Home Smart Speaker revolution has begun! Join us for an exciting workshop in which we will develop skills that can be used on each of these platforms!Learn how to design, author and publish BOT-style applications for use with chat clients, Amazon Echo, Google Home and other BOT-ready platforms. Learn why these technologies represent the future of how users will interact with merchants and services on the web. Don't be left behind! Get a head start on the next wave and add this amazing set of skills to your resume with this comprehensive, fun and exciting workshop!
In the 60s and 70s, we used heavy iron, client server applications running on mainframes, accessed through terminals. In the mid-80s, we switched to heavy-weight applications which you purchased and installed on your PC. Next, in the mid-90s, we collectively bought-in to web-based applications. The turn of the century brought us into the world of mobile apps running on hand-held devices in the mid 00s. A decade later, we are due for the next evolution in delivering knowledge and services to our end users. Enter the BOT!
Join me in this workshop as we explore this new and exciting world of internet robots (or BOTs, for short). We will cover the history of this new kid on the tech block, the tools available to assist you in building and deploying BOTs and we will design, build and deploy a number of BOTs and have them interact with you live via the Facebook messenger app, Amazon Alexa and Google Home devices.
Don't wait. Future-proof your skill set today and learn how to attract, engage, retain and amaze your users!
Engaging your users has never been more important than it is today. Competition for user attention is fierce and ruthless. BOTs and Smart Speakers can thrill your users and give you the edge over your competitors. Join us for a fast-paced and entertaining exploration of this new way to attract, engage, retain and amaze your users!
BOTs are a new and compelling way to engage with users. Want to increase your conversion rates by 10 or 20%? Deploy an effective BOT and watch your engagement rates soar!
In this cool and compelling session, we will create, deploy and demonstrate a fully functional BOT. Join us for a fast-paced and entertaining exploration of this new way to attract, engage, retain and amaze your users!
The end has come. REST is finally dead. The world of reactive data sources has killed it, and your users will be forever grateful. Gone from your applications are 'Refresh' buttons. Gone from your sever code are the polling routines, pinging remote services for changes. Customers dashboards update seamlessly and in real time. Your users have never been happier.
If this sounds like a world that you want to live in, join us for this awesome workshop exploring the various options available to the enterprise architect when designing and implementing the reactive software layers and constructs necessary to make this dream a reality today!
Users are demanding applications which keep them informed of new events as soon as they happen. They are no longer willing to accept “Just hit the refresh button” or “It will update in a few minutes by itself” when demanding satisfaction of this new basic requirement. They are collaborating in real time, co-editing, co-authoring, 'co-laborating' with colleagues across the country and around the world, chatting over the phone or VOIP while working together via your app. They want their updates to travel from their laptop to their co-workers screens as fast as their voice reaches them through the phone. This is a tough requirement to meet, especially when trying to put a modern face on a legacy app or integrating a shiny, new, reactive app with a legacy, REST-based datasource.
And it is not just your end-users that are clamoring for reactive data sources. No, the requirements for server-to-server communication of changes to data or state have forever changed. REST no longer is King in the world of web services. REST just doesn't cut the mustard any longer. Corporate users of your data services are demanding more flexible, reactive options when consuming your endpoints.
Join us for this thought provoking and exploratory workshop and learn the what, why and how of dealing with these new architectural challenges as we explore how you can architect your new or existing stack to satisfy the ever-increasing demand for 'real-time' applications and data services fed by reactive data sources regardless of your current technology choices.
This workshop is for developers of all levels from any programming language background. The patterns discussed will be applicable to all software stacks.
The end has come. REST is finally dead. The world of reactive data sources has killed it, and your users will be forever grateful. Gone from your applications are 'Refresh' buttons. Gone from your sever code are the polling routines, pinging remote services for changes. Customers dashboards update seamlessly and in real time. Your users have never been happier.
If this sounds like a world that you want to live in, join us for this awesome workshop exploring the various options available to the enterprise architect when designing and implementing the reactive software layers and constructs necessary to make this dream a reality today!
Users are demanding applications which keep them informed of new events as soon as they happen. They are no longer willing to accept “Just hit the refresh button” or “It will update in a few minutes by itself” when demanding satisfaction of this new basic requirement. They are collaborating in real time, co-editing, co-authoring, 'co-laborating' with colleagues across the country and around the world, chatting over the phone or VOIP while working together via your app. They want their updates to travel from their laptop to their co-workers screens as fast as their voice reaches them through the phone. This is a tough requirement to meet, especially when trying to put a modern face on a legacy app or integrating a shiny, new, reactive app with a legacy, REST-based datasource.
And it is not just your end-users that are clamoring for reactive data sources. No, the requirements for server-to-server communication of changes to data or state have forever changed. REST no longer is King in the world of web services. REST just doesn't cut the mustard any longer. Corporate users of your data services are demanding more flexible, reactive options when consuming your endpoints.
Join us for this thought provoking and exploratory workshop and learn the what, why and how of dealing with these new architectural challenges as we explore how you can architect your new or existing stack to satisfy the ever-increasing demand for 'real-time' applications and data services fed by reactive data sources regardless of your current technology choices.
This workshop is for developers of all levels from any programming language background. The patterns discussed will be applicable to all software stacks.
A wonderful workshop adventure with a wonderful language on the client side.
Entirely written in JavaScript it is meant as a wholesale replacement on the front end. Derived from Haskell, Elm is fast, elegant, and concise. Elm also hides much of the complexities away including side effect management, event management, and exception handling where the programmer, the happy programmer might I add just focuses on the core.
This workshop encompasses:
Install Elm: For instructions visit…
https://guide.elm-lang.org/install.html
The site has installers for Mac, and Windows, you can use npm-install to install what you need.
If you don't want to install anything and try the language on the web, you can also use https://ellie-app.com/
Have your favorite editor installed and ready. There are many resources for your favorite editor
WebStorm/IDEA - Elm plugin (Not the elm-language plugin)
VIM - elm-vim plugin
Emacs - elm-mode
Sublime - Elm Language Package Support
VSCode - Elm Language Support
Atom - Language-elm Package
A wonderful workshop adventure with a wonderful language on the client side.
Entirely written in JavaScript it is meant as a wholesale replacement on the front end. Derived from Haskell, Elm is fast, elegant, and concise. Elm also hides much of the complexities away including side effect management, event management, and exception handling where the programmer, the happy programmer might I add just focuses on the core.
This workshop encompasses:
Install Elm: For instructions visit…
https://guide.elm-lang.org/install.html
The site has installers for Mac, and Windows, you can use npm-install to install what you need.
If you don't want to install anything and try the language on the web, you can also use https://ellie-app.com/
Have your favorite editor installed and ready. There are many resources for your favorite editor
WebStorm/IDEA - Elm plugin (Not the elm-language plugin)
VIM - elm-vim plugin
Emacs - elm-mode
Sublime - Elm Language Package Support
VSCode - Elm Language Support
Atom - Language-elm Package
By now I bet your company has hundreds, maybe thousands of services, heck you might even consider some of them micro is stature! And while many organizations have plowed headlong down this particular architectural path, your spidey sense might be tingling…how do we keep this ecosystem healthy?
In this talk, I will go beyond the buzzwords into the nitty gritty of actually succeeding with a service based architecture. We will cover the principles and practices that will make sure your systems are stable and resilient while allowing you to get a decent night's sleep!
It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility, cost them large sums of money, and those accountable undoubtedly lose their jobs. Security requires you to be proactive. Keep your employer out of the headlines by learning some key security best practices.
This hands-on workshop is designed to teach you how to identify and fix vulnerabilities in Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities.
It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility, cost them large sums of money, and those accountable undoubtedly lose their jobs. Security requires you to be proactive. Keep your employer out of the headlines by learning some key security best practices.
This hands-on workshop is designed to teach you how to identify and fix vulnerabilities in Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities.
At the end of the day, an architect's primary job is to communicate. Not only do we need to make sure our teams understand the design of the system well enough to implement it, we must be able to explain our decisions to an audience that isn't impressed with how many TLAs you can rattle off in one sentence. Successful architects need to seamlessly transition from in depth technical conversations to budget meetings to discussions with end users adjusting the message to fit the audience.
While oral communication is key, good architects also spend a good deal of time putting pixel to screen via email, IM and various architectural documents we're expected to create. We need to write clearly and concisely while also knowing when the best course of action is to pick up the phone or walk to someone's desk.
In this talk, we'll explore the various methods that we as architects use to communicate with our stakeholders. We'll talk about knowing our audience, being able to present as well as how to run a good meeting. We'll discuss various patterns (and antipatterns) of presenting along with some concrete advice on how to do it better. At the end of the day, our job is to tell effectively tell a story - this talk will look at ways to do that.
Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.
In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.
-Java 8 JDK or later version
-Your favorite IDE (Preferably IntelliJ IDEA Community Edition)
-git
Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.
In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.
-Java 8 JDK or later version
-Your favorite IDE (Preferably IntelliJ IDEA Community Edition)
-git
Regular Expressions are an undervalued, underutilized tool in the developer toolbox. Few programming technologies have stood a comparable test of time for their capacity to improve developer productivity, to shortcut complex tasks, to reduce dependency on various libraries, and to encourage code reuse. They also help to teach patterns and improve pattern recognition, not only for code, but for programmers themselves. Competency with regexes will make you a better programmer, regardless of your choice of language or platforms. And it will impress your peers, too!
This workshop will teach you the fundamentals of writing, debugging, and testing PCREs (Perl-compatible Regular Expressions) in multiple programming languages. With hands-on examples we will cover regex syntax, metacharacters, assertions, grouping, quantifiers, greed, capturing, balanced matches, and replacing. We'll compose regexes from scratch to parse some common string formats such as URLs, email addresses, and even JSON. Given enough time, we'll even learn look-around assertions, and examine some creating uses of regexes in the field of natural language processing.
Angular brings together some of the most promising new technologies in the web space like Components, Observables, Window.fetch all the while bundling together a set of “best” practices like dependency injection in one development stack. If you are looking to build powerful single page applications then Angular is your friend. 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.
This session will focus on Angular 12
In this workshop we will get down and dirty with Angular. In this workshop we will start with the very basics of how to bootstrap our Angular application, and work slowly towards making REST-ful AJAX requests to a backend. List of topics include
NgModule*ngFor@Inputs and @OutputsHttp and Observablesrouter-outletAlong the way we we prescribe to some established practices like directory structure, naming, and some tricks to make our development life easier.
First, install the angular-cli using the instructions in their README.md.
Then please follow all the instructions listed in this README to get your workshop source-code.
Ensure that everything wakes up just as the README describes
See you soon!!
New architectural paradigms like microservices and evolutionary architecture, as well as the challenges associated with managing data and transactional contexts in distributed systems, have generated a renewed interest in disciplined software design and modular decomposition strategies. We know that the secret to obtaining the benefits of these architectures is getting the boundaries right, both at the team and the component/service level! Fortunately, there is a mature, battle-tested approach to system decomposition that is perfect for these architectures: Domain-Driven Design.
In this workshop, we'll cover the following topics:
You'll leave the workshop with a solid understanding of DDD and how it can help you best decompose your domain and business capabilities so that you can be more effective with modern architectures.
Attendees will require a laptop with the following capabilities:
It would also be helpful to have a free Realtime Board account, or failing that, a presentation/diagramming tool you feel comfortable and productive using.
A basic understanding of Java frameworks like Lombok, JUnit, AssertJ, Mockito is useful.
By the end of this conference you will have learned many new tools and technologies. The easy part is done, now for the hard part: getting the rest of the teamand managementon board with the new ideas. Easier said than done.
Whether you want to effect culture change in your organization, lead the transition toward a new technology, or are simply asking for better tools; you must first understand that having a “good idea” is just the beginning. How can you dramatically increase your odds of success?
You will learn 12 concrete strategies to build consensus within your team as well as 6 technique to dramatically increase the odds that the other person will say “Yes” to your requests.
As a professional mentalist, Michael has been a student of psychology, human behavior and the principles of influence for nearly two decades. There are universal principles of influence that neccessary to both understand and leverage if you want to be more effective leader of change in your organization.
In this session we discuss strategies for getting your team on board as well as when/how to approach management within the department and also higherup in the organization.
In Part 1, you learned the core principles of influence and persuasion. How to we take this back to the office and apply what we've learned?
We dive deep in to specific strategies to get both the team and the business on board with your ideas and solutions. We cover several realworld patterns you can follow to be more effective and more persuasive. Part 1 was conceptual, part 2 is practical.
This talk discusses the progression from a monolithic application, where the application and user data are in the same database, to a microservice architecture, where the application and user data are in separate databases.
It covers the history behind sessions and some of the issues with them. It then builds on this by introducing tokens to manage identity and finally ends with a complete discussion of JSON Web Tokens (JWTs). I cover what JWTs are, how they are used, the benefits and some of the issues with them.
As your organization changes from a monolithic architecture to microservices, or you are looking at what this type of change requires, a key component to consider is identity and user management.
This talk will discuss the progression from monolithic identity to microservice based identity. You’ll learn about techniques to make the switch less painful and pitfalls to watch out for during the process.
As Cloud computing becomes more popular and many businesses are keen to adopt it,one of their major concerns is security. In spite of the hype accompanying it and the success stories from the large organisations who have adopted, there are also numerous examples of breaches that have been experienced in the cloud. Many businesses would like to know how to create a secure cloud infrastructure to ensure that all their applications and data is well protected.
This talk is based on my experience in different projects that I have been involved in, some pitfalls that my team has fallen into and considerations that we can take while preparing for new cloud infrastructure.
This talk is not about a particular cloud vendor solutions but about the questions and considerations to take to ensure that your cloud infrastructure is secure.
The considerations include:
Ensuring data is securely protected from anyone who would want to access it.
Encrypting the data so that if it got to the wrong people
Authentication to ensure that only the authorised people can access the data
Enabling due diligence so that data is not accessible by those who eavesdrop and would like to modify it.
Protecting the infrastructure from Denial of Service attacks(DOS) from both internal and external sources
This talk also highlights some common pitfalls:
Using components for a different purpose other that what it is created to for.
Waiting till after the application is built before preparing the infrastructure.
Creating the infrastructure then thinking about the security at the last minute.
At the end of this session, attendees:
Are able to evaluate the level of security that they need
Can reorganise their priority while designing for their cloud infrastructure
Are equipped to create a highly secure infrastructure
As the cloud becomes more popular, many cloud-inexperienced architects wonder whether migration to the cloud is the correct way to scale. When they decide to migrate they have to figure out where to start from and which components to use. This talk is not about a particular cloud vendor but the questions and considerations to take while deciding on a cloud architecture for your business.
After deciding to migrate to the cloud, the architecture design will determine the success rate of the infrastructure. This architecture needs to be robust and well thought of to ensure that it handles all the requirements at hand and flexible enough for the future.
This talk is about considerations to take while designing a system, including:
The intended clients
Investment decisions
The business strategy
The development team
Choice of tools
Good development practices
Here we also discuss common pitfalls of the architecture design process, including choosing tools.
To simplify development and deployment, you want everything in the same artifact, so you put your React app “inside” your Spring Boot app, right? But what if you could create your React app as a standalone app and make cross-origin requests to your API? A client app that can point to any server makes it easy to test your current client code against other servers (e.g. test, staging, production). This session shows how to develop with Java 8, Spring Boot, React, and TypeScript. You’ll learn how to create REST endpoints with Spring MVC, configure Spring Boot to allow CORS, and create an React app to display its data. If time allows we’ll cover authentication with OpenID Connect and deployment to Cloud Foundry.
This is a presentation that I used to do about Angular, but since so many people speak about Angular, I decided to do it for React.
OAuth is not an API or a service: it is an open standard for authorization and any developer can implement it. OAuth is a standard that applications can use to provide client applications with “secure delegated access”. OAuth works over HTTP and authorizes Devices, APIs, Servers and Applications with access tokens rather than credentials, which we will go over in depth below. OpenID Connect (OIDC) is built on top of the OAuth 2.0 protocol. It allows clients to verify the identity of the user and, as well as to obtain their basic profile information.
This session covers how OAuth/OIDC works, when to use them, and frameworks/services that simplify authentication.
This talk covers security at each level: server, database, and application. I cover how to secure a Linux server, secure the database, and finally to secure the application.
This presentation is a step-by-step guide that includes two-factor authentication, SSH security, intrusion detection, permissions, sockets, proxies, grants, password encryption, entropy, SQL injection, and social hacking.
On the NFJS tour, there are questions that seem to come up again and again. One common example is “How do we determine which new tools and technologies we should focus our energy on learning?” another is “How do we stop management from forcing us to cut corners on every release so we can create better and more maintainable code?” which, after awhile becomes “How can we best convince management we need to rewrite the business application?”
There is a single metaanswer to all these questions and many others.
It begins with the understanding that what we as engineers value, and what the business values are often very different (even if the ultimate goals are the same) By being able to understand these different perspectives it's possible to begin to frame our arguments around the needs and the wants of the business. This alone will make any engineer significantly more effective.
This session picks up from where “Stop writing code and start solving problems” stops discussing what is value, how do we align the values of the business with the needs and values of the engineer.
If you’ve spent any amount of time in the software field, you’ve undoubtably found yourself in a (potentially heated) discussion about the merits of one technology, language or framework versus another. And while you may have enjoyed the technical debate, as software professionals, we owe it to our customers (as well as our future selves) to make good decisions when it comes to picking one technology over another.
In this talk, I will explore what criteria we should consider when comparing technologies, how we can avoid burning platforms as well as what to do when we’ve reached a dead end. We will also apply these techniques to a current technology or two.
In the past, the software development process was divided into various stages, from the business defining the requirements, then the developers building the software, then the testers test it to ensure that there are no bugs in the application, then it is passed over to the operations team who release it to production and a support team to maintain it.
Over time the process has been changing to accomodate feedback to each stage of the software lifecycle and release software faster by bringing the team to work collaboratively and make it less of a staged process. A part of this improvement, a devops culture has emerged where the developers and the operations team work together in the development and deploying the application. This in itself has brought up a lot of challenges while still leaving the technical support of the application to another team, who did not develop it.
This talk:
Highlights misconceptions of the various team functions
Evaluates various ways to streamline the process of building, releasing and supporting software
Evaluate a way forward where the whole team can achieve their needs and continue being productive.
Examine what is in it for the developers? The operations team? The business? The customer?
The talk is conducted in a well paced, highly-interactive style to keep the audience engaged throughout with examples that are drawn from previous projects that I have worked on.
How do you build an API that isn't obsolete as soon as it goes live? This Lessons from the Field talk will take you on our 8 year journey culminating with the current rollout of api.nfl.com.
From previous generations of the API yields API Design Principles, hints on how to be pragmatic, various technologies tried and technologies currently is use.
Creating new domain objects in a microservice architecture can result in the following quandry: should an existing service be augmented or should a new service be created. When the objects do not fit within existing services, this results in having pico services, many trivial services to support the new domain objects.
Enter GOLD - a GraphQL based open source library that allows for the dynamic specification of domain objects and management of their instances. It is the central component of a single microservice that powered superbowl.com for Superbowl LI. Going foward, the service will power key aspects of both nfl.com and the mobile products.
We developers really like code.
Code, being plain-text, can be version-controlled, versioned, and follow a traditional SDLC lifecycle.
For the longest time however, we were forced to live with having most of our Ci/Cd and server configurations live outside of our codebases, often at the mercy of infrastructure/operations teams.
With the evolution of DevOps comes the notions of constructs like IaaC (Infrastructure-As-A-Code), and with Jenkins 2.0, we can now manage our Jenkins jobs configurations as code!
In this session we will explore the concept of “Pipelines-As-A-Code”, including the DSL that Jenkins offers, and how we can use this to configure Jenkins jobs via simple, version-controlled Jenkins files. We will see how we can create Jenkins jobs by autodiscovering repositories, as well as when we branch our code to create releases.
Back in the day, it used to be so simple. Our projects had a main.js file that contained a few hundred lines and every so often the corporate communication department would ship out some new CSS files. But now things are not quite so easy. With more and more single page apps containing thousands or hundreds of thousands of lines of JavaScript, we're going to need a bigger boat.
In this talk I will explore various options you can deploy on your projects to tame the mass of code that lives on the front end of our applications. From NPM to Gulp to Webpack, this talk will help you establish a front end pipeline.
Let me guess - your company is all in on “the Cloud” but no one can really agree what that means. You’ve got one group Dockering all the things while another group just rearchitected the Wombat system as a set of functions…as a service. It is enough to make a busy developer’s head spin - how do we make sense of all the options we have? I hate to burst your bubble, but there are no silver bullets, just a set of tools that we can leverage to solve problems. And just as a master carpenter knows when to use their favorite framing hammer and when they need to reach for the finish hammer, we need to use the right tool at the right time to solve our problems.
In this talk we will survey the various options today’s application teams have at their disposal looking at the consequences of various approaches. We will clear up the buzzword bingo to give you a solid foundation in various cloud computing approaches. Most importantly, we will discuss why the right answer will almost always be: and not or.
Rod Johnson, creator of Spring, says TypeScript his new favorite language. “It's just so useful!” After working in Scala, Java, and Clojure for years, I have to agree. TypeScript is a perfectly practical compromise. It's designed for developers, not theorists.
If you like static types, come learn what TypeScript offers that even Scala doesn't. Duck typing is charming when it includes unions and literals and partials.
If you hate static types, learn how to keep them out of your way until they become useful. There are tricks for this.
This session will cover the TypeScript language, with a focus on back-end development in Node. I'll cover some of the ways Node differs
from the JVM, especially dependency loading and concurrency. I'll focus on gradual typing: how to evolve a codebase from flexible to
safe. Learn how to get rid of typing.
TypeScript is not a language for zealots. It is a language for developers who want to get work done and get it mostly right. Come let
me sell you on it, or teach you more about its interesting and useful corners.
With new frameworks every day, what's one more? In this workshop we will code a simple, lightweight JavaScript framework. More importantly, we will examine the features that most frameworks address, patterns to use along the way, and reasons why you may or may not need a framework at all. This workshop will teach the keys to becoming a skilled front-end developer, and show you what bits of HTML5, CSS3, and JavaScript you'll need to build great applications.
There's no better way to learn JavaScript than to write a simple framework! Some of the features we will create include:
You will find a great many use cases that don't need a framework at all, especially if you're using modern browsers. We will discuss those use cases, features in HTML5, CSS3 and ES6+ which help, and a whole bunch of JavaScript patterns to make developing rich web applications easy and maintainable.
With new frameworks every day, what's one more? In this workshop we will code a simple, lightweight JavaScript framework. More importantly, we will examine the features that most frameworks address, patterns to use along the way, and reasons why you may or may not need a framework at all. This workshop will teach the keys to becoming a skilled front-end developer, and show you what bits of HTML5, CSS3, and JavaScript you'll need to build great applications.
There's no better way to learn JavaScript than to write a simple framework! Some of the features we will create include:
You will find a great many use cases that don't need a framework at all, especially if you're using modern browsers. We will discuss those use cases, features in HTML5, CSS3 and ES6+ which help, and a whole bunch of JavaScript patterns to make developing rich web applications easy and maintainable.
Development teams often focus on getting code to production losing site of what comes after the design and build phase. But we must consider the full life cycle of our systems from inception to deployment through to sunset, a discipline many companies refer to as site reliability engineering.
While your organization may or may not have an SRE team, you have someone playing that role and we can all benefit from looking at the principles and practices that we can bring to bear on our projects. In this talk, I will introduce the concepts of SRE and how you can adopt these ideas on your applications.
As a software developer, you've likely come across at least one veteran in our field who has shared tales of the old days when they used punch cards to give instructions to a computer. Thankfully, those days are long gone. Over time, the way we interact with machines has evolved through various stages such as textual, graphical, and touch/gestural user interfaces…up to today where Siri, Alexa, and Google Home are ushering in a new era of voice user interfaces.
In this session, we'll focus on Alexa, the voice assistant present in Amazon's line of Echo devices. We'll explore the Alexa Skills Kit (ASK) and see how to construct voice UIs (known as “skills”) to do our bidding. We'll see how to back those skills using Spring, including Spring MVC and Spring Cloud Function. And maybe, one day, we'll tell future generations about how we once had to actually touch computers.
Programming is a series of frustrations. Everything we do, we could do better or faster if we only had our tools set up just so. If our error messages were a little better, our code a little cleaner, our tests a lot wider. When we spend time on this, it's known as “yak shaving,” and it can get messy.
How do you balance the work you’re supposed to be doing with the work that makes your work, work? Dive into the yak stack with me. We'll see five different species of yak, and discuss how and when to tackle each one. At the bottom of the yak stack, we might find the Golden Yak, with secret wisdom engraved on its skin.
This session will give you reasons to spend time smoothing your development experience, and clues for where to spend that time in ways that help your whole team.
As Tech Leaders, we are presented with problems and work to find a way to solve them, usually through technology. In my opinion this is what makes this industry so much fun. Let's face it - we all love challenges. Sometimes, however, the problems we have to solve are hard - really hard. So how do you go about solving really hard problems? That's what this session is about - Heuristics, the art of problem solving. In this session you will learn how to approach problems and also learn techniques for solving them effectively. So put on your thinking cap and get ready to solve some easy, fun, and hard problems.
Agenda:
Microservices continues to be the latest buzzword in the industry, and probably will be for some time. If you are not sure what microservices is or want to start getting your feet wet in understanding the basics of this architecture style, then this session is just right for you. In this session I will cover the basics of the microservices architecture pattern. We'll talk about distributed architecture, what a microservice is, what the bounded context means, how to determine the right level of service granularity, the dangers of inter-service communication, and the role of the API layer. By the end of this session you will have a good idea of what the microservices architecture style is all about and whether it is a good fit for you.
Agenda:
.
.
Jorge Santayana is famous for saying “Those who cannot remember the past are condemned to repeat it”. When SOA (Service-Oriented Architecture) was all the craze, everyone got all excited about services, but forgot about the data. This ended in disaster. History repeats itself, and here we are with Microservices, where everyone is all excited about services, but once again, forgets all about the data. In this session I will discuss some of the challenges associated with breaking apart monolithic databases, and then show the techniques for effectively creating data domains and how to split apart a database. I consider the data part of Microservices the hardest aspect of this architecture style. In the end, it's all about the data.
Agenda
Once you break things apart into microservices, you must then put them back together. In other words, individual services still sometimes need to talk to one another to complete a given business transaction, whether that transaction is synchronous or asynchronous. In this session I talk about the various patterns of communication within microservices - orchestration, aggregation, and adapters. I also talk about coupling between services, including stamp coupling and bandwidth issues, and how to address these common communication woes.
Agenda
Have you ever wondered how to share data between microservices? Have you ever wondered how to share a single database schema between hundreds (or even thousands) of microservices (cloud or on-prem)? Have you ever wondered how to version relational database changes when sharing data in a microservices environment? If any of these questions intrigue you, then you should come to this session. In this session I will describe and demonstrate various caching strategies and patterns that you can use in Microservices to significantly increase performance, manage common data in a highly distributed architecture, and even manage data synchronization from cloud-based microservices. I'll describe the differences between a distributed and replicated cache, Using live coding and demos using Hazelcast and Apache Ignite, I'll demonstrate how to share data and also how to do space-based microservices, leveraging caching to its fullest extent.
Agenda:
Reactive architecture patterns allow you to build self-monitoring, self-scaling, self-growing, and self-healing systems that can react to both internal and external conditions without human intervention. These kind of systems are known as autonomic systems (our human body is one example). In this session I will show you some of the most common and most powerful reactive patterns you can use to automatically scale systems, grow systems, and self-repair systems, all using the basic language API and simple messaging. Through code samples in Java and actual run-time demonstrations, I'll show you how the patterns work and also show you sample implementations. Get ready for the future of software architecture - that you can start implementing on Monday.
Agenda
There are many different uses for Apache Kafka. It can be used as a streaming broker, event broker for transactional data, and even a database. This session is about understanding streaming architecture and how to implement it using Apache Kafka. I start this session by talking about some of the streaming architecture patterns, then dive into how Apache Kafka works using the Core API. Using live coding examples in Apache Kafka, I also talk about the differences between Kafka and regular messaging (RabbitMQ, ActiveMQ, etc.) and when you should use each. I end this session by putting everything together, showing an actual streaming architecture using Kafka within a Microservice ecosystem for gathering various metrics for business and operational monitoring and reporting.
Agenda:
One of the expectations of any software architect is to analyze the current technology environment and recommend solutions for improvement. This is otherwise known as continually assessing architecture vitality. Too many times software architects fail to regularly perform this task, leading to emergency refactoring efforts to save a troubled system from failure. The question is, what does it mean to assess an application architecture? In this session we will explore static analysis metrics and tools and techniques for leveraging those metrics for determining structural decay. Using a real-world large-scale application, I'll show you how to leverage code metrics to find (and fix) structural decay before it gets you into trouble.
Agenda
While there are dozens of activities within an enterprise architecture effort, there is only one primary outcome - an enterprise architecture roadmap. Roadmaps describe what efforts (i.e., projects) need to be done to meet a specific objective, the dependencies between those efforts, and the prioritization of those efforts. In this session I'll cover the four main models that make up an EA roadmap and show you techniques for how to identify projects, classify projects, prioritize projects, and finally illustrate these efforts through consolidated roadmap views. By the end of this session you'll have a clear view of why enterprise architecture is needed, the purpose behind it, and how to create an effective and clear enterprise architecture roadmap.
Agenda
There are many traditional approaches to enterprise architecture. Unfortunately, these traditional approaches are one of the reasons EA fails in today's world. In the first part of this session I'll describe and demonstrate the traditional approaches to EA, explain why they fail, and then show you several modern approaches to enterprise architecture that hold lots of promise in transforming EA to the 21st century. In the second part of this session I'll then describe 4 different enterprise architecture strategies for overall EA team structure, governance, process, and standards.
Agenda
Organizing and governing enterprise architecture models and processes is a daunting task. No wonder so many people are wondering whether an enterprise architecture framework will help. Understanding various enterprise architecture frameworks like Zachman, TOGAF, and FEAF is the first step. More important, however, is knowing whether you need an EA framework at all. In this session I will start with the basics of the Zachman Framework, TOGAF (The Open Group Architecture Framework), and FEA (Federal Enterprise Architecture) so that you can gain a complete understanding of how each of these frameworks work. During the journey of these frameworks I will continually point out the strengths and weaknesses of each framework to arrive at the best part of the session - how to build your own EA Framework that works for you and your situation.
Agenda
Continuous delivery is not a pipe-dream technology, reserved only for the “cool kids” at hip tech startups. Although it's not easy, many concepts are within reach of most teams. That being said, it require more than simple technology changes. Attend this session to learn the fundamental concepts of CD, how to build your CD pipeline with Gradle and Jenkins, and recommendations on tools and best practices.
No prior knowledge is assumed and this talk will start from first principles.
Part one begins with a detailed overview of what CD is (and isn't) and how to build a business case for CD. Making both the technical case and business case for CD is vital as it's necessary to get the entire organization on board with the changes required.
Part two is a deeper dive into building a continuous delivery pipeline with Gradle and Jenkins (although the broader concepts can be applied to the tooling of your choice) You'll see how easily Gradle integrates with Java and how to leverage configuration management and gradle plugins to build all of your quality gates.
Scala for Java Developers is a full live code and fast paced presentation and workshop (laptops optional), and this is all about the Scala language.
Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala. Laptops optional so you can try stuff out on your machine and create questions of your own!
Some things will be required if you to participate in the workshop
Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference, you can prepare Scala before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference. But it is preferred to do the installation before the event.
For MacOSX:
For Windows
For Linux
You may also want to take the opportunity to load some Scala Plugins onto your favorite IDE and Editor. Below is a list of resources that you can use to enhance your environment so that you can enjoy Scala syntax highlighting and other helpful tools like refactoring, debugging and analysis.
Eclipse - The Eclipse has an IDE plugin for Scala called aptly Scala-IDE. You can either download the complete Scala IDE which includes the complete Eclipse download. You can also download the plugin. 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. Scala-IDE is also available at the Eclipse Marketplace, although I would recommend getting the latest instructions from scala-ide.org
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
VSCode - Download the “Scala Language Plugin” from the plugins within VSCode.
That is it. Hope to see you soon.
Scala for Java Developers is a full live code and fast-paced presentation and workshop (laptops optional), and this is all about the Scala language. This is Part 2, continuing where we left off from Part 1.
Scala is a wonderful functional/hybrid language. It will become one of the 5 languages that you will need to know to be a highly successful JVM developer in the very near future (others being Groovy, Clojure, Java 8, and JRuby). Scala, as opposed to some of the other languages, has quite a learning curve. This presentation was built for questions. We will start with some basics, how this presentation will flow and end will be up to you, the audience. Bring your intellect, curiosity, and your questions, and get ready for some Scala.
Some things will be required if you to participate in the workshop
Unfortunately, Internet connectivity is sometimes a dicey affair and at times it can rain on our parade. To avoid having to wait for the install at the conference, you can prepare Scala before the conference! If you don't have the opportunity to do this, we will have either memory sticks or private networks at the conference. But it is preferred to do the installation before the event.
For MacOSX:
For Windows
For Linux
You may also want to take the opportunity to load some Scala Plugins onto your favorite IDE and Editor. Below is a list of resources that you can use to enhance your environment so that you can enjoy Scala syntax highlighting and other helpful tools like refactoring, debugging and analysis.
Eclipse - The Eclipse has an IDE plugin for Scala called aptly Scala-IDE. You can either download the complete Scala IDE which includes the complete Eclipse download. You can also download the plugin. 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. Scala-IDE is also available at the Eclipse Marketplace, although I would recommend getting the latest instructions from scala-ide.org
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
VSCode - Download the “Scala Language Plugin” from the plugins within VSCode.
That is it. Hope to see you soon.
It happens to us all; there are simply days where it seems impossible to get anything done. This session focuses on techniques and tips to get into the zone, stay in the zone and to protect your productivity, even in disruptive environments.
Rather than focusing on any one productivity methodology (e.g. GTD) This talk analyzes the internal and external factors that affect our productivity and offers broader strategies to get back on track.
For us developers, there has been a lot of change in the infrastructure where our apps will run. New to the mix is running in containers in some type of cloud enabled environment. After some basic concepts around containers and running them in production we go full on ALL DEMO, ALL THE TIME! I am going to show how to accomplish your local fast iteration development but now seamlessly deploy that to a frickin’ awesome run time platform a container platform based off of Kubernetes.
Come and see how the future of development is evolving!
For most of my lifetime in the computing world, data crunching and web serving were two very separate worlds. If a web app wanted access to the analysis there was a long process of ETL, DB work, imports and exports, and bribing various network and storage people for the resources you needed. With the rise of containers, orchestration, cheap computing and networking, and over 10 years of people tackling large problems at new scales we have finally come to a convergence.
It is now possible for us to actually use the same hardware, and more importantly, clustering software to converge both types of workloads. We are going to lay out a high level vision of how this can look with Containers, Kubernetes, web servers, and Apache Spark. This can be considered a germ of what we can look to build in the future. We will demo this in action and show this is actually now achievable for mere mortals such as us. This convergence allows data analysis move from custom R or Python scripts on an analyst’s desktop to a front-line accessible web app. At the same time, the analyst can “constrain” the analysis to prevent “statistical overreach”.
The maturing of industry projects and tools around cloud development and administration has led to the formation of the Cloud Native Computing Foundation. This new foundation is similar to the Apache Foundation in that it provides governance over projects from incubation to maturity. These projects define the current and future standards of the cloud which is important for all devops teams to be aware of. This session is a guided at jet speed tour of each project and how it fits in the eco-system.
This session will briefly cover each of the CNCF projects will a outline of:
The projects covered include:
Science is a systematic process of engineering feedback loops that help you learn. This learning isn't arbitrary. In science, we're on a mission to discover useful clues that help us understand a system. Whether that system is a product we're trying to design, a process we want to improve, or an application we're trying to understand – the art of engineering feedback loops still applies.
In this session, we'll breakdown a foundational framework for engineering feedback loops based on Statistical Process Control (SPC) theory from the Lean Manufacturing world, applied to the art of problem-solving in software development. We'll start with explicit models for the problem-solving process itself, then discuss a framework for engineering feedback loops on top.
Ramp up your engineering skills like never before, by mastering the art of the feedback loop.
In the world of legacy code, we often end up inheriting a tangled ball of mess with a lack of automation, and no clear surfaces for testing. Yet still, under these circumstances, we're expected to safely make changes without regressions. Where do we start? How do we tackle this challenge? How do we get a handle on re-architecture?
We'll start this discussion with a first-hand use case and example – tackling the re-architecture of an 800k line JBoss application with near-zero unit tests. Ugh. The only option on the table was Selenium. UGH.
Let's talk about alternative strategies. How have you tackled similar situations? How could we build a data-driven regression framework without going through the UI?
This session will be 70% discussion, focused on the challenges you've faced in test harnessing legacy code. Be ready to share the story of a challenge your facing, or help out your fellow attendees with advice.
We'll discuss the strategies used to conquer the challenge in this case study, and how you could apply the same pattern to your own projects.
How much time have you spent automating tests, then discovered the tests were mostly useless, brittle, time-consuming, and hard to understand? How many times have you deleted everything, started over, and came with a substantially better strategy for next time?
In this session, we'll dig into one disaster story at a time, explore the nuts & bolts, then distill lessons learned and improvement ideas.
One of the best ways to evolve our brain's “Anti Pain” gut feel system is through sharing disaster experiences, reflecting on alternatives, and distilling patterns and lessons learned.
As a bonus, venting your frustrations is cathartic!
Once upon a time, it was just me and my app – the days when all I had to know was “get data, put on screen.” Fast forward ten years later, and what the hell happened? The level of complexity that we deal with in modern software development is insane.
Are we really better off than we were 10 years ago, or have we just been putting out our fires with gasoline?
In this session, we'll turn the projector off, and focus on a deep-dive discussion, contrasting the world of 10 years ago versus today. Rather than generalizations and hand-waiving about the golden promises of automation and magic frameworks, we're going to question everything and anchor our discussions in concrete experience.
Looking back across your career in software development, how has the developer experience changed?
First, we'll dig into the biggest causes of friction in software development, and how our solutions have created new problems. Then we'll focus on distilling strategies for overcoming these challenges, and how we can take our teams, and our industry in a better direction.
Some teams seem to have some mysterious chemistry from the beginning. Other teams wallow, bicker, and slog their way to uncertain results. What makes one team soar, and another stumble? It's not just chance.
In this session, we'll explore the essential ingredients that result in that mysterious “chemistry.” For example, we’ll examine the prerequisites for cohesion, and factors that pull teams apart. We'll look at myths and realities of software teams.
You'll gain tools to assess your agile team, and insights on how to adapt the environment for growing great teams.
Learning Outcomes:
Identify the essential elements for great teams.
Strategies to adapt the environment to improve the chance of team success.
Identify common pitfalls for agile teams.
Through table activities and facilitated conversation, we'll explore experiences in teams, talk about what works, and what doesn't. I'll present research about teams, and related it to concrete steps that managers, team leads, and team members can apply to their own situations.
Some teams seem to have some mysterious chemistry from the beginning. Other teams wallow, bicker, and slog their way to uncertain results. What makes one team soar, and another stumble? It's not just chance.
In this session, we'll explore the essential ingredients that result in that mysterious “chemistry.” For example, we’ll examine the prerequisites for cohesion, and factors that pull teams apart. We'll look at myths and realities of software teams.
You'll gain tools to assess your agile team, and insights on how to adapt the environment for growing great teams.
Learning Outcomes:
Identify the essential elements for great teams.
Strategies to adapt the environment to improve the chance of team success.
Identify common pitfalls for agile teams.
Through table activities and facilitated conversation, we'll explore experiences in teams, talk about what works, and what doesn't. I'll present research about teams, and related it to concrete steps that managers, team leads, and team members can apply to their own situations.
You adopted microservices architecture to fundamentally change your time-to-market, your code-to-production time from months to days, perhaps even hours. The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring Cloud annotations all throughout your business logic. The second generation of microservices architectural style was enabled by the rise of Kubernetes, now the defacto standard cloud native application infrastructure. The next generation of microservices will leverage sidecars and a service mesh.
In this session, we will give you a taste of Envoy and Istio, two open source projects that will change the way you write distributed, cloud native, Java applications on Kubernetes & OpenShift. Demonstrations of tracing, circuit-breaking, traffic shaping, network fault-injection, smart canaries, dark launches and much more.
Everybody seems to be rocking with Kubernetes and OpenShift! Even your favorite repos at GitHub are running on top of it. Don't be the last developer to board this bullet train. Come and learn a LOT in this session about Kubernetes.
We will provide numerous practical tips & techniques that will take you from cloud newbie to cloud native.
This session covers the landscape of Big Data tools, technologies and best practices in 2018. You'll leave this session armed with the knowledge you need to build Big Data solutions by assembling the best technologies for you.
We cover the components of a big data pipeline, options available for each module and the pros, cons and best practices for each option.
Java developers have run their code in Application Servers for many years. However, the cloud paradigm brought new ways to think and design applications. One example of this change is the Serverless architecture where event-driven code is executed on an ephemeral container managed by a 3rd party. It doesn't mean that there are no servers involved, but for the developer's perspective, it means that they don't need to worry about them.
Come to this session and learn FaaS - Function-as-a-Service, open source event driven lambda style programming model for Kubernetes.
Gradle is the build tool of choice in the open source world, and rapidly becoming the standard in industry as well. Anyone who works with Gradle on a Java project knows the basics of the Java plugin and how to write simple tasks in Groovy. Gradle can do much more, however. This talk will demonstrate how to write your own custom task classes and how to create Gradle plugins from them. Other Gradle features will be demonstrated as well, including file manipulation, incremental builds, generating the Grade wrapper, and resolving conflicts in dependencies.
Gradle Inc also provides a free build scan capability to analyze build files. This too will be demonstrated, as well as profiling your build, determining dependencies, and more.
You have some modular code with a REST API. You are on your way to Microservices. Next, you package it in a container image that others can run. Simple. Now what? Your service needs to log information, needs to scale and load balance between its clones. Your service needs environment and metadata way outside its context. What about where the service will run? Who starts it? What monitors its health? What about antifragility? Updates? Networking? Oh my.
Don't get flustered. We will explore how Kubernetes simplifies the complexity of distributed computing.
This session will help you understand the terms, architecture and the mechanics of the Kubernetes tools. You will understand how to target your applications to a seemingly complex distributed compute platform.
Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts (1 of 2)
Aha moments with apps in containers can be quite liberating. The mobile space is saturated with “there's an app for that”. For us, we now expect “there's a container for that”. “Write once, run anywhere” (WORA) has changed to “Package once, run anywhere” (PORA). The growing community of containers is riding up the hype curve. We will look at many ways to assemble pods using architecture patterns you already know.
Your software package delivery and installation is no longer an rpm, deb, dmg, jar, war, native executable or a run script, it is simply an image that has a common run container command.
During the presentation, we will explore some examples on Katacoda.
Prerequisite: If you are unfamiliar with Kubernetes be sure to attend: Kubernetes Koncepts
At the 2009 Agile conference, J.B.Rainsberger declared “Integration tests are a scam”. I agree. Come see some compelling reasons why consumer-driven contract testing is a much better approach. Particularly for microservices.
We will explore different testing techniques on Kubernetes, including an important one called “Consumer-Driven Contracts”.
After a brief overview of the concepts a live demonstration will show you how to:
This is the droid you are looking for. Within this droid are hundreds of rules designed to review your code for defects, hotspots and security weaknesses. Consider the resulting analysis as humble feedback from a personal advisor. The rules come from your community of peers, all designed to save your butt.
We will explore techniques on how to add these checks to your IDE, your build scripts and your build pipelines.
Too much chatter in your pull requests? See how the analysis tools teach best practices, without ego or criticism, to a spectrum of developers. As a leader see how to develop an effective code quality intern program around this technique. We will also see some techniques to use Kubernetes to obtain reports and dashboards right on your local machine and from your continuous integration pipeline.
Ready Player One.
Welcome to the future of Augmented Reality. All physical limitations of what can exist around you, have now been lifted. In the world of AR, we can visualize anything we can dream… so dare to dream big.
In this session, we'll break down the Matrix into a buildable software architecture model – the algorithm of Life() expressed as a probabilistic Magnet Operating System. Next, we become Software Shaman responsible for shaping the metaphors and schemas that define the Oasis… welcome to the world of Reality Construction.
You might like to believe that “objective reality” and “perception” can be decoupled from one another, but the attempt at decoupling these things, is yet another layer of perception. The entire system of sense-making is emotionally-biased to explain our feelings. Rationality is a facade on top of an emotionally-wired brain.
What if we re-engineered the Game of Life from the ground up as an Augmented Reality Video Game? What does your Oasis look like?
Welcome to the future. Let's make it fun.
The GraphQL specification has been gaining traction at incredible speed but the need to define, and then maintain, a separate GraphQL schema can be a substantial barrier to entry. GLiTR is an open source framework developed at the NFL with the express purpose to help us bridge this gap.
With GLiTR, it is now possible to build a GraphQL schema directly off of the existing domain POJOs prevalent in Java programming thereby leveraging existing code and greatly reducing the development time needed to get started with GraphQL.
In this session we will dive deeper into Dockerfiles. We will explore the DSL that Dockerfiles provide to allow for the automation of image creation.
Dockerfiles provide a means to automate the creation of images, and consequently the containers within which our applications run. The Dockerfile, though minimal, provides us with everything we need to package our software, and enable it to run. In this session we will dive deep into the Docker DSL, and explore the many commands that it provides, and along the way explore some differences between similar commands, and some gotchas.
Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing…an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?
As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.
This hands on workshop covers both the theory and practice of optimizing and tuning a production MySQL Database.
Basic knowledge of Linux and SQL are expected. You'll be given ssh access to a vm to review diagnostic data and to make both code and database changes.
We live, and operate in a world where our services do not need to be available 24/7, but also respond to surges in demand, and scale down when demands are less.
Reactive systems, and reactive architectures have arisen to address this very concern.
Vert.x is a ployglot toolkit that makes writing reactive applications on the JVM possible.
With a non-blocking, event driven architecture, Vert.x can help you scale your application, leveraging the multi-threaded nature of the JVM, and the multi-core abilities of your hardware.
In this session we will take a look at Vert.x, it's programming model and architecture.
We will write some code, and explore the ecosystem around Vert.x, as well as discuss some of the gotchas that you might come across as you develop Vert.x applications.
“Forewarned is forearmed”
-Old Proverb
If it seems like humans are easy to deceive, it's because we are. The myriad traits that make humankind so eminently exploitable are practically baked into our DNA. Too often these same traits make it into the software we build. This session takes an entertaining look at why humans are so easy to fool and goes on to explore what we can do to overcome our weaknesses and build more secure software.
Security is everyone's responsibility but the burden disproportionally falls on us. As software engineers, we are the last line of defense in our organization. We build the technology and that technology is constantly scanned, probed, and tested. Building truly secure software requires going beyond mere functional requirements; it requires a complete shift in how we think about problems.