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.

Add AI capabilities to your Java systems using the excellent LangChain4j framework. Add chat capabilities, image generation, vision models, texttospeech, transcription, and more, quickly and easily. RetrievalAugmented Generation (RAG) will also be included, using a variety of sources, including pdf, HTML, Word docs, and URL resources. The workshop will also demonstrate how to access models added to your local machine using the Ollama system.

The workshop will use Java 17 or above. Those who wish to code along will need to register and get an API key from OpenAI. Other models discussed will be Mistral, Anthropic (Claude), and Google (Gemini), as well as open source models running on your local machine using Ollama.

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 GPT4 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.

Workshop Requirements

• Java 17 or above, mostly for records, the HTTP client, and other features
• If you want to access OpenAI services, you need to register for a developer key at https://platform.openai.com.
• If you want to run the AI tools locally, as some of the exercises do, please install Ollama. The installer is located at https://ollama.com, and is available for macOS, Linux, and Windows.
• Once you've installed Ollama, download the gemma2 and moondream models. The command to do so is ollama run gemma2 and the same for moondream. 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 GPT4 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.

Workshop Requirements

• Java 17 or above, mostly for records, the HTTP client, and other features
• If you want to access OpenAI services, you need to register for a developer key at https://platform.openai.com.
• If you want to run the AI tools locally, as some of the exercises do, please install Ollama. The installer is located at https://ollama.com, and is available for macOS, Linux, and Windows.
• Once you've installed Ollama, download the gemma2 and moondream models. The command to do so is ollama run gemma2 and the same for moondream. 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.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?

Workshop Requirements

You'll need…

