Brent Laster

GitHub Copilot is a popular AI assistant that helps software developers more easily create content, get answers to coding-related questions, and handle many of the boilerplate tasks of software development. But it can also do much more in the areas where it can be used. Join Copilot expert (and author of the upcoming “Learning GitHub Copilot” book from O'Reilly) for a quick overview of some of the additional tips and tricks to allow you to make the most from this AI assistant.

Most users know GitHub Copilot can help with the basics of code generation, creating test cases, documentation, etc. But because the tool is AI based, there's a lot more that it can help you with in these areas simply by asking it and giving it the right prompts. In this session, we'll take a look at some ways to leverage beyond the basics of these tasks to creating results that are usable more deeply and widely. We'll also look at some ways to compensate when Copilot does not have the most recent information, or needs to be picking up more relevant context.

In this ½ day course, author and trainer and DevOps Director Brent Laster will take you beyond the basics of Kubernetes to understand the advanced topics you need to know to ensure your success with K8S.

In plain and simple explanations and hands-on labs, you’ll learn about key concepts such as RBAC, admission controllers, affinity, taints and tolerations mean and how to use them. You’ll learn tips to debug your Kubernetes deployments and how to leverage probes to ensure your pods are ready and healthy – and what happens when they aren’t.

Along the way, we’ll give you hands-on experience and time to play with these concepts in a simple minikube environment running on your own virtual machine that you can keep as a reference environment after the course.

Learning and understanding AI concepts is satisfying and rewarding, but the fun part is learning how to work with AI yourself. In this presentation, author, trainer, and experienced technologist Brent Laster will help you do both! We’ll explain why and how to run AI models locally, the basic ideas of agents and RAG, and show how to assemble a simple AI agent in Python that leverages RAG and uses a local model through Ollama.

Join us to learn about all 3 topics in 90 minutes!

No experience is needed on these technologies, although we do assume you do have a basic understanding of LLMs.

This will be a fast-paced, engaging mixture of presentations interspersed with code explanations and demos building up to the finished product – something you’ll be able to replicate yourself after the session!

Containers are all the rage these days – from Docker to Kubernetes and everywhere in-between. But to get the most out of them it can be helpful to understand how containers are constructed, how they depend and interact with the operating system, and what the differences and interactions are between layers, images, and containers. Join R&D Director, Brent Laster as he does a quick, visual overview of how containers work and how applications such as Docker work with them.

Topics to be discussed include:

• What containers are and the benefits they provide
• How containers are constructed
• The differences between layers, images, and containers
• What does immutability really mean
• The core Linux functionalities that containers are based on
• How containers reuse code
• The differences between containers and VMs
• What Docker really does
• The Open Container Initiative
• A good analogy for understanding all of this

Updated! LM Studio is an easy to use desktop app for experimenting with local and open-source Large Language Models (LLMs) by hosting them on your own system.
Here are some of the features it provides (quoted from its homepage):

Run LLMs on your laptop, entirely offline
Use models through the in-app Chat UI or an OpenAI compatible local server
Download any compatible model files from HuggingFace repositories
Discover new & noteworthy LLMs in the app's home page

Hugging Face is a community hub focused on creating and sharing AI models. It provides many free and pre-trained models as well as datasets and tools to use with them.

Ollama is a command line tool for downloading, exploring, and using LLMs on your local system.

In this hands-on workshop, we'll cover the basics of getting up and running with LM Studio, Ollama and give you hands-on labs where you can use them and Hugging Face to find and load and run LLMs, interact with it via Chat and Python code and more!

Join author, trainer and speaker Brent Laster to learn about LM Studio, Hugging Face, Ollama, and Streamlit and how to use them to find and use Large Language Models hosted and running in your own environment. Get hands-on experience with the applications and learn how to DIY your own Gen AI!

Agenda:

Section 1: Introduction

In this section, we'll talk about what LLMs are, learn about basic use of LM Studio to find models and also start to look at huggingface.co.

Lab 1 - Lab 1 - Getting familiar with LM Studio and models

Purpose: In this lab, we’ll start to learn about models through working with one in LM Studio.

Section 2: Chatting with LLMs and using their APIs

In this section, we'll learn about how we can chat with an LLM, the different roles involved in chatting, and how to also use API calls from the command line to interact with models.

Lab 2 - Chatting with our model

Purpose: In this lab, we'll see how to load and interact with the model through chat and terminal.

Section 3 - Programming for local models

In this section, we'll look at how to create some Python code to interact with LM Studio with its lms interface and lmstudio.js library for JavaScript and Typescript.

Lab 3 - Coding to LM Studio

Purpose: In this lab, we'll see how to do some simple Python and JavaScript code to interact with the model.

Section 4 - Leverage HuggingFace.co

In this section, we'll look more into the model details and tools for using models that Hugging Face offers, including its transformers library and pipelines.

Lab 4 - Working with models in Hugging Face

Purpose: In this lab, we’ll see how to get more information about, and work directly with, models in Hugging Face.

Section 5 - Using Ollama

In this section, we'll learn about how we can use the standalone tool Ollama to get and run LLMs. We'll also talk about multimodal models.

Lab 5 - Using Ollama to run models locally

Purpose: In this lab, we’ll start getting familiar with Ollama, another way to run models locally.

Section 6 - Creating simple UIs for GenAI with Streamlit

In this section we'll work with a graphical Python library, Streamlit to see how to quickly and easily create interactive interfaces like chatbots to use with our local LLMs.

Lab 6 - Building a chatbot with Streamlit

Purpose: In this lab, we'll see how to use the Streamlit application to create a simple chatbot with Ollama.

GitHub Copilot Extensions are integrations designed to enhance GitHub Copilot’s functionality by allowing it to interact with external tools, services, and custom workflows directly within development environments. These extensions enable developers to perform tasks such as querying databases, monitoring deployments, retrieving documentation, or automating actions without leaving their coding interface, thereby reducing context switching and improving productivity.

In this presentation, we’ll explore how to extend GitHub Copilot’s functionality to work with your own apps through the GitHub Copilot Extensibility Platform. Attendees will learn about Copilot Agents, skillsets, and VS Code chat participants – the 3 ways to interact with the platform.

In this presentation, we'll cover the options, tips, and tricks for using GitHub Copilot to help us identify how to test code, generate tests for existing code, and generate tests before the code.

Join global trainer, speaker, and author of the upcoming book, Learning GitHub Copilot, Brent Laster as he presents material on multiple ways to leverage Copilot for testing your code on any platform and framework.

Have you wondered what options GitHub Copilot can provide for helping to not only write your code, but test your code? In this session, we'll examine some key ways that Copilot can support you in ensuring you have the basic testing needs covered. In particular, we'll cover:

• A quick overview of GitHub Copilot
• Letting Copilot tell you how to get started testing for a new language
• Creating tests for existing code through one-step commands
• Creating tests for existing code with comments
• Creating tests for existing code with explicit prompts
• Validating inputs to functions using Copilot
• Using Copilot to build out tests for edge cases
• Leveraging testing frameworks
• Building tests before the code - TDD with Copilot

In this workshop, we'll cover the options, tips, and tricks for using GitHub Copilot to help us identify how to test code, generate tests for existing code, and generate tests before the code.

Join global trainer, speaker, and author of the upcoming book, Learning GitHub Copilot, Brent Laster as he presents material on multiple ways to leverage Copilot for testing your code on any platform and framework.

Have you wondered what options GitHub Copilot can provide for helping to not only write your code, but test your code? In this session, we'll examine some key ways that Copilot can support you in ensuring you have the basic testing needs covered. In particular, we'll cover:

• A quick overview of GitHub Copilot
• Letting Copilot tell you how to get started testing for a new language
• Creating tests for existing code through one-step commands
• Creating tests for existing code with comments
• Creating tests for existing code with explicit prompts
• Validating inputs to functions using Copilot
• Using Copilot to build out tests for edge cases
• Leveraging testing frameworks
• Building tests before the code - TDD with Copilot

Get handson learning to understand and utilize Generative AI from the ground. Work with key AI techniques and implement simple neural nets, vector databases, large language models, retrieval augmented generation and more all in one single day session!

Generative AI is everywhere these days. But there are so many parts of it and so much to understand that it can be overwhelming and confusing for anyone not already immersed in it. In this fullday workshop, opensource author, trainer, and technologist Brent Laster will explain the concepts and working of Generative AI from the ground up. You’ll learn about core concepts like neural networks all the way through to working with Large Language Models (LLM), Retrieval Augmented Generation (RAG) and AI Agents. Along the way we’ll explain integrated concepts like embeddings, vector databases and the current ecosystem around LLMs including sites like HuggingFace and frameworks like LangChain. And, for the key concepts, you’ll be doing handson labs using Python and a preconfigured environment to internalize the learning.

In this full-day workshop, open-source author, trainer, and DevOps director Brent Laster will provide an extensive introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionalities and features they provide.
You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as more advanced workflows to automate typical CI/CD and other tasks. And you’ll learn about
how to create and use your own actions, create and manage artifacts, and how to debug and secure your GitHub Action workflows.

This course will leverage hands-on, guided labs using GitHub and GitHub Actions so that participants can gain “real-world” experience with GitHub Actions.”

GitHub Copilot is a generative AI tool for coding that assists developer in writing code more efficiently and faster. This full-day course will help you gain a comprehensive understanding of the tool's capabilities and how to use it effectively in your day-to-day coding.

In this full-day class, we'll cover the basics of Copilot and provide you with hands-on experience through labs. You'll learn the what, why, and how of Copilot and see how to leverage its generative AI functionality in daily coding tasks across multiple languages. You'll also learn key techniques and best practices for working with Copilot.

IMPORTANT NOTE: In order to do the labs for this course, you must have a GitHub Copilot subscription. If you do not, you can log into GitHub, then go to https://github.com/settings/copilot and sign up (start free trial) before the course.

Just as CI/CD and other revolutions in DevOps have changed the landscape of the software development lifecycle (SDLC), so Generative AI is now changing it again. Gen AI has the potential to simplify, clarify, and lessen the cycles required across multiple phases of the SDLC.

In this session with author, trainer, and experienced DevOps director Brent Laster, we'll survey the ways that today's AI assistants and tools can be incorporated across your SDLC phases including planning, development, testing, documentation, maintaining, etc. There are multiple ways the existing tools can help us beyond just the standard day-to-day coding and, like other changes that have happened over the years, teams need to be aware of, and thinking about how to incorporate AI into their processes to stay relevant and up-to-date.

Just as CI/CD and other revolutions in DevOps have changed the landscape of the software development lifecycle (SDLC), so Generative AI is now changing it again. Gen AI has the potential to simplify, clarify, and lessen the cycles required across multiple phases of the SDLC.

In this session with author, trainer, and experienced DevOps director Brent Laster, we'll survey the ways that today's AI assistants and tools can be incorporated across your SDLC phases including planning, development, testing, documentation, maintaining, etc. There are multiple ways the existing tools can help us beyond just the standard day-to-day coding and, like other changes that have happened over the years, teams need to be aware of, and thinking about how to incorporate AI into their processes to stay relevant and up-to-date.

What you will learn

In this half-day workshop, open-source author, trainer and DevOps director Brent Laster will provide a solid introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionality and features they provide. You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as how they can fit into a CI/CD environment. And you’ll learn about how to create and self-host your own actions.

This course will leverage hands-on, guided labs using GitHub and GitHub Actions so that participants can gain “real-world” experience with GitHub Actions.

Draft course outline (subject to change)

Section 1: A quick intro to GitHub Actions

Content: In this section, we’ll cover the basics of GitHub actions – what are they and why would we use them? We’ll cover what “event driven” means and what events, jobs, actions, steps, runners and workflows are. And we’ll see how they all related to each other and work together. We’ll see how to create and store a GitHub action. Finally, we’ll look at how to create a simple action.

Lab 1: Creating a simple example – In this lab, we’ll get a quick start learning about GitHub Actions by creating a simple project that uses them.
We'll also see what a first run of a workflow with actions looks like. this lab, attendees will create and use a basic GitHub Action

Section 2: Taking actions further

Content: In this section, we’ll cover how to find GitHub actions that might be of interest. We’ll look at how to share and version actions. And we’ll see how to use additional features with actions.

Lab 2: Learning more about Actions – In this lab, we'll see how to get more information about Actions and how to update our workflow to use others. We'll also see how to add jobs and commit changes through the browser interface.

Section 3: Working with your own action

Content: For this section, we’ll look at how to create and then use your own custom action

Lab 3: Adding your own action - in this lab, we'll see how to create and use a custom GitHub Action

Section 4: Looking at action logs and getting details

Content: For this section, we’ll dive into the logs produced for GitHub actions to understand what's really happening on the runner systems and also look at how to add some simple markup to add a status badge on your project.

Lab 4: Exploring logs - in this lab, we'll take a closer look at the different options for getting information from logs.

Section 5: Getting debug info

Content: In this section, we’ll cover how to get debug information when running through actions and workflows.

Lab 5: Looking at debug info - in this lab, we'll look at some ways to get more debugging info from our workflows

Part 6: Working with advanced workflows

Content: In this section, we'll look at various examples of advanced workflows including chaining workflows, using conditionals, and working with REST APIs to drive other events in GitHub.

Lab 6: Chaining workflows, using conditionals, and working with REST APIs in workflows.

MCP, or Model Context Protocol, is a standardized framework that allows AI agents to seamlessly connect with external data sources, APIs, and tools. Its main purpose is to make AI agents more intelligent and context-aware by giving them real-time access to live information and actionable capabilities beyond their built-in knowledge.

Join AI technologist, author, and trainer Brent Laster as we learn what MCP is, how it works, and how it can be used to create AI agents that can work with any process that implements MCP. You'll work with MCP concepts, coding, servers, etc. through hands-on labs that teach you how to use it with AI agents.

With MCP, developers can easily integrate AI agents with a wide variety of systems, from internal business databases to third-party services, without having to build custom integrations for each use case. MCP servers act as gateways, exposing specific actions and knowledge to the AI agent, which can then dynamically discover and use these capabilities as needed. This approach streamlines the process of adding new functionalities to AI agents and reduces ongoing maintenance.

MCP is particularly useful for scenarios where AI agents need up-to-date information or need to perform actions in external systems-such as customer support bots fetching live ticket data, enterprise assistants accessing knowledge bases, or automation agents processing transactions. By leveraging MCP, organizations can create more adaptable, powerful, and enterprise-ready AI solutions that respond to real-world business needs in real time

In this presentation, we'll cover some of the latest developments and feature additions in GitHub Copilot as rolled out in recent months and at GitHub Universe. Join author, trainer, technologist, and author of the upcoming book “Learning GitHub Copilot” from O'Reilly, Brent Laster to learn what's new and exciting with this popular generative AI tool!

GitHub Copilot continues to evolve as a popular AI coding assistant, adding features and functionality regularly. But there are more significant changes that have been rolled out recently, including wider Copilot integration in the individual GitHub plan for things like indexing repos, pull request and issue summaries. Also, there's new functionality for reviewing code, agent edits, vision features, giving Copilot custom instructions that will apply to every chat, and more!