With the introduction of the new Hybrid .NET MAUI Blazor model developers are provided an entirely different method of interacting/building .NET applications that target iOS and Android. This session takes a dive into this technology and talks about the practicality of what this technology means, how it might be used and next steps.

We will explore the following * Project structure overview * End-user differences between using a traditional MAUI implementation vs MAUI Blazor * Performance & Security considerations * Store submission guidance

At the end of this session attendees will see a real-world example of an appliation built with .NET MAUI Blazor and will be able to reference the solution after the event to help in their own technology research.

When it comes to distributed, event-driven messaging systems, we usually see them supporting either one of two types of semantics: streaming, or queueing, and rarely do we find a platform that supports both. In this presentation, we’ll first get an introduction and some clarifications of event-driven versus message-driven systems, event streams, and stream processing. We’ll then take a look at Apache Pulsar which offers a very unique capability in modern, cloud-native applications and architecture, in which its platform supports both Publish-Subscribe and Message Queues, and extends into streams processing as well as performs message mediation & transformation. We will see how it works closely with and relies on Apache Bookkeeper for its durable, scalable, and performant storage of log streams, and leverages on Apache Zookeeper to manage the otherwise very complex ecosystem. We will then compare Apache Pulsar with the popular Apache Kafka platform to understand some of their key differences as to how Pulsar can overcome some of Kafka's limitations. With Pulsar's flexible architecture and cloud-native readiness, we will take a look to see how it can be integrated and work collaboratively with the popular Spring framework.

Many companies have legacy systems that have become tangled webs of ownership and dependencies. Sources of truth float around as they are synced from one system to the next, any fault can cause side effects or stale data. My team and I have been working on decoupling our monoliths and I would like to share that journey, the technologies (Kafka, ksqlDb, etc), and the patterns (Strangler, Scaffolding, etc) we use to create single sources of truth and a new modern software ecosystem.

We’re all familiar with the notion that software is everywhere, and that in some way it touches nearly every product you’ll ever own. One such product is dimensional lumber, like a 2x4 or 4x4. There are a number of steps between a tree in a forest and a piece of lumber you buy in a store. One of those is ‘edging’, the process of removing the living edge from a flat section of raw material, and producing a board of an appropriate width with straight sides.

This talk is a post-mortem of a prototype system we built for optimizing the potential value of material coming out of an edger. While the AI for optimizing produced material was an important part of our system, it wasn’t the only part of our system!

In this talk, we’ll cover: * The general problem of dimensional lumber extraction * How the client’s brand influenced which AI techniques we used to solve the problem * How AI is just a part of a larger software product, including * How we took an agile approach to AI development * How we handled estimating the cost of building the solver (and the rest of the software) * How AI integrated with the rest of the team

I’m hoping the audience takes away: * Sometimes the best technical solution is not the best overall solution * Even when AI is required for a product, it is never the whole product * AI software isn’t ‘special’ from a best-development-practices perspective

We’re all familiar with the notion that software is everywhere, and that in some way it touches nearly every product you’ll ever own. One such product is dimensional lumber, like a 2x4 or 4x4. There are a number of steps between a tree in a forest and a piece of lumber you buy in a store. One of those is ‘edging’, the process of removing the living edge from a flat section of raw material, and producing a board of an appropriate width with straight sides.

This talk is a post-mortem of a prototype system we built for optimizing the potential value of material coming out of an edger. While the AI for optimizing produced material was an important part of our system, it wasn’t the only part of our system! In this talk, we’ll cover:

• The general problem of dimensional lumber extraction
• How the client’s brand influenced which AI techniques we used to solve the problem
• How AI is just a part of a larger software product, including
• How we took an agile approach to AI development
• How we handled estimating the cost of building the solver (and the rest of the software)
• How AI integrated with the rest of the team

I’m hoping the audience takes away: Sometimes the best technical solution is not the best overall solution Even when AI is required for a product, it is never the whole product AI software isn’t ‘special’ from a best-development-practices perspective * Folks interested in using AI on a project, but especially * Individual contributors who wonder how to build AI * Product owners who wonder how AI integrates on a product level * Project managers who wonder how AI impacts development rituals and team composition

In this session we'll explore Azure Machine Learning Studio and the Azure ML Python SDK and how they can help novices, journeymen, and experts on their machine learning journey without requiring deep knowledge of machine learning algorithms.