• A Java IDE of your choice. I'll be using IntelliJ, but you are welcome to use Spring Tools, Netbeans, or whatever you prefer for Java development. (Spring Tools–either the Eclipse or VSCode version–or IntelliJ is recommended, though).
• Java 17 or higher. I recommend using SDKMan (https://sdkman.io/) for managing multiple versions of Java on your machine. I'll be using Zulu 17.0.6 for most tasks, but may switch to a Liberica NIK version for purposes of native builds.
• Docker (optional, but may be necessary for some tasks)

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?

Workshop Requirements

You'll need…

• A Java IDE of your choice. I'll be using IntelliJ, but you are welcome to use Spring Tools, Netbeans, or whatever you prefer for Java development. (Spring Tools–either the Eclipse or VSCode version–or IntelliJ is recommended, though).
• Java 17 or higher. I recommend using SDKMan (https://sdkman.io/) for managing multiple versions of Java on your machine. I'll be using Zulu 17.0.6 for most tasks, but may switch to a Liberica NIK version for purposes of native builds.
• Docker (optional, but may be necessary for some tasks)

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!

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.

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 microservicesbased projects continue to stumble and falter at alarming rates. The key to unparalleled success lies in the art of finetuning and tailormaking 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, problemcentric 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 longlived 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 changeagent, 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 outward and become adopted. This is the art of Innovation.

Fortunately there has been over a century of study on the topic of how innovations go from novel idea to mainstream adoption. The art of 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 “datacentric manifesto” leading with this paragraph.

&gt “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 applicationcentric 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.

Datacentric is a major departure from the current applicationcentric approach to systems development and management. Migration to the datacentric 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 fatclient 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 defacto best practice for building modern web applications. But at what cost?

We've gone fullcircle. 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 frameworkdriven SPAs is what users demand, thus we follow the everchanging 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 fatclient 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 defacto best practice for building modern web applications. But at what cost?

We've gone fullcircle. 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 frameworkdriven SPAs is what users demand, thus we follow the everchanging 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 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.

“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.

Workshop Requirements

• Java (17 or higher)
• An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)

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.

• Subdomains to Architecture Boundaries
• Bounded Contexts
• Context Mapping
• Value Objects, Entities, and Aggregates
• Where do Microservices fit in?
• How do subdomains and bounded contexts fit in?
• Where do we put human beings in all this?
• What is Event Storming

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

  • Introduction to OWASP
  • Significance of OWASP Top 10
  • Overview of OWASP Top 10 for Applications, APIs, and LLMs

• OWASP Top 10 for Application Security

  • Presentation: Common Vulnerabilities and Mitigation Strategies
  • Demonstration: Live Examples of Application Security Vulnerabilities

• OWASP Top 10 for API Security

  • Presentation: Key Challenges in API Security and Best Practices
  • Demonstration: Illustration of API Security Vulnerabilities and Attacks

• OWASP Top 10 for LLM Applications (Large Language Models)

  • Presentation: Unique Security Concerns in LLM Applications
  • Demonstration: Showcase of LLM Security Vulnerabilities and Risks

• Q&A and Discussion

  • Open Floor for Questions and Discussion

• Conclusion

  • Summary of Key Takeaways
  • Call to Action: Implementing Security Best Practices

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

• Overview of the evolving enterprise software development landscape.
• The critical role of Enterprise Architecture in leveraging emerging technologies.
• Setting the stage for a 3-5 year technology roadmap.

Generative AI, Graph Databases, and Vector Databases

• Exploring Generative AI applications in creating dynamic and predictive models.
• Utilizing graph databases for enhanced data relationships and analytics.
• Leveraging vector databases for AI-driven applications and similarity search functionalities.

GPTs and Copilot GPTs

• Introduction to GPT models and their capabilities in software development.
• Applications of Copilot GPTs in automating coding tasks and enhancing developer productivity.
• Future potential and integration strategies for GPT technologies in enterprise solutions.

Augmented Reality (AR) & Virtual Reality (VR)

• Advances in AR and VR for enterprise applications.
• Use cases in training, operations, and customer engagement.
• Positioning AR/VR in the enterprise technology stack.

Edge Computing

• Transitioning from centralized to decentralized computing frameworks.
• Enhancing responsiveness and efficiency in IoT and enterprise applications.
• Edge computing's role in the future enterprise architecture.

Artificial Intelligence & Machine Learning (AI/ML)

• Scaling AI/ML for enterprise-wide solutions.
• Strategic importance of ethical AI and bias mitigation in corporate settings.
• Integration of AI/ML in operational and decision-making processes.

Blockchain Technology

• Blockchain's potential beyond cryptocurrencies in enterprise applications.
• Enhancing security and transparency in supply chains, finance, and contracts.
• Strategic incorporation into the enterprise IT landscape.

Agents and Advanced Automation

• The role of software agents in automating complex processes and interactions.
• Integration of agents with existing AI systems to create more autonomous and intelligent systems.
• Future trends in automation and how they reshape enterprise workflows.

Preparing for the Future

• Building a flexible, adaptive IT strategy that accommodates fast-paced technological changes.
• The role of Enterprise Architecture in ensuring alignment with business goals.
• Steps for developing a forward-looking technology roadmap.

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.

This comprehensive presentation explores the evolution of Java from version 8 through 25, demonstrating how the language has transformed from an object-oriented platform into a modern, multi-paradigm programming language. Starting with Java 8's functional programming revolution—including lambdas, streams, and Optional—the presentation traces Java's journey through significant milestones like records, pattern matching, virtual threads, and data-oriented programming. Through practical code examples from a real repository, attendees will see how these features work together to create more expressive, maintainable, and performant applications.

The presentation begins with Java 8's game-changing features, using the ProcessDictionaryV2 example to showcase functional programming patterns, higher-order functions, and advanced Stream API usage including collectors like groupingBy and teeing. It then progresses through Java 9-11's quality-of-life improvements (var, HTTP Client, String enhancements), Java 12-17's language evolution (text blocks, records, pattern matching, sealed classes), and Java 18-21's modern capabilities (virtual threads for massive scalability, sequenced collections). Special attention is given to Data-Oriented Programming, demonstrating how records, sealed classes, and pattern matching combine to create a new programming paradigm. The presentation also covers cutting-edge features like unnamed variables (_) and looks ahead to Java 25 LTS with scoped values and performance improvements. Throughout, best practices are emphasized, including embracing immutability, leveraging pattern matching for cleaner code, using virtual threads for I/O-bound operations, and adopting modern APIs over legacy alternatives. All examples are drawn from the accompanying repository, providing attendees with working code they can explore and adapt for their own projects.

Workshop Requirements

Java 24 until Java 25 is released, then Java 25. The instructor plans to use IntelliJ IDEA during class, though that is not required. If you do install IDEA, the free community edition is fine.

This comprehensive presentation explores the evolution of Java from version 8 through 25, demonstrating how the language has transformed from an object-oriented platform into a modern, multi-paradigm programming language. Starting with Java 8's functional programming revolution—including lambdas, streams, and Optional—the presentation traces Java's journey through significant milestones like records, pattern matching, virtual threads, and data-oriented programming. Through practical code examples from a real repository, attendees will see how these features work together to create more expressive, maintainable, and performant applications.

The presentation begins with Java 8's game-changing features, using the ProcessDictionaryV2 example to showcase functional programming patterns, higher-order functions, and advanced Stream API usage including collectors like groupingBy and teeing. It then progresses through Java 9-11's quality-of-life improvements (var, HTTP Client, String enhancements), Java 12-17's language evolution (text blocks, records, pattern matching, sealed classes), and Java 18-21's modern capabilities (virtual threads for massive scalability, sequenced collections). Special attention is given to Data-Oriented Programming, demonstrating how records, sealed classes, and pattern matching combine to create a new programming paradigm. The presentation also covers cutting-edge features like unnamed variables (_) and looks ahead to Java 25 LTS with scoped values and performance improvements. Throughout, best practices are emphasized, including embracing immutability, leveraging pattern matching for cleaner code, using virtual threads for I/O-bound operations, and adopting modern APIs over legacy alternatives. All examples are drawn from the accompanying repository, providing attendees with working code they can explore and adapt for their own projects.

Workshop Requirements

Java 24 until Java 25 is released, then Java 25. The instructor plans to use IntelliJ IDEA during class, though that is not required. If you do install IDEA, the free community edition is fine.

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.

• What is a Virtual Thread
• Creating and Using a Virtual Thread
• What will Loom's Virtual Threads do to Future and Reactive
• What is a Continuation?
• What is Structured Concurrency?
• What are Scoped Values

Threading 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.

• Concurrency vs. Parallelism
• Happens Before Guarantee
• volatile
• Starvation, Livelock, Deadlocks, and Race Conditions
• Using Composition over Inheritance
• Locks and choosing the right locks
• Wait, Notify, and Notify All
• Synchronizers
• CyclicBarrier
• Phaser
• CountdownLatch
• Semaphores