New England Software Symposium

May 3 - 4, 2024

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.

Workshop Requirements

Java 17 or above, mostly for records, the HTTP client, and other features
Gson parser, provided via the Gradle build tool
Gradle, provided as a wrapper in the project repository
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 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.

Workshop Requirements

Java 17 or above, mostly for records, the HTTP client, and other features
Gson parser, provided via the Gradle build tool
Gradle, provided as a wrapper in the project repository
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 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.

It almost feels like we keep hearing this chant “Monoliths are bad, Microservices are awesome.” When architects, technical leads, and developers reject architecture due to bias or favor due to infatuation organizations lose. The most important question is what are the business needs and which architecture is the most suitable for that.

In this presentation we will compare the contrast the differences between monoliths and microservices and the consequences of choosing one over the other. The goal is for us to develop an objective knowledge so we can choose wisely in order to serve our businesses.

Creating Microservices is hard and it takes more effort.

In this presentation, we will distill some design and architectural patterns that can help us with that journey. We can learn from some proven solutions that can help us to avoid common mistakes and also help us gravitate toward focusing on the essential problems that are inherent to the Microservices architecture.

Threads are lightweight, but do not scale well. That's one of the reasons we have been focused on the elastic capabilities on the cloud. Unfortunately that has an impact both on our environment and your companies wallet.

In this presentation we will learn how virtual threads reduce those impacts and help us to create scalable applications with minimum change to code.

Design Patterns are common ways to solve problems that developers have discovered over time. They often fill the gaps between the language capabilities and the design goals. When languages mature, sometimes patterns become natural features of languages and blend in to the natural way of writing code instead of a special effort. Java has evolved significantly over the years.

In this session we will revisit some common design problems and see how patterns are realized to solve those problems with the modern capabilities in Java.

Why talk about resilience when thinking of scale? It turns out all the effort we put in to achieve great performance may be lost if we are not careful with failures. Failure is not only about unavailability of parts of an application to some users, it may result in overall poor performance for everyone else as well.

In this presentation we will discuss ways to attain scale and discuss how to preserve those efforts by dealing with failures properly.

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!

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.

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!

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.

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.

Confused about Kubernetes? Don't know what it does? This is the session that will bring clarity for all things Kubernetes.

The orchestration wars are over, and we have a winner, namely Kubernetes. However, it's not easy to wrap your head around all the abstractions that Kubernetes uses.

In this two-part session we'll wade into the water, but quickly navigate to the deep end of Kubernetes. We'll use a demo-driven approach along with analogies and diagrams to bring clarity to understanding this massively complex, yet powerful, ubiquitous tool.

We'll cover the following:

What is Kubernetes and why do we need such a tool?
Kubernetes cluster architecture
Pods, InitContainers and Sidecar containers
ReplicaSets
Deployments
Volumes and PersistentVolumes
ConfigMaps, Secrets and the Downward API
Services
Ingress
StatefulSets

We'll also look into the tradeoffs of using tools like Kubernetes, and when it's appropriate, and if there are any alternatives.

Confused about Kubernetes? Don't know what it does? This is the session that will bring clarity for all things Kubernetes.

The orchestration wars are over, and we have a winner, namely Kubernetes. However, it's not easy to wrap your head around all the abstractions that Kubernetes uses.

We'll cover the following:

What is Kubernetes and why do we need such a tool?
Kubernetes cluster architecture
Pods, InitContainers and Sidecar containers
ReplicaSets
Deployments
Volumes and PersistentVolumes
ConfigMaps, Secrets and the Downward API
Services
Ingress
StatefulSets

We'll also look into the tradeoffs of using tools like Kubernetes, and when it's appropriate, and if there are any alternatives.

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 two-part 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

In particular, in terms of security. Securing and hardening VMs is very different than that for containers.

In this two-part 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

As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.

To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?

This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.

With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.

Java has come a long way in the recent years.

In this two part presentation, we will learn about the exciting features including modularization, text blocks, records, sealed classes, pattern matching, and also how these features interplay with each other to provide the most flexibility and power to you to create fluent code.

Java has come a long way in the recent years.

In this two part presentation we will learn about the exciting features including modularization, text blocks, records, sealed classes, pattern matching, and also how these features interplay with each other to provide the most flexibility and power to you to create fluent code.

Dividing a large problem into subproblems that are scheduled to run on different threads is an often used solution. We've used executors and fork join pool for such problems in the past. These solutions, in spite of being very powerful, has significant limitations.

In this presentation we will start with those solutions, discuss the issues, and learn how structured concurrency, introduced in Java 21, can help solve such problems more effectively and elegantly.

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.