Specifically we'll explore Automated ML in the web portal, the machine learning designer for intermediate users, and the Python SDK for those who prefer to code in Python but take advantage of Azure's cloud offerings. We'll also explore the use of Hyperdrive from Python to customize the training process for custom workloads.

By the time we're done, you'll see how Azure is a frighteningly powerful platform for all flavors of data scientists - including those without a data science background.

How quickly does your application respond to security threats?

Most applications rely on security logs (assuming they are present) sent to a monitoring repository, where they are correllated against other activity, analyzed for risk, and responded to when the monitoring team has time.

At that point, an attacker may already have breached the application, or gotten enough information to come back later. Instead, what if we allowed the application to block malicious activity automatically before it had time to become an issue?

In this session, I will present several strategies for developing traps and pitfalls within an application that can catch hacker behavior, and even block the offending user, before any damage is done.

Modern "smart" homes are dumb; your lights shouldn't stop working because your Internet is down, and your new doorbell shouldn't compromise your network security.

A smarter and more secure home doesn't depend on cloud services or a disparate array of apps to function, and it's easier than you might think to achieve total local control. A dash of technical knowledge, a dab of DIY elbow grease, and this session are all you need to get started.

In this session you'll learn how to choose and install a local hub (Home Assistant vs Hubitat vs HomeKit), which devices work best (Zigbee vs Z-Wave vs Wifi), and how to integrate lights, plugs, sensors, and switches without the cloud. You'll also learn how to add smart features like remote control and push notifications to your existing "dumb" appliances.

Come take a tour through the land of smart, local home automation and stop being dependent on someone else's computers!

Artificial Intelligence (AI) is no longer science fiction; it’s here today, and it’s here to stay. It is in the products you use every day: home automation, digital assistants, or credit card fraud detection, just to name a few.

All businesses will be affected by AI in the coming years, and the impact will be significant. The only remaining question is, how will you influence its effect on your company?

Getting started with AI is a daunting task, but necessary for businesses who want to stay competitive. During this session, we’ll discuss:

• How to determine if, where, and how to use AI effectively within your organization
• When and how to build an AI team
• Common early mistakes and pitfalls when getting started with AI
• Typical misconceptions around AI and its application
• What to look for in an AI partner or potential hire

Too much design up front and you are bumping into the design all of the time (and losing time). Not enough design and your system can crumble in reality. How do you blend architecture so you have the right decisions at the right time, and give them enough due dilligence? How do you embrace cloud and microservices and not risk getting into different failure scenarios or overly complicated maintenance and ripple effects?

In this session we will walk through visualizations that help teams blend product thinking with architecture. Along the way, we will look at microservices and domain modeling as well as chaos engineering and fault tolerance - blending all of these into a context that is consumable by all and gives the right emphasis at the right time.

Leave this session with simple visualizations and approaches that you can apply immediately to start blending product with architecture, especially if you are looking to run in a cloud world.

Event-driven architecture promotes the production, detection, consumption of, and reaction to events. Using this type of architecture can improve how your products respond to events coming in from multiple sources – especially when you need to take various actions based upon an event. During this session, we’ll explore event-driven architecture and how we can incorporate it into a microservice pattern to develop lightweight services that can quickly react to events coming from multiple sources. While the architecture can work with different technologies, we’ll implement this approach using Azure services.

Testing is vital to any software project. Automated tests help improve confidence in code changes as you increase project velocity. Finding the right tools and libraries can be an arduous process. And, in most languages, adding testing means adding a pile of new dependencies to the project. But, have you ever tried the tools built right into the language? One of the beauty's of the Go programming language is that it is built with productivity in mind. The creators of the language have included many tools that make developers productive--including a robost testing framework. Come see how easy it is to get started with Go's testing library and see many of the features that will keep you using it in all your projects.

The OAuth standard has been around for a while, but traditionally it has required a back-end server to hold a client secret, well, secret. Managing secrets can be a very hard problem to solve. Until now! By supporting Proof Key for Code Exchange, or PKCE, OAuth flows can now be accomplished entirely in the client--and still be secure. In this talk we begin the standard three-legged flow and then introduce PKCE. By the time you leave, you will understand how to implement it in your client applications and the benefits for doing so.

