As far as Java is concerned, most AI tools are just another RESTful web service. In this session, learn how to use modern Java features like records, text blocks, the HTTP Client API and more to access ChatGPT, the Whisper audio-to-text transcription API, and image generators like DALL-E, Stable Diffusion, and Midjourney.
Records naturally map to JSON structures, and there are a wide variety of networking libraries available. Text blocks make it easy to create multi-inputs for services. Ultimately data-driven approaches, which combine sealed interfaces and records, make it easy to build powerful clients for AI web services.
LangChain is a popular AI framework in the Python world, but recently it has been ported to Java as part of the LangChain4J project. It brings useful abstractions to the process of adding AI capabilities to your Java-based systems, like prompt templates, structured outputs, message chains, and embedding services which allow you to add your own data to LLMs.
This talk will demonstrate how to use LangChain4J both in regular Java systems and with other frameworks like Spring. While it is too early to know which AI framework is going to become the definitive answer for Java developers, LangChain4J makes a strong case for the title.
This talk will be tailored to Java developers as we delve into the practical applications of AI tools to ease your software development tasks. We'll explore the capabilities of GitHub Copilot used as a plugin for IntelliJ IDEA and VSCode. We'll also play with GPT-4 and examine ways it can help.
It's often said that AI tools will not replace existing developers, but that a developer with those tools will have an advantage over developers without them. Join us as we try to demystify the world of AI for Java developers, equipping you with practical skills to incorporate these tools into your development workflow. Note that this is a rapidly changing field, and the talk will evolve to work with the latest features available.
OpenAI
services, you need to register for a developer key at https://platform.openai.com.Ollama
. The installer is located at https://ollama.com, and is available for macOS, Linux, and Windows.llama3
and llava
models. The command to do so is ollama run llama3
and the same for llava
. You can also use pull
instead of run
.This talk will be tailored to Java developers as we delve into the practical applications of AI tools to ease your software development tasks. We'll explore the capabilities of GitHub Copilot used as a plugin for IntelliJ IDEA and VSCode. We'll also play with GPT-4 and examine ways it can help.
It's often said that AI tools will not replace existing developers, but that a developer with those tools will have an advantage over developers without them. Join us as we try to demystify the world of AI for Java developers, equipping you with practical skills to incorporate these tools into your development workflow. Note that this is a rapidly changing field, and the talk will evolve to work with the latest features available.
OpenAI
services, you need to register for a developer key at https://platform.openai.com.Ollama
. The installer is located at https://ollama.com, and is available for macOS, Linux, and Windows.llama3
and llava
models. The command to do so is ollama run llama3
and the same for llava
. You can also use pull
instead of run
.With much of the industry finally migrating to Java 11, 17, or 21, it’s time to learn about many of the newer features you can use in your code. None of the changes since Java 8 have been as dramatic as the move to functional programming, but collectively the latest capabilities can really streamline the way you work. This talk summarizes several of them, like records and record patterns, sealed classes and interfaces, switch expressions, the HTTP client API, pattern matching for switch, and more, using them together in an app to see how they interact and improve your Java coding experience.
This talk summarizes several of them, like records and record patterns, sealed classes and interfaces, switch expressions, the HTTP client API, pattern matching for switch, and more, using them together in an app to see how they interact and improve your Java coding experience.
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 and Spring Boot 3.
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'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 and Spring Boot 3.
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…
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 to-do 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!
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 go-to 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 high-level understanding of these approach, their respective trade-offs and ultimately how to align your API approach with your architectural and organizational goals.
Architecture is often described as “the stuff that's hard to change” or “the important stuff (whatever that is).” At its core, architecture defines the very essence of software, transcending mere features and functions to encompass vital capabilities such as scalability, evolvability, elasticity, and reliability. But here's the real question: where do these critical capabilities truly originate?
In this session, we'll embark on a journey to uncover the secrets behind successful architectures. While popular architecture patterns may offer a starting point, it's time to unveil the startling truth – both monolith and microservices-based projects continue to stumble and falter at alarming rates. The key to unparalleled success lies in the art of fine-tuning and tailor-making architectures to precisely fit the unique needs of your organization, environment, and the teams delivering the software.
Step into the future as we introduce a groundbreaking, problem-centric approach to defining and evolving system architectures. Our practical techniques will empower you to transform constraints, both architectural and environmental, into powerful enablers of robust, valuable, and long-lived software systems.
Join us and elevate your architecture game to new heights!
Statistically speaking, you are most probably an innovator. Innovators actively seek out new ideas, technologies, and mental models by reading books, interacting with a broader social circle, and attending conferences. While you may leave this conference with the seed of an idea that has the potential to transform your teams, products, and organization; the battle has only begun. While, as a potential change-agent, you are ideally positioned to conceive of the powerful new ideas, you may be powerless to drive the change that leads to adoption. Your success requires the innovation to diffuse.
Fortunately there has been over a century of study on the topic of diffusion of innovations. Diffusing an innovation is difficult, but tractable and this session illuminates the path. You will get to the heart of why some innovations succeed while others fail as well as how to tip the scales in your favor. You'll leave armed with the tools to become a powerful change agent in your career and life and, ultimately, become a more powerful and influential person.
Agile has become an overused and overloaded buzzword, let's go back to first principles. Agile is the 12 principles. Agile is founded on fast feedback and embraces change. Agile is about making the right decisions at the right time while constantly learning and growing.
Architecture, on the other hand, seems to be the opposite. Once famously described by Grady Booch as “the stuff that's hard to change” there is overwhelming pressure to get architecture “right” early on as the ultimate necessary rework will be costly at best, and fatal at worst. But too much complexity, too early, can be just as costly or fatal. A truly practical approach to agile architecture is long overdue.
This session introduces a new approach to architecture that enables true agility and unprecedented evolvability in the architectures we design and build. Whether you are a already a seasoned architect, or are simply beginning that path, this session will fundamentally change the way you think about and approach software architecture.
In 2017, an organization known as The Semantic Arts published their “data-centric manifesto” leading with this paragraph.
> “We have uncovered a root cause of the messy state of Information Architecture in large institutions and on the web today. It is the prevailing application-centric mindset that gives applications priority over data. The remedy is to flip this on its head. Data is the center of the universe; applications are ephemeral.”
While the vision and ideas of this manifesto are compelling, implementation details are scarce leaving the potential out of reach of many busy developers and architects.
Data-centric is a major departure from the current application-centric approach to systems development and management. Migration to the data-centric approach will not happen by itself.
This session is full of practical and actionable examples, insights, and approaches to this new paradigm. If you’re ready to consider the possibility that systems could be more than an order of magnitude cheaper and more flexible, then check out this session to see firsthand a new way to think about software and information systems.
When the world wide web launched in 1993, it presented a revolutionary new way to globally share information. The revolution didn't stop there. The web soon became a platform for building, hosting, and distributing entire applications. Today most applications are built as web applications yet the core capabilities of HTML remain mired in the Web 1.0 days. Ajax was the first of many “hacks” to build web applications that delivered the rich, responsive user experience that rivaled traditional fat-client applications. Early js libraries and frameworks overcame browser incompatibilities and provided the first abstractions to hide the hacks and today's frameworks are so powerful that conventional wisdom states they are the de-facto best practice for building modern web applications. But at what cost?
We've gone full-circle. Today's SPAs have more in common with the fat client applications of the 90s (albeit with simplified deployment) than they do with the web. The modern UX of today's framework-driven SPAs is what users demand, thus we follow the ever-changing trends; but at what cost? Beyond the bloat, complexity, and ephemerality of the modern webdev toolchain; modern webdev practices have inadvertently abandoned the core ideas of the web that made the platform technologically, architecturally, and philosophically revolutionary.
Leading thinkers in the web development space have long proclaimed that “not everything should be a SPA” however the alternative of a web 1.0 vanilla html application has very limited utility in the year 2024. Are these our only options, or does a “third way” exist?
This session introduces that “third way” based on the revolutionary ideas that empowered the web. A meaningful, practical, and proven alternative to SPA frameworks providing a simpler and more lightweight approach to building applications on the Web and beyond without sacrificing the UX.
Web applications built following this “third way” boast more evolvability, longevity, and simplicity. SPAs will continue to have their place, but good software engineering is about using the right tool for the job. After attending this session, you will have more than just a hammer in your toolbox.
When the world wide web launched in 1993, it presented a revolutionary new way to globally share information. The revolution didn't stop there. The web soon became a platform for building, hosting, and distributing entire applications. Today most applications are built as web applications yet the core capabilities of HTML remain mired in the Web 1.0 days. Ajax was the first of many “hacks” to build web applications that delivered the rich, responsive user experience that rivaled traditional fat-client applications. Early js libraries and frameworks overcame browser incompatibilities and provided the first abstractions to hide the hacks and today's frameworks are so powerful that conventional wisdom states they are the de-facto best practice for building modern web applications. But at what cost?
We've gone full-circle. Today's SPAs have more in common with the fat client applications of the 90s (albeit with simplified deployment) than they do with the web. The modern UX of today's framework-driven SPAs is what users demand, thus we follow the ever-changing trends; but at what cost? Beyond the bloat, complexity, and ephemerality of the modern webdev toolchain; modern webdev practices have inadvertently abandoned the core ideas of the web that made the platform technologically, architecturally, and philosophically revolutionary.
Leading thinkers in the web development space have long proclaimed that “not everything should be a SPA” however the alternative of a web 1.0 vanilla html application has very limited utility in the year 2024. Are these our only options, or does a “third way” exist?
This session introduces that “third way” based on the revolutionary ideas that empowered the web. A meaningful, practical, and proven alternative to SPA frameworks providing a simpler and more lightweight approach to building applications on the Web and beyond without sacrificing the UX.
Web applications built following this “third way” boast more evolvability, longevity, and simplicity. SPAs will continue to have their place, but good software engineering is about using the right tool for the job. After attending this session, you will have more than just a hammer in your toolbox.
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 meta-answer 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.
“What you must learn is that these rules are no different than the rules of a computer system. Some of them can be bent. Others can be broken. "
-Morpheus
The world of technology seems logical, objective, and to operate by consistent rules. Reality can be illogical, subjective, and even random at times. Yet we accept subjective reality as-is; our single perspective is all we can really know.
In the end, reality constrains engineers and magicians reshape reality. Perhaps reality is not what it seems.
Join Michael Carducci, magician and software architect, as he takes you on a journey through the marriage of the logical and the illogical, the intersection of magic and technology. Discover what each has to teach the other, and how you can apply the lessons to transform your skills and your career.
With over 25 years of experience in both fields–and a lifetime of successes and failures–Michael shares his deeply reflective, unique, and authentically honest perspective on both careers, dealing with problems, challenges, wins, and losses.
This talk combines illusion, engineering wisdom, life lessons, and the stories that connect them. You'll be astonished, engaged, and leave with an entirely new perspective on technology and life.
By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.
So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.
For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot auto-configuration, you'll be able to get straight to the point of asking questions and getting answers your application needs.
In this session, we'll consider a handful of use cases for Generative AI and see how to implement them with Spring AI. We'll start simple, then build up to some more advanced uses of Spring AI that employ your application's own data when generating answers.
Introducing Spring Modulith
Although microservices are still a useful architectural choice, the balance of additional complexity and the advantages of microservice architecture do not necessarily work out in the benefit of all applications. While most application will benefit from improved modularity, the challenges that come with distributed computing may be too much for some applications to take on. A well-structured and modular monolithic application might be a better fit.
In this session, we'll explore Spring Modulith, a relatively new Spring library that enables developers to build well-structured Spring Boot applications, guiding them in discovering domain-driven modules, and verifying that the modular arrangement is correct. We'll also see how Spring Modulith assists with modular integration testing and documentation.
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.
The architecture paradigms we’re using are changing. The platforms we deploy our software to are changing. We are confronted with several new architecture paradigms to choose from, such as microservices and miniservices. Should we automatically discard some of the proven architectures we’ve used in the past, including more traditional web services? Likewise, new platforms, such as cloud, complicate the decision. Yet, at the heart of this transformation is modularity. From monoliths to microservices and everything in between, modularity is the foundation.
In this session, we’ll explore how modularity is impacting the platforms we are leveraging and the architecture paradigms we’ll use and offer a clear roadmap with proven guidance on navigating the architecture decisions we must make.
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.
As of Java 9, modularity is built in to the Java platform…Finally! Yet few teams are using it. And in reality, you may never use it…at least not for a while. However by understanding the module system, you're guaranteed to see the Java platform in a completely different light. In this session, we explore the default module system, how it works on the Java platform, and what’s in the future for the Java Platform Module System.
We will demonstrate the impact that JPMS will have on our existing applications and identify what we must do to get ready for JPMS. You will also see firsthand how to use the JPMS and the benefits that support for modularity on the Java platform will have on your applications.
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.
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.
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.
Domain Driven Design has been guiding large development projects since 2003, when the seminal book by Eric Evans came out. Domain Driven Design is split up into two parts: Strategic and Tactical. One of the issues is that the Strategic part becomes so involved and intense that we lose focus on implementing these sorts of things. This presentation swaps this focus as topic pairs. For example, when we create a bounded context, is that a microservice or part of the subdomain? When we create a domain event, what does that eventually become? How do other tactical patterns fit into what we decide in the strategic phase?
In this presentation, we will break it down into pairs of topics.
With advanced AI tools, software architects can enhance their project design, compliance adherence, and overall workflow efficiency. Join Rohit Bhardwaj, an expert in generative AI, for a session that delves into the integration of ChatGPT, a cutting-edge generative AI model, into the realm of software architecture. The session aims to provide attendees with hands-on experience in prompt engineering for architectural tasks and optimizing requirement analysis using ChatGPT. It is a compelling talk explicitly designed for software architects who are interested in leveraging generative AI to improve their work.
Outline:
Introduction
A brief overview of the session.
Importance of generative AI in software architecture.
Introduction to ChatGPT and its relevance for software architects.
Prompt Engineering for Architectural Tasks
Crafting Effective Prompts for ChatGPT
Strategies for creating precise and effective prompts.
Examples of architectural prompts and their impact.
Hands-On Exercise: Creating Architectural Prompts
Interactive session: Participants will craft and test their prompts.
Feedback and discussion on prompt effectiveness.
Optimizing Requirement Analysis
Leveraging ChatGPT for Requirement Analysis and Design
Integration of AI in empathizing with client needs and journey mapping.
Cost Estimations, Compliance, Security, and Performance
Selecting appropriate technologies and patterns with AI assistance
Hands-On Exercise: Requirement Analysis and Design
Case Study
Using Empathy Map and Customer Journey Map tools in conjunction with AI.
Case Study Cost Estimations, Compliance, Security, and Performance
Custom GPTs, Embeddings, Agents
Key Takeaways:
Enhanced understanding of how generative AI can be used in software architecture.
Practical skills in prompt engineering tailored for architectural tasks.
Strategies for effectively integrating ChatGPT into requirement analysis processes.
Join us for an immersive journey into the heart of modern cybersecurity challenges. In this groundbreaking talk, we delve into the intricacies of securing your digital assets with a focus on three critical domains: applications, APIs, and Large Language Models (LLMs).
As developers and architects, you understand the paramount importance of safeguarding your systems against evolving threats. Our session offers an exclusive opportunity to explore the industry-standard OWASP Top 10 vulnerabilities tailored specifically to your domain.
Uncover the vulnerabilities lurking within your applications, APIs, and LLMs, and gain invaluable insights into mitigating risks and fortifying your defenses. Through live demonstrations and real-world examples, you'll witness firsthand the impact of security breaches and learn proactive strategies to combat them.
Whether you're a seasoned architect seeking to fortify your organization's security posture or a developer striving to build resilient systems, this talk equips you with the knowledge and tools essential for navigating the complex landscape of cybersecurity.
Agenda
OWASP Top 10 Overview
OWASP Top 10 for Application Security
OWASP Top 10 for API Security
OWASP Top 10 for LLM Applications (Large Language Models)
Q&A and Discussion
Conclusion
This talk explores how cutting-edge technologies and trends will shape the future of enterprise software development, creating opportunities for innovation and efficiency. We’ll discuss how to leverage these technologies within an Enterprise Architecture framework to build a robust roadmap that guides enterprises through technological advancements and competitive landscapes.
Introduction
Generative AI, Graph Databases, and Vector Databases
GPTs and Copilot GPTs
Augmented Reality (AR) & Virtual Reality (VR)
Edge Computing
Artificial Intelligence & Machine Learning (AI/ML)
Blockchain Technology
Agents and Advanced Automation
Preparing for the Future
Join us for a transformative captivating session where you'll embark on a journey of discovery as we unveil a comprehensive seven-step methodology designed to revolutionize your approach to API design and implementation.
Throughout the session, we'll explore practical use cases drawn from diverse industries, allowing you to gain valuable insights into the intricacies of designing APIs for real-world scenarios. From taxi hailing giants like Uber and Lyft to social media titans such as Facebook and Instagram, you'll dissect the unique challenges and requirements driving API design in today's dynamic digital landscape.
Guided by seasoned industry experts, you'll delve into the core principles of RESTful microservices architecture and learn how to apply them effectively in your own projects. Through engaging presentations, interactive exercises, and hands-on, you'll master essential concepts such as OData integration, industry best practices, and innovative design strategies.
By the end of the session, you'll emerge with a deep understanding of the seven-step process for designing superior cloud-native RESTful microservices APIs. Armed with practical insights and invaluable experience, you'll be ready to tackle the challenges of modern software architecture head-on, driving innovation and excellence within your organization.
Don't miss this opportunity to elevate your skills, expand your knowledge, and unlock the full potential of RESTful microservices architecture. Join us and take the first step towards architectural mastery today!
– Seven-Step Methodology to Design RESTful Microservices APIs
Embark on our journey with a comprehensive overview of the seven-step methodology crucial for crafting robust and scalable RESTful microservices APIs. Learn how to navigate the intricacies of API development while adhering to industry best practices, setting the foundation for success in your microservices architecture endeavors.
Exercise: Industry Best Practices for API Development
Put your newfound knowledge into action as we delve into hands-on exercises designed to reinforce industry best practices for API development. Gain practical insights and hone your skills in designing APIs that meet the highest standards of performance and scalability.
– Unveiling OData - The Best Way to REST
Explore the power of OData (Open Data Protocol) as we unravel its capabilities and advantages in building RESTful microservices. Discover how OData simplifies data access and manipulation, offering unparalleled flexibility and efficiency in your API design endeavors.
Exercise: Online Ecommerce API Design
Engage in a real-world exercise focusing on online ecommerce API design, where you'll apply OData principles to create seamless and intuitive API solutions tailored for the digital marketplace.
– Understanding Use Cases
Delve into the realm of practical use cases as we analyze scenarios from industries like taxi hailing (Uber/Lyft) and social media (Facebook/Instagram). Gain insights into the unique challenges and requirements driving API design in these domains.
Exercise: Use Case Exploration
Immerse yourself in hands-on exercises exploring use cases for taxi hailing and social media companies. Apply your newfound knowledge to design APIs that address specific challenges and optimize performance in these dynamic environments.
Designing Taxi Hailing APIs - Uber/Lyft
Deep dive into the intricacies of designing APIs for taxi hailing services like Uber and Lyft. Explore real-world examples and best practices for architecting APIs that facilitate seamless interactions between users, drivers, and the platform.
Exercise: Design Challenges
Challenge yourself with hands-on design exercises focused on tackling real-world challenges such as duplicate records, data migration, large data volume considerations, data rate limits, decision-making, and data validations.
– Navigating API Challenges
Navigate through the complexities of API challenges as we dissect common pitfalls and obstacles encountered in RESTful microservices architecture. Gain strategies and insights to overcome these challenges and optimize your API solutions for maximum efficiency and scalability.
Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new six-month release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.
The purpose of this workshop is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.
Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new six-month release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.
The purpose of this workshop is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.
There is a new way of Threading, which means it is time to prepare. Project Loom has introduced Java Virtual Threads, which is now available in Java 21. Virtual Threads are small Threads meant to perform quick operations with the need to procure long-running OS threads, which can prove expensive. In this presentation, we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, and what does it mean for third-party libraries.
Future
and ReactiveThreading has always been tough. Even with new frameworks that can make it easy, sometimes we don't have them at our disposal. This full-day session focuses on threading and the various synchronizers in Java. We will have material you can use as a reference and challenges that will help you remember some pitfalls to avoid.
volatile
Phaser
CountdownLatch