In this session we will discuss what modular monoliths are, what they bring to the table, and how they offer a great middle ground between monoliths and distributed architectures like microservices.

Monoliths get a bad rep. Experienced software developers have seen one too many monoliths devolve into a big ball of mud, leaving everyone frustrated, with an itch to do a “rewrite”. But monoliths have their pros! They are usually simpler, easier to understand, and faster to build and debug.

On the other side of the spectrum you have microservices—that offer scale, both technically and organizationally, as well as having the badge of honor of being “the new cool kid on the block”. But productionizing microservies is HARD.

Why can't we have our cake and eat it too? Turns out, we can. In this session we will explore the modular monolith—all the upsides of a monolith with none of the downsides of distributed architectures. We'll see what it means to build a modular monolith, and how that differs from a traditional layered architecture. We will discuss how we can build architectural governance to ensure our modules remain decoupled. Finally we'll see how our modules can communicate with one another without violating modularity.

By the end of this session you'll walk away with a greater appreciation for the monolith, and see how you can leverage this within your system architecture.

It's not just architecture—it's evolutionary architecture. But to evolve your architecture, you need to measure it. And how does that work exactly? How does one measure something as abstract as architecture?

In this session we'll discuss various strategies for measuring your architecture. We'll see how you know if your software architecture is working for you, and how to know which metrics to keep an eye on. We'll also see the benefits of measuring your architecture.

We'll cover a range of topics in this session, including

Different kinds of metrics to measure your architecture
The benefits of measurements
Improving visibility into architecture metrics

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.

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.

You may be working in an organization where pairing and/or mobbing is encouraged or even expected. Collaboration has many benefits but it is not easy. What are some of the ways in which we can get effective in collaborative development?

In this presentation we will discuss several practices that you, as an individual, and your team collectively can practice to make the collaborative development sessions fruitful, less contentious, and help to achieve the goals for the benefit of the teams and the enrichment of the individuals.

In 2017, an organization known as The Semantic Arts published their “data-centric 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 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.

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.

By the end of this conference you will have learned many new tools and technologies. The easy part is done, now for the hard part: getting the rest of the team-and management-on board with the new ideas. Easier said than done.

Whether you want to effect culture change in your organization, lead the transition toward a new technology, or are simply asking for better tools; you must first understand that having a “good idea” is just the beginning. How can you dramatically increase your odds of success?

You will learn 12 concrete strategies to build consensus within your team as well as 6 technique to dramatically increase the odds that the other person will say “Yes” to your requests.

As a professional mentalist, Michael has been a student of psychology, human behavior and the principles of influence for nearly two decades. There are universal principles of influence that neccessary to both understand and leverage if you want to be more effective leader of change in your organization.

In this session we discuss strategies for getting your team on board as well as when/how to approach management within the department and also higher-up in the organization.

In Part 1, you learned the core principles of influence and persuasion. How to we take this back to the office and apply what we've learned?

We dive deep in to specific strategies to get both the team and the business on board with your ideas and solutions. We cover several real-world patterns you can follow to be more effective and more persuasive. Part 1 was conceptual, part 2 is practical.

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!

In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.

Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.

In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table. Examples include:

Rebase and interactive rebase
restore/switch and when to use them
worktrees
shallow-clones
Git's filesystem monitor

By the end of this session, you will walk away with a slew of new tools in your arsenal, and a new perspective on how this can help you and your colleagues get the most out of Git.

In this dynamic talk, we explore the fusion of AI, particularly ChatGPT, with data-intensive architectures. The discussion covers the enhancement of big data processing and storage, the integration of AI in distributed data systems like Hadoop and Spark, and the impact of AI on data privacy and security. Emphasizing AI's role in optimizing big data pipelines, the talk includes real-world case studies, culminating in a forward-looking Q&A session on the future of AI in big data.

This talk delves into the innovative integration of advanced AI models like ChatGPT into data-intensive architectures. It begins with an introduction to the significance of big data in modern business and the role of AI in scaling data solutions. The talk then discusses the challenges and strategies in architecting big data processing and storage systems, highlighting how AI models can enhance data processing efficiency.

A significant portion of the talk is dedicated to exploring distributed data systems and frameworks, such as Apache Hadoop and Spark, and how ChatGPT can be utilized within these frameworks for improved parallel data processing and analysis. The discussion also covers the critical aspects of data privacy and security in big data architectures, especially considering the implications of integrating AI technologies like ChatGPT.
The talk further delves into best practices for managing and optimizing big data pipelines, emphasizing the role of AI in automating data workflow, managing data lineage, and optimizing data partitioning techniques. Real-world case studies are presented to illustrate the successful implementation of AI-enhanced data-intensive architectures in various industries.

Introduction (10 mins)
- Unleashing the power of big data in modern businesses
- Importance of data-intensive architectures in scaling data solutions
- Introducing AI's role in big data, with a focus on ChatGPT
Part 1: Architecting for Big Data Processing and Storage (25 mins)
- Understanding the challenges of big data processing
- Designing scalable data storage solutions
- Achieving high availability and fault tolerance
- Integrating AI models like ChatGPT for enhanced data processing
Part 2: Distributed Data Systems and Frameworks (25 mins)
- Leveraging the potential of distributed processing tools
- Introduction to Apache Hadoop, Spark, and other frameworks
- Performing parallel data processing and analysis
- How ChatGPT and similar AI models can be utilized in distributed systems
Part 3: Handling Data Privacy and Security in Big Data Architectures (20 mins)
- Challenges and considerations for data privacy in big data environments
- Ensuring data security and confidentiality
- Adhering to compliance regulations in big data projects
- Discussing the implications of AI like ChatGPT on data privacy and security
Part 4: Best Practices for Managing and Optimizing Big Data Pipelines (20 mins)
- Data workflow orchestration and automation
- Data lineage and metadata management
- Data partitioning and optimization techniques
- Utilizing AI models like ChatGPT for optimizing big data pipelines
Case Studies and Real-World Applications (10 mins)
- Inspiring examples of successful data-intensive architecture implementations
- Learning from the experiences of leading organizations
- Case studies involving ChatGPT in big data solutions
Conclusion and Q&A (10 mins)
- Recapitulation of key takeaways
- Addressing questions and facilitating discussions with the audience
- Highlighting the future of AI and big data with technologies like ChatGPT

Overall, this talk aims to provide a comprehensive understanding of how AI, especially ChatGPT, can be integrated into data-intensive architectures to enhance big data processing, analysis, and management, preparing attendees to harness AI's potential in their big data endeavors.

Key Takeaways:

AI's Impact on Big Data: Insight into how AI, especially ChatGPT, enhances big data processing and scalability.
Designing AI-Integrated Systems: Strategies for building scalable, AI-enabled data processing and storage solutions.
AI in Distributed Frameworks: Understanding the integration of AI in systems like Hadoop and Spark for improved data analysis.
Data Privacy and Security: Best practices for maintaining data integrity and compliance in AI-enhanced big data environments.
Optimizing Data Pipelines with AI: Techniques for using AI to automate data workflows and optimize data management.
Real-World AI Applications: Learning from case studies where AI in data architectures has driven success.
Future of AI in Big Data: Insights into the evolving role and potential of AI technologies like ChatGPT in big data.
Interactive Learning: Engaging in discussions and Q&A for a deeper understanding of AI's role in big data.

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

Graph technology has been the fastest-growing sector in database systems over the past decade. This talk addresses the strategic importance of mastering graph technologies, which is crucial for professionals who are at the forefront of technological innovation, coding efficiently, and system design. Mastering these tools isn't just an enhancement—it's an imperative.

In this comprehensive session, we'll explore high-level graph algorithms that form the backbone of modern, complex systems and discuss how these algorithms are integral to the architecture of efficient graph databases. We will delve into the advanced functionalities and strategic implementations of knowledge graphs, illustrating their essential role in integrating disparate data sources, empowering AI applications including generative AI, and enhancing business intelligence.

Join us to navigate the complexities and opportunities this dynamic field presents, ensuring you remain at the cutting edge of technology and continue to drive significant advancements in your projects and enterprises.

Advanced Graph Algorithms

Review of essential graph theory concepts tailored for advanced understanding.
Exploration of complex algorithms such as Greedy Algorithms, Dijkstra’s, and Bellman-Ford, focusing on optimization and problem-solving in real-world scenarios.

Graph Database Architecture

An in-depth look into graph databases versus traditional relational databases and why graph databases have become crucial in handling modern data needs.
Discussion on best practices for designing graph databases that ensure performance, scalability, and efficiency.

Mastery of Knowledge Graphs

Detailed examination of the construction, utilization, and strategic importance of knowledge graphs in business and technology landscapes.
Insight into how knowledge graphs are transforming industries by enhancing data integration, semantic search, and AI-driven insights, including generative AI.

Case Studies and Emerging Technologies

Analysis of successful implementations and case studies where graph technologies have made a significant impact.
Exploration of future trends such as graph neural networks and their potential to revolutionize knowledge representation and machine learning applications.

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.

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