I find 2 things to be consistent. More and more organizations are embracing Agile and more and more organizations are beginning to understand the value of their data. I work with organizatons undergoing an agile transformation. The question comes up "What about the data teams?" Can they be agile? Join me as I walk through 2 case studoes using different approaches while working with data teams.

This talk is designed to quickly introduce developers to a wide range of useful tools and services we have found extremely useful in helping us provide better solutions, improving our development process, and generally just making our lives easier.

These tools range from sites that provide useful services for developers, APIs we frequently utilize within our applications to provide more capabilities, SDKs and libraries we commonly leverage, and utilities we find useful.

Our goal with this talk is to quickly demonstrate a large number of useful tools, utilities, and APIs and leave attendees with the resources they need to find out more. Some of these tools are free/open source and others are commercial, but we find them all extremely useful and can’t wait to share how we use them.

We will discuss:

Developer utilities (all the way down to our favorite command prompts) 3rd party APIs Productivity software IDEs and plugins Useful NPM and NuGet packages

As a consultant, I get to see many systems built by many different developers. Recently, I’ve seen an uptick in the number of systems built with a microservice architecture in mind, but those systems often include a lot of the same mistakes that keep them from working well.

In this session you’ll learn from my experiences and get pointers on what to avoid in your microservices implementations so that you don’t accidentally build something which has all the worst aspects of a monolithic application and the worst aspects of microservices These monsters are what I call “distributed monoliths”, and I can help you avoid building one accidentally.

Organizations undergoing change must embrace the idea of experimentation. Those that only change vocabularies and not behaviors wonder why they quickly fall back into old habits, why the changes did not ‘stick’. Those organizations failed to embrace or misunderstood the objectives of experimenting. Organizational learning happens when people begin questioning the way things are done, they begin trying out different ideas together and share those learnings. Join me as we explore what it means to have an experimentation mindset.

Bigfoot has been a staple of American folklore since the 19th century. Many are convinced that Bigfoot is real. Others suggest he’s merely a cultural phenomenon. And some just want to believe. There is even a group, the Bigfoot Field Researchers Organization, that tracks Bigfoot sightings and makes the reports available online. And they have thousands of reports.

I want to explore this delightful data but, unfortunately, it’s been made for the convenience of humans and not computers. While this makes it easy for me to read, searching for reports can be a bit of a challenge. Some of the data is tidy and computer friendly—like the latitude and longitude. Other bits are really for us humans—like the eyewitness accounts. So, how can I find the Bigfoot sightings that interest me most with data structured like this?

Well, I’ll show you! In this talk, I’ll load these Bigfoot sightings into Redis and use RediSearch to index them, making it easy to query both the computer friendly bits and the human friendly bits. I’ll also show you how to search on fields, find keywords within text, find nearby Bigfoot sightings using geolocation data, and run queries that aggregate these searches.

When we’re done, you’ll know how to quickly search, query, and aggregate data in Redis using RediSearch. You can use this newfound power for boring old corporate data, but I’m going to use it to find Bigfoot!

Problems are inevitable, so it is critical to be able to detect them as quickly as possible. This session will give an overview of how to use three open-source tools - Prometheus, Grafana, and Mimir - to set up a production-ready observability platform and find problems faster.

Specifically, this session will cover: * An overview of Prometheus, from setup to scraping metrics * Methods to produce metrics on various systems * An introduction to Grafana, including using the built-in Alertmanager and example use cases * Utilization of Mimir to store metrics long-term * Ways to encourage developers and operations to use the platform

After this presentation, you will have the foundation needed to implement a comprehensive alerting solution for your business.

I've spent nearly half of my 20 year software development career enamored with functional programming and embracing its principles. Imagine my horror then when my career took an unexpected turn and I suddenly found myself working on a greenfield project, building a brand new API...in node.js. JavaScript. The wild west. Surely there was no way a functional programmer like me could ever thrive in this world. Or was there?

Learn how I've applied functional principles via modern JavaScript features such as scoped declarations, array methods, arrow functions, and the reflection APIs to build the flexible, scalable, and responsive system that powers my company's business.

Mobile development is one of the most exciting kind of projects to work on. With the proliferation of smartphones, it has been made easy to reach a large number of users via mobile apps. With the invent of App Store and Play Store, the mobile development space has grown exponentially. The technology has come along way and has made getting started with mobile development much easier.

In this session, we will explore several ways to getting started with mobile development for iOS and Android. Difference and opportunities between native and cross-platform platforms, and progressive web apps (PWA), and their tradeoffs, and the job market of the future.

#### (and other stories from the backlog)

“I just don’t know what else I can do, man. I’ve tried everything.”

Roger had my attention. The only emotion he'd shown me before now was I’ve got this, I don’t need your help. The development team he led just would not deliver fast enough. And, at first glance, it did look like he had tried everything in his power as their manager.

But before long, Roger's team became known for their quickness, all but erasing their old reputation.

Wait, what happened? Come hang with me for an hour, I'll tell you all about it.

Software is a game of insight. And stories are the best way we have to share our insights with each other. By sharing them, we elevate our work, our industry, and our lives as software professionals.

I've got stories to tell you about the teams I've worked with. You'll see yourself and your team in theirs. You'll ride the ups and downs with them from the safety of your chair. You'll walk away with the lessons they lived. And you'll probably realize how many stories you have to tell, too.

In this session we will take a look at how AutoFixture can simplify the arranging and asserting portions of your .NET unit tests. We'll explore how it integrates with mocking libraries to allow you to easily write tests and have dependency types automatically mocked and injected into your object under test. We'll also look at how AutoFixture can be extended and customized to make you more productive with your domain specific types. Why build your own mocks or create custom fakes when AutoFixture can do it for you?

Visual perception and the sense of sight is critical to most of the tasks we do on a daily basis, and humans are very visually driven beings. As we look for ways that AI can help us automate and simplify things in our lives, we must also give our computers a way to “see”. Computer Vision technology does that and equips companies with real-time intelligence through AI and machine learning. By understanding what is in your images and video feeds you gain new insights and the ability to act on them more quickly and strategically. In this presentation we will look at what computer vision is, the common problems that computer vision helps solve, the steps involved in creating your own computer vision solution, and some sample case studies to show the types of things a computer vision solution can achieve. This will be a code free presentation focusing on the core concepts and the art of the possible.

Are you using JWT tokens to secure your .NET web APIs? Are you also worried about the security of using long-lived tokens or about possible holes in your token refresh implementation?

If that sounds like you: fear not—all your answers are here in this session. Join me as I cover all the JWT and refresh token best practices, and help you make sure you’re following them. We’ll even look at a real token and refresh implementation which you can build off of in your projects. Join us, and make sure you’re not making a mistake with this common security technology.

As the organizer for Vue.js Indy (since 2016), I've done about 100 different iterations on "Intro to Vue". This event will be a guided interactive talk, where you get to play around with Vue directly learning the basics, and also in a full web app with components (so bring a laptop to follow along).

We'll cover what parts of Vue are "borrowed" from other frameworks that can make it feel so familiar, and how they changed, simplfied, or improved on those ideas. And what innovative features Vue has come up with over the years that I STILL can't beleive no one else is copying from them.

This will be a light-hearted, beginners-welcome, fun talk, where everyone can speak up, ask questions, and get the most out of our time.

When it comes to popular Christmas movies there's a recurring debate as to whether or not that list of movies should include the 1988 film Die Hard. Thankfully, machine learning has been applied to this problem and we have an answer.

We'll start off by using Python, Pandas, and Jupyter Notebooks to analyze and clean movie data and then prepare it for model training while avoiding factors that might introduce bias.

After that we'll explore using the beginner-friendly features of Azure Machine Learning Studio's Automated ML to train and evaluate a classification model.

Finally, we'll deploy the trained model to Azure as a web service and see what it has to say about Die Hard.

By the time we're done you'll know the truth about Die Hard and have a deeper understanding of machine learning experiments and some common beginner-friendly tools involved in machine learning.

Metadata, data about data, is everywhere. We seem to intrinsically understand that using data to further describe the data within our systems brings numerous benefits to taming complexity. It follows then that metaprogramming, programming that interacts with the program itself by inspecting or even manipulating its own code can bring similar benefits to our software.

ES6 greatly expands upon JavaScript's existing metaprogramming capabilities with the Symbol, Reflect, and Proxy types. Through some practical examples we'll discuss the role each of these types play within JavaScript metaprogramming and see how they not only affect your code but even drive several modern language features.

Since C# was rewritten entirely from scatch for version 6, the updates to the C# language have been coming very quickly, both in major version release which typically correspond to a Visual Studio release, and out-of-band point releases that get new, useful features in developers' hands sooner rather than later. With all the changes happening, it's difficult to keep up, and that means you may be missing out on some language features that will make you a more productive programmer. In this session, I'll take you through some of the best C# language features that have been introduced recently and prepare you to use them to their full potential.

Two of the hardest challenges in software development are building the right thing and building the thing right. The first problem comes from a lack of understanding of what users want. The second comes from the fact that the complexities of software make it challenging to build high-quality applications.

It might not surprise you that humility increases empathy for users, which helps us make sure we're building the right thing. However, did you know that Dijkstra once said humility was also a key to producing high-quality software?

We will look at practical ways intellectual humility can help you be a better software developer. I'll show you how humility drives you to use abstraction to manage complexity. I'll show you have it enables you to find alternative solutions to problems. And I'll show you how it helps you focus on the needs of the user.

In the modern software landscape, humility is a tool that can level you up as a developer. It deserves a place in your toolbox.

To empower citizen developers and to address the shortage of professional developers, low-code solutions have been increasingly populer. In recent years, Microsoft low-code offerings have introduced an ecosystem where low-code and pro-code can both contribute in the same project to accelerate business outcomes.

In this session, you will learn about low-code solutions and tools offered by Microsoft Power Platform, such as, Power Automate, Power Apps, and Power Pages.

With the recent updates to HTML/CSS/Javascript we can replicate much of the functionality of our favorite framework without having to install the framework, dependencies and then manage the versions. Instead we can write vanilla JS code coupled with HTML & CSS and get the same effect as we did with those frameworks. This session will look at using just HTML, CSS and Javascript to create a simple multi-view SPA application. In building the application we will take a close look at building a router, creating a reusable site structure and how to create multiple views. By the end you will have all the tools to create your own framework or perhaps just understand some of the inner workings of the one(s) you use.

This session is designed to introduce developers how to effieciently query their document databases. We will also look at metrics that could be a bad query smell.

We will be using Mongo in this session for our document store. All of these principals still apply to other Document stores.

Whether you are creating an open source library or building enterprise app core components, you need to get that functionality into other projects. But developing these resources is usually easier than consuming them. How about a worry free way to distribute and reference those resources in your project that will let you stay up to date, but allow you to avoid problems that may introduce breaking changes or new bugs? NuGet packages to the rescue! We'll also take a look at where you can find NuGet (packages aren't just for code any more) and how to create, distribute, and maintain your very own package. Then, you’ll be ready to share your package with your team, your enterprise, or even… The world!

Markov Chain is a probability theory that has been gaining popularity in modeling the likelihood of customer behavior. Monte Carlo Markov Chain (MCMC) is a particularly useful variation in marketing and finance problems involving a probability analysis of data, especially when machine learning is a factor in delivering a solution. In this presentation attendees will learn about creating a Monte Carlo Markov Chain model using R programming libraries. Attendees will learn the best cases to apply these techniques for data models used in marketing, finance, and various projects.

The tools and toolchains we use in modern software development make creating powerful, maintainable software easier than ever. However, this comes at a price: The ever-changing, evolving set of tools makes the process of setting up a development environment far more difficult. Depending on how many projects you need to work on, potentially across different stacks (or even different versions of the same stack), getting an engineer's development environment set up properly can be a real pain.

With Visual Studio Code Dev Containers, you can containerize an entire development environment, complete with all code, required tools and even VS Code extensions, allowing engineers to simply spin up the entire environment on-demand. You can standardize the environment so that all engineers are working with the same versions of the tools as everyone else. New hires can be ready to run, debug and commit changes to a codebase on their first day. Open-source contributors can easily open the code and be ready to contribute without having to configure complex environments.

In this session, I'll walk through the benefits of Dev Containers and how to create them for your new or existing projects.

Scaling - every organizations primary concern. Sure something is great and works, but will it scale?

The problem is no one ever talks about what they mean by scale and what they expect.

In this session we look at different meanings of scale. For each, we look at ways we ‘could’ scale.

Setting up a database table to store user information and have a webAPI method to login is just the beginning. Once a user is logged in you need to return a token for subsequent calls, and store that somewhere so the user doesn’t have to constantly pass their username and password. The database can store user roles and rights allowing the user access to only certain calls or privileges. This course takes a simple view at doing this from scratch with a simple SQL database, .NET WebAPI and an HTML front end. We will also look at testing our WebAPI in Postman. By the end of the course a base security scheme can be achieved and further built upon.

Accessibility is now and has been a hot topic for many years. Web projects come in all sizes as well does team support. From small startups, all the way to entrenched enterprise solutions, addressing accessibility continues to be a challenge. TBH, HTML and CSS by itself is 100% accessible. But as soon as we start to add complex layouts and interactive elements, things breakdown fast.

Of the 10 most common accessibility issues #4 jumps out at me as a complex issue wrapped up in a mosaic of issues.

Missing WAI-ARIA attributes

The Web Accessibility Initiative – Accessible Rich Internet Applications (WAI-ARIA) is a technical specification used by developers to build accessible interactive content. Interactive content includes elements like drag-and-drops, accordions, or sliders. Unfortunately, these types of interactive content interfere with users who rely on screen readers or speech instructions if they’re not implemented properly.

The web today and the web of the future is complex and it will get even more complex. Users are demanding more and more complexity as far as interactive elements and immersive experiences all at the same time, we can not leave people with disabilities behind.

It is here where we have the challenge. Stipulating that all the devs in an org will be 100% fluent in accessible code is a bar that few will set. All the documents and lunch-n-learns will not solve this either. In this talk I will go over modern strategies for how we can all ship accessibility.

Takes aways

Attendees of this talk will learn how a team of dedicated engineers with full knowledge of accessibility standards can set web dev teams up for success. Leveraging modern HTML tools developers can solve these issues and ship consistent experiences that can be used in any modern development framework with accessibility rules made available via a declarative API.

Aircraft are everywhere. Knowing exactly where is paramount as it’s considered bad form for two aircraft to be in the same place at the same time. To avoid this, aircraft worldwide constantly and publicly broadcast their location, heading, and all sorts of other data using a system called ADS-B or Automatic Dependent Surveillance Broadcast.

This data is a natural fit for a streaming architecture. After all, it’s a constant stream of data that is literally being broadcast in real-time. But how can we capture these broadcasts and the data within? Surely it must require expensive hardware and special tools!

Not so much. It turns out that we can capture ADS-B data easily using a combination of a cheap radio dongle and free software—a combination called software-defined radio. From there we can store it in a streaming data structure and consume, transform, and publish it using microservices. Cool, right?

In this session, you’ll learn how software-defined radio works (and not just for ADB-S), how to receive and store ADS-B data in streams, and how to use those streams with microservices. And, I’ll do it all by example—building a dashboard showing real-time flight data using Node.js, Redis Streams, and whatever front-end JavaScript framework happens to be popular that day!

Security vulnerabilities in software are almost always a result of malicious user input. The solution then, of course, is to securely sanitize all user data to avoid any issues. But, in a large application, there are numerous places this sanitation can happen. To name a few, the data can be validated when it first arrives or it can be encoded when it is exported back to the user or sent to a backend service such as a database.

In this session, I will cover the best places to sanitize user data to avoid security issues and the advantages and disadvantages to each approach in your code.

Deploying an application to Kubernetes can be challenging. In this session, we are going to unpack setting up a Kubernetes platform using VMware’s open-source Tanzu Community Edition (TCE). Discuss best practices around deploying applications to Kubernetes. Tanzu Community Edition is an open-source Kubernetes platform from VMware that installs easily, and includes a software supply chain based on Cartographer, Flux CD, Cloud Native Buildpacks, and Knative. You can install TCE in less than ten minutes. Once installed, you will have a fully functioning Kubernetes cluster with a supply chain that will automatically take source code from any SCM, build and deploy to Kubernetes.

Not all aspects of software architecture are glamorous, some are downright stressful and often lead to anxiety and stress. One of such roles is the selection of technology stacks and the decision making that goes into which solution should be utilized.

Even within the Microsoft space in 2022 we have so many different models of development that it is becoming increasily more difficult to make seemingly simple decisions such as which technology stack should be used and why. We are presented with so many options, how do we best analyze and select a platform? This session strives to dive into the decision making process, not necessarily any technology specific solutions. Looking at elements such as:

• Developer experience
• Training ability
• Future growth/patching tolerance
• Performance & Scale requirements
• Environmental requirements
• Time to delivery
• Deployment/update scenarios

All of these, and more, should be considered with each and every technology selection. it is very easy to back yourself into a corner without a proper approach to th decision making process.

At the end of this session attendees will have a framework of understanding with regards to technology stack evaluation and how best to pick a future solution while considering all of the risks/rewards.

Frontend developers want to build scalable solutions that delight their customers. However, many developers may not have the domain knowledge to work comfortably with a cloud-provider.

AWS Amplify changes that.

Using both frontend-centered language and tooling, it's now easier than ever to build and deploy scalable solutions that include an authentication, an API, database, and serverless functions. Doing so means less time configuring your services, and more time focusing on what makes your product amazing.

This talk with discuss these features, and showcase a demo.

As developers, we change things every day. Beyond automating the existing manual processes, we are the engine that drives processes towards new approaches for efficiency. However, too few developers get any education on how to leverage their position for better and more pervasive change. Join us as we walk through how developers lead change, what can go wrong, what we can do to make it better, and how we can all work in better environments based on how we show up to change the organization. No matter how powerless we may feel, through code, we have the capacity to change the world.

With shortage of skilled coders and IT professionals, managers can work smarter to maximize their team's productivity and quality.

In this session, you will get exposed to a set of practice that helps you to maximize productivity for your software teams and projects. These practices are derived from ancient wisdom and latest human resource research but applied to software development.

Bring your questions and scenarios.

Tranio tells Lucentio that, “No profit grows where is no pleasure ta’en: In brief, sir, study what you most affect.” While Tranio’s point was to get Lucentio to loosen up for him to “live a little,” this is still a valuable lesson to developers. Your team has worked hard to build the functionality that provides all of your customers’ needs, but how easily have you made it for them to access that? Sometimes building the API is the easy part; making them usable is the hard part. But by adding an API gateway, we can make it easier for customers to access functionality and data provided by your application.

In this presentation, we will look at API gateways in general and how to use them to make your APIs usable. We’ll then go into examples using Azure’s API Management service, which allows you to streamline work in Azure and across hybrid and multi-cloud environments to provide your customers with a single place to work with your APIs.

TypeScript enables web developers to improve the clarity and reliability of their code. It also enables more powerful tools for writing code. This led to its rapid rise in popularity. But what can it do for you beyond just adding types to your variables and parameters? In this talk, we look at some of the more advanced features in the language that can help you deliver valuable solutions in less time.

In this session, we will look at features such as: * union types * intersection types * mixins * generics

We will also look at some of the new features in the latest versions of TypeScript

We’ve asked our users and stakeholders, and they’ve given us answers, but at some level, we all know that the answers aren’t the whole truth. Here’s how to get the real requirements. To get real requirements, we need the wisdom of anthropologists, the study of marketing, and psychology. In this session, you’ll learn how to leverage questions to capture and refine your requirements quickly. You’ll discover how market researchers reveal more about people's needs and wants than they know themselves. You’ll learn how psychologists, counselors, and skillful conflict negotiators find ways of getting people to talk even when they don’t want to.

Natural language processing is a technique for taking human understandable text and wresting machinable information from it through a variety of techniques. When we think about NLP, we typically think about tasks like assessing the tone of a passage of text, answering questions stated in natural language, or summarizing a large amount of text. We recently helped a client build a system for scoring pre-interview screening assessments using AI & ML.

Typically, we spend a great deal of effort trying to convince our clients that there are AI techniques relevant to their problems, and that those approaches are mature enough for prime-time use. Here, we had the opposite problem: Our client knew AI was appropriate for their problems, and they were absolutely convinced it was ready for deployment. However, they wanted to use AI to solve all of their automated scoring problems. Over the course of building the system, we found several situations where simpler non-AI techniques could provide comparable or better performance than state of the art AI.

In this talk, we’ll discuss:

• Why automating scoring was a fundamental business need for our client
• What their technical approach to automated scoring was
• How we improved their existing AI models
• How we identified situations where AI wasn’t the best approach

By the end of the talk, the audience will:

• Have been introduced to several models for AI-based natural language and code understanding
• See a 10,000 foot view of how to automate scoring rubrics for assignments that include both programming and human communication
• Have some rules of thumb for deciding when AI is necessary or when a simpler technique is likely to exist or be more desirable.