Many of us have significant experience in Java. Yet, from time to time, we get tripped up by some code that we quite did not expect to behave the way it does.
In this presentation we will take a look at some of those and get a deeper understanding of the language we use everyday.
Java has been evolving at a rapid pace. Some of the most noticed changes are the features in the language. However, there are other interesting and significant changes in Java, not related to the language but in the JDK and the ecosystem.
In this presentation we will take a look at some of those exciting changes and how we can benefit from them.
The switch feature of Java has gone through an amazing transformation. In this presentation will start with switch as a statement, transform from there to an expression, and into a full blown pattern matching syntax.
We will get quite deep into this feature to explore various usecases.
A prerelease feature in Java, structure concurrency is going to change how we do concurrent programming.
In this presentation we will take a look at the benefits of this new feature and how to make use of it.
Threads have been part of Java since the beginning. But, the new virtual threads, introduced as prerelease in Java 19, are different in how they're implemented and how we can benefit from them.
In this presentation we will learn about virtual threads, the problems they solve, and how to make use of them.
REST is, undoubtedly one of the most maligned and misunderstood terms in our industry today. So many different things have been called REST, that the world has virtually lost all meaning. Many systems and applications that self-describe as “RESTful” usually are not, at least according to REST as defined in Dr. Roy T. Fielding’s 2000 Dissertation, “Architectural Styles and the Design of Network-based Software Architectures”.
The wild success of the architecture derived by Dr. Fielding led many to want to emulate it (even when it was inappropriate to do so). As a shorthand, organizations began referring to “RESTful” systems, which exposed “RESTful” APIs. Over time “REST” became a buzzword referring to a vague generalization of HTTP/json APIs that typically bear little to no resemblance to the central ideas of REST (and thus elicit few of the benefits). Hypermedia is the central pillar and defining characteristic of the REST architectural style yet it remains almost universally absent.
Hypermedia was a revolutionary idea that, while more relevant than ever, is almost forgotten in today's tech space. Consequently few reap the benefits of this idea and ever fewer know what they might be giving up.
Although not every system needs to (or should be) RESTful, it's helpful to understand the key–and often overlooked–ideas to be able to decide if they make sense for your current next project. This session introduces the key foundational ideas and shows what these ideas look like in practices. Although hypermedia and REST don't make sense for every project or system, you'll leave this session with a better understanding of these groundbreaking ideas, practical insights on how to adopt them today, and ultimately armed to approach the trade-offs of this approach mindfully and deliberately.
The web is arguably the single most impactful revolution in human history (to date). By agreeing on a simple set of standards, we have collectively unlocked all the world's information. Documents can be discovered, retrieved, published, and shared so easily we don't even think about it.
Data, on the other hand, is a different story. Our data remains stuck in the 1980s. Locked in silos, each with a different format, interface, and conventions that must be interpreted by a human, parsed, mapped, and converted. Data is at the heart of many problems we solve today, and we produce data exponentially faster than we can consume it.
Today I can request any document from any server on the web. I need to know nothing about the underlying technology the server uses, nothing about how the information is stored or retrieved, and consume it instantly. We've been evolving those same capabilities with data over the past 20 years and the standards, tools, and technologies are reaching critical mass. The linked data revolution is now one that you can no longer ignore. Join us to see what you've been missing.
Completely Rewritten for 2023
Part one of this series introduces the ideas, motivations, and applications of linked data along with historical context. This more technical session dives deeper into the tech stack and available tooling.
We'll dive into key linked data patterns, explore semantic modeling, graph queries, and talk about applying these ideas in the field, where the rubber meets the road!
Knowledge graphs have been quietly powering the future, unlocking new capabilities that were unimaginable to most just a few years ago. The few, however, have been imagining this future for decades and we've finally arrived at, what industry analysts are calling, “The year of the knowledge graph”
This session provides a historical look at the roots of Knowledge Graphs and how the ideas have evolved over the decades along with breakthroughs in various fields, have brought us to the brink of a new era in technology. Join us to see how far we've come and what is possible next!
Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.
This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.
Kafka is a “must know.” It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs. As such, Kafka has become an essential product in the microservice and big data world.
This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.
Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.
In particular, in terms of security. Securing and hardening VMs is very different than that for containers.
In this twopart session, we will see what securing containers involves.
We'll be covering a wide range of topics, including
Understanding Cgroups and namespaces
What it takes to create your own container technology as a basis of understanding how containers really work
Securing the build and runtime
Secrets management
Shifting left with security in mind
Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.
In particular, in terms of security. Securing and hardening VMs is very different than that for containers.
In this twopart session, we will see what securing containers involves.
We'll be covering a wide range of topics, including
Understanding Cgroups and namespaces
What it takes to create your own container technology as a basis of understanding how containers really work
Securing the build and runtime
Secrets management
Shifting left with security in mind
1-1s are ubiquitous in the software engineering industry, and great leaders cherish these discussions.
What makes 1-1s so valuable?
1-1s are just like any other meeting - they are used to exchange data - be it tactical project updates, personal updates, or perspectives on how a project is going. There is also implicit data exchanged, signals that are interwoven with each word that is spoken. These are our emotions.
Emotions can be felt and observed but can be difficult to interpret and process. Our brains are in overdrive when communicating with other humans as we take in these implicit signals along with the literal words being spoken. During 1-1s, this can intensify as our focus is entirely on the other person; What signals are they sending? How will I respond? What isn’t being said here?
Emotional intelligence is the ability to identify, understand, and manage our emotions to communicate more effectively with others. In this interactive discussion, we will explore how to leverage the four emotional intelligence skills to facilitate more productive and enjoyable 1-1s.
We are knowledge workers and ultimately, we must own our growth and learning. Personal Knowledge Management is a process of collecting information that one uses to gather, classify, store, search, retrieve and share knowledge in their daily activities and the way in which these processes support work activities.
Despite taking notes, bookmarking web content, and highlighting passages in books; often we struggle to recall or rediscover these many insights we pick up daily in our work and life. This session introduces a tool and some process recommendations to never again lose discoveries and knowledge resources.
Michael shares the tools and workflow he (and many on the NFJS tour) use to write, organize and share your thoughts, keep your todo list, and build your own digital garden. These approaches naturally connects what you know the same way your brain does, and makes it easier to make everything you learn actionable and always at your fingertips.
You'll learn the basics, tips and tricks, and recommendations of these tools and practices; and leave armed to deploy these right away as you continue learning at the conference!
How does designing Microservices differ from designing more traditional applications?
What is a better way to learn than to take a problem, analyze the requirements, explore the design options, apply the concepts of bounded context, and arrive at the architecture and design of Microservices to realize the requirements?
Come to this workshop to get a practical, hands-on practice to navigate from requirements all the way to a workable solution and along the way learn about different architectural goals and approaches that can help with the design.
git client to fetch the examples and labs from a git repository.
How does designing Microservices differ from designing more traditional applications?
What is a better way to learn than to take a problem, analyze the requirements, explore the design options, apply the concepts of bounded context, and arrive at the architecture and design of Microservices to realize the requirements?
Come to this workshop to get a practical, hands-on practice to navigate from requirements all the way to a workable solution and along the way learn about different architectural goals and approaches that can help with the design.
git client to fetch the examples and labs from a git repository.
Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.
In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.
In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Game of Life is an intriguing game. At first look it looks simple, but as you look closer, it appears to be quite complex. How can we implement this game with different constraints, what are the constraints? Is it possible to use functional programming for this, to honor immutability? You see, it is intriguing.
We will discuss the constraints, think about how we may be able to solve them, and along the way discover how functional programming can play a role. We will have a fully working program, using live coding, at the end of this session, to illustrate some nice ideas that will emerge from our discussions.
The organization has grown and one line of business has become 2 and then 10. Each line of business is driving technology choices based on their own needs. Who and how do you manage alignment of technology across the entire Enterprise… Enter Enterprise Architecture! We need to stand up a new part of the organization.
This session will define the role of architects and architectures. We will walk through a framework of starting an Enterprise Architecture practice. Discussions will include:
Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.
Within this session we look holistically an engineering, architecture and the software development process. Discussing:
* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs
* Awareness of application portfolio and application categorization
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem
The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.
Just as sharpening the saw is the best way to cut down a tree… sharpening your development environment allows for a more focused more productive experience.
This session is a collection of scripts, aliases, shells, editors and tools which will super charge your development experience.
This session will cover:
Bring your machine and lets have you productive within 2 hours!
This is an introductory workshop to get started with Kubernetes. This assumes that you, the attendee, are fresh to this technology. This workshop begins with defining terms, deploying Kubernetes objects, tracking the health of your deployments, and exposing your application to the outside world. Our end goal is to have you deploy a full application on the internet.
We will begin by reviewing containers and why they are a good idea. Then we will transition into Kubernetes, what it is and when we want to use it. We will define the common tools you need to use Kubernetes. We show you how to access your Kubernetes cluster and how to deploy payloads onto your cluster. We then will dig into the common objects and the roles each object is responsible for. This workshop will also include strategies for what to do when things go wrong. Finally, we describe how to tie the whole thing securely using TLS termination, so you can get started with deploying your scalable, fault-tolerant, production application.
This is an introductory workshop to get started with Kubernetes. This assumes that you, the attendee, are fresh to this technology. This workshop begins with defining terms, deploying Kubernetes objects, tracking the health of your deployments, and exposing your application to the outside world. Our end goal is to have you deploy a full application on the internet.
We will begin by reviewing containers and why they are a good idea. Then we will transition into Kubernetes, what it is and when we want to use it. We will define the common tools you need to use Kubernetes. We show you how to access your Kubernetes cluster and how to deploy payloads onto your cluster. We then will dig into the common objects and the roles each object is responsible for. This workshop will also include strategies for what to do when things go wrong. Finally, we describe how to tie the whole thing securely using TLS termination, so you can get started with deploying your scalable, fault-tolerant, production application.
In this example-driven presentation, we'll focus on how to build reactive APIs in Spring. We'll start with Spring WebFlux, a reactive reimagining of the popular Spring MVC framework for HTTP-based APIs. Then we'll have a look at RSocket, an intriguing new communication protocol that is reactive by design.
Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.
Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.
Integration, once a luxury, is now a necessity. Doing this well, however, continues to be elusive. Early attempts to build better distributed systems such as DCOM, CORBA, and SOAP were widely regarded as failures. Today the focus is on REST, RPC, and graphql style APIs.
Which is best? The goto answer for architects is, of course, “it depends.”
In this session, we look at the various API approaches, how they attempt to deal with the challenge of decoupling client from server, evolvability, extensibility, adaptability, composability.
The biggest challenge is that needs change over time, and APIs must necessarily evolve. Versioning is challenging, and breaking changes are inevitable. You'll leave this session with a highlevel understanding of these approach, their respective tradeoffs and ultimately how to align your API approach with your architectural and organizational goals.
Mob Programming is a style of programming in which the entire team sits together and
works on a single task at a time. Teams that have worked this way have found that
many of the problems that plague normal development just melted away, possibly because communication and learning increases. Teams also find that the quality of their code increases. They find their capacity to create increases. However, the best part of all this is that teams end up being happier and more cohesive.
In this session we introduce the core concepts of mob programming and then get handson mobbing on a coding kata.
Although Java originally promised write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.
Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.
While deploying Spring applications in containers has always been possible, Spring Boot makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.
In this example-driven session, we're going to look at how to create and deploy Spring applications as container images and deploy them into a Kubernetes cluster. Along the way, we'll also get to know a few of the most useful tools that a Spring developer can employ in their development workflow when building containerized Spring applications. We'll also see how to apply patterns of Spring Cloud–such as configuration, service discovery, and gateways–using native Kubernetes facilities instead of Spring Cloud components. And we'll look at how components of the Spring ecosystem can work with your Spring applications to enable them to thrive in a Kubernetes cluster.
Test your setup: Make sure that the Docker Desktop is running and then type “kind create cluster”. It should take a minute or so, but then you should be able to type “kubectl config current-context” and see “kind-kind” listed.
Shifting business priorities, working from home, layoffs, and the end of the 5 star catered office lunch spread. The world around us can feel like dodging one !$%$ storm after the other as we navigate the chaos of modern software engineering.
In this 60 minute talk, we will plot a safe route for weathering the storm by focusing on what we have control over as a team (and hopefully coming out stronger!)
Attendees will leave with 3 exercises they can facilitate with their teams to improve team operational health, build stronger compassion for one another, and align on a shared mission to propel through the toughest climates.
According to a CareerBuilder study, only 40% of new tech leaders receive formal training when they become a boss for the first time. The rest are forced to get scrappy to quickly equip themselves with new skills, techniques, and mindsets to effectively transition into their new roles.
This workshop was designed to fill this gap; providing tactical techniques and resources for both new and seasoned technical leaders!
In this full day workshop, you will learn how successfully navigate the complexities of Engineering Management. Topics include:
Purposeful leadership, emotional intelligence, self awareness, time management, prioritizing the right things, social styles, giving feedback, career conversations, 1:1s, psychological safety, recruiting, interviewing, onboarding, measuring team metrics, motivation, engagement, team building, and building sustainable relationships.
Interactive group exercises will help you practice these new ideas and techniques in a safe and engaging environment.
You will leave with new perspectives on Engineering Management, as well as handouts and plenty of resources to grow and further develop skills in your daily work.
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
According to a CareerBuilder study, only 40% of new tech leaders receive formal training when they become a boss for the first time. The rest are forced to get scrappy to quickly equip themselves with new skills, techniques, and mindsets to effectively transition into their new roles.
This workshop was designed to fill this gap; providing tactical techniques and resources for both new and seasoned technical leaders!
In this full day workshop, you will learn how successfully navigate the complexities of Engineering Management. Topics include:
Purposeful leadership, emotional intelligence, self awareness, time management, prioritizing the right things, social styles, giving feedback, career conversations, 1:1s, psychological safety, recruiting, interviewing, onboarding, measuring team metrics, motivation, engagement, team building, and building sustainable relationships.
Interactive group exercises will help you practice these new ideas and techniques in a safe and engaging environment.
You will leave with new perspectives on Engineering Management, as well as handouts and plenty of resources to grow and further develop skills in your daily work.
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
We spend far and away more time reading code than we do writing it, but we spend far more time and money learning how to write it better. We are all familiar with the feeling of looking at a piece of code and having no idea what it does. Trying to debug it is a real chore! What if you could confidently approach unfamiliar code knowing that you can find what you need to in short order?
This session will show you some tools and techniques to be able to read and comprehend unfamiliar code more quickly. We will also go over some debugging techniques to help find bugs more quickly in unfamiliar code.
You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?
The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.
In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.
By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.
You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?
The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.
In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.
By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.
We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domaindriven design gives us the concepts and practices to better design and decompose our services.
In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.
In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.
If you need a deeper dive into DDD, then this is the session for you.
In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.
Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.
As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?
You'll need…
In this example-driven session, we're going to look at how to implement GraphQL in Spring. You'll learn how Spring for GraphQL builds upon GraphQL Java, recognize the use-cases that are best suited for GraphQL, and how to build a GraphQL API in Spring.
Typical REST APIs deal in resources. This is fine for many use cases, but it tends to be more rigid and less efficient in others.
For example, in an shopping API, it's important to weigh how much or how little information should be provided in a request for an order resource? Should the order resource contain only order specifics, but no details about the order's line items or the products in those line items? If all relevant details is included in the response, then it's breaking the boundaries of what the resource should offer and is overkill for clients that do not need it. On the other hand, proper factoring of the resource will require that the client make multiple requests to the API to fetch relevant information that they may need.
GraphQL offers a more flexible alternative to REST, setting aside the resource-oriented model and focusing more on what a client needs. Much as how SQL allows for data from multiple tables to be selected and joined in response to a query, GraphQL offers API clients the possibility of tailoring the response to provide all of the information needed and nothing that they do not need.
How do we move information realtime and connect machine learning models to make decisions on our business data? This presentation goes through machine learning and Kafka tools that would help achieve that goal.
In this presentation, we start with Kafka as our data backplane and how we get information to our pub/sub. As they enter Kafka, how do we sample that data and train our model, then how do we unleash that model on our real-time data? In other words, picture extracting samples for credit card approvals for training, then attaching the model for online processing: The moment we receive an application, we can either approve or disapprove a credit application based on a machine learning model trained on historical data. We will discuss other options as well like Spark, H2O, and more.
Refactoring is an essential skill for working with legacy code. Knowing code smells and how to correct them through refactoring is essential for maintaining an existing code base. But what are we refactoring to? We don't want to refactor just for the sake of it. This is where design patterns really shine. When we refactor to a proper design pattern, we are putting together a real solution to the problem rather than just moving code around to make it a little more readable.
This session will show you how to use your full developer toolbox so you can go from code smell to refactoring recipe to design pattern to solution.
In tech teams it's a constant firefight. We react. Then we react to the reaction… the cycle continues. In all this noise, in all this chaos, how do we move forward. How do we remain proactive?
A great leader must be an enabler for the team. At times this means insulating the team from the noise. At other times it means improving the environment for the team. At all times, however, it requires setting clear priorities and conditions for success.
This session is focused on the art of moving forward in even the noisiest environments.
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.
Over the last few years, JavaScript has introduced a slew of new features—fat-arrow functions, maps and sets. But wait! What's a WeakMap
? And there's a WeakSet
? And what exactly does Proxy
do, and why do we need it given JavaScript's dynamic nature? And then there's Proxy's cousin, Reflect
. Are these features more the result of feature envy than of any pragmatic value?
In this fast-paced live coding session, Raju Gandhi will demonstrate how you can use these features in combination to create a reactivity system very similar to ones used by modern view libraries like Vue.js. Of course, if you are interested in Vue.js, or already use it, you have even more reason to see how Vue performs some its magic. Win win!
In this session, we will explore the APIs of several new additions to JavaScript, as well as see how they can be used to build something interesting, including:
If you've heard of these constructs, and want to see how to build something really cool, you really need to attend this session (And as a bonus, you'll see how one of the world's most popular frontend library does some of it's magic).
Remember in the Matrix, when Neo said “I know Kung Fu”, and then Morpheus said “Show me”, well we will be doing that except with IntelliJ. In this dojo, we will be using all the wonderful keymappings that are available in IntelliJ and we will make you a lean mean coding machine!
In this dojo, you will master the art of:
“Show no weakness, Show no mercy”
Athletes and artists practice a lot before they go on stage and perform. It's impossible to practice and learn new skills while we are performing our day job. We have workouts for our bodies.
This talk will introduce some workouts for our minds to sharpen the skills we use daily and help us to learn new skills.
Over the last decade, DevOps has emerged as an influential business philosophy and practice, helping businesses drive high quality software to market faster. DevOps focuses on the elimination of bottlenecks that occur when development and operational resources are too divorced from one another. But what about friction in the development and test process? What about the delayed feedback cycles that come from slow builds and test flakiness? How can we reduce friction in areas that are outside of the focus of DevOps? Raju Gandhi, Developer Advocate at Gradle Enterprise, will talk about how the emerging practice of DPE addresses these questions. The presentation will include examples of DPE practices in action from Java projects using the Maven or Gradle build tool.
Attendees will walk away from this presentation with a better understanding of:
Whether you are a programmer, a lead, an architect, a technical manager, or just a nice simple human being your day starts and ends with making decisions. It involves making many small decisions and may involve making some big ones too.
In this keynote we will talk about the art of decision making, the consequences of the choices we make, and tie that into the everyday architecture and design of enterprise systems.
Software projects can be difficult to manage. Managing teams of developers can be even difficult. We've created countless processes, methodologies, and practices but the underlying problems remain the same.
This session is full of practical tips and tricks to deal with the reallife situations any tech leader regularly encounters. Put these techniques into practice and create an enviable culture and an outstanding development team. At the same time, you'll avoid common management mistakes and pitfalls.
In this session we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including state management and routing.
Note: We'll be covering Vue version 3
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this is the session for you. Come in for 180 minutes of a thrill ride as we explore this fascinating new framework and mindset.
Note: We'll be covering Vue version 3
In this session we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including state management and routing.
Note: We'll be covering Vue version 3
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this is the session for you. Come in for 180 minutes of a thrill ride as we explore this fascinating new framework and mindset.
Note: We'll be covering Vue version 3
Embraced containers yet? If so, that only presents the beginning of the journey. Designing your images to be lean, and your containers configurable requires us to leverage Dockerfiles to their maximum potential. At scale, everything matters—build times, testing, multi-stage builds, conventions around tagging and logging. There is a whole ecosystem of tools around how we can best build our images and containers.
In this session we will learn many a trick on how we can leverage Docker's own tooling as well as third-party tools to ensure that our first steps in the container world are the right ones.