Skip to main content
AmigoFish

JetBrains

JetBrainsVideo

Format:
YouTube channel
New videos:
Several times a week
Typical length:
about 25 minutes, not counting Shorts
Latest video:
Not rated yet

About this show

We make you a better (professional) software developer.

JetBrains creates intelligent software development tools consistently used and trusted by 11.4 million professionals and 88 Fortune Global Top 100 companies. Our lineup of more than 30 products includes IDEs for most programming languages and technologies, such as IntelliJ IDEA, PyCharm, and others, as well as products for team collaboration, like YouTrack and TeamCity. JetBrains is also known for creating the Kotlin programming language, a cross-platform language used by more than 5 million developers worldwide yearly and recommended by Google as the preferred language for Android development.

Learn more about us and our products at https://www.jetbrains.com/

Videos come from the channel's public YouTube feed. The artwork is the newest video thumbnail. Last updated . Names, artwork and text belong to their publishers.

Cosmos

Similar by topic and creator

See the full Cosmos

Videos

  • Fix Your CI Without Leaving the IDE: TeamCity MCP and CLI | Artem Rokhin | GameDev Day 2026

    · 36 min

    Modern continuous integration shouldn’t force you to jump between your IDE, a browser, and a build server just to figure out why a build broke. This talk introduces two ways to bring TeamCity into your everyday workflow: MCP support, which lets Rider (and AI assistant) query builds and fix CI issues without leaving your editor, and the TeamCity CLI, for scripting and interacting with your server straight from the terminal. We’ll walk through a real Unity build pipeline as our example and then show how the same techniques carry over to any tech stack. You’ll leave knowing how to keep your CI close to where you actually work. Speaker: Artem Rokhin, Solutions Engineer, TeamCity, JetBrains Learn more: TeamCity MCP and CLI for AI agents: https://www.jetbrains.com/help/teamcity/ai-agent-integration.html Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore TeamCity: https://www.jetbrains.com/teamcity/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #TeamCity #Unity #CICD

    Not rated yet
  • Evolving a Live Game Engine: Introducing ECS Without a Full Rewrite | Alex Zhorau | GameDev Day 2026

    · 51 min

    This talk explores how the Entity Component System (ECS) paradigm can be introduced into an already shipped mass-market game without rewriting the entire engine or disrupting a live product. Drawing on experience with proprietary engines and Unreal Engine, it covers the practical challenges of connecting ECS to legacy scene representation, components, and scripting layers, as well as the compromises required around memory layout and performance. The session presents a staged migration approach and explains why a hybrid ECS and legacy architecture is often the most sustainable outcome for a live game. Speaker: Alex Zhorau, Software Engineer, Meta Medium: https://medium.com/@AZhorau Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #GameDev #ECS #GameEngines

    Not rated yet
  • How Static Analysis Can Help in the Age of AI | Kai Schmithusen | GameDev Day 2026

    · 32 min

    AI generates an unprecedented amount of code. However, it can also produce an unprecedented amount of technical debt. In this talk, we’ll start by aligning on our definition of code quality, what poor code quality means in terms of business outcomes, and the kinds of issues AI creates and why. We’ll then explain how static analysis can help you alleviate these problems and where it's most useful in an AI-powered development pipeline. To round it out, we’ll use a Qodana workflow as an example to show how it can be used to improve quality and cut costs in your projects. Speaker: Kai Schmithusen, Product Specialist and Global Sales Lead for Qodana, JetBrains Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Qodana: https://www.jetbrains.com/qodana/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #Qodana #StaticAnalysis #AI

    Not rated yet
  • Live-Building AI-Driven PCG with Godot, C#, and Gemini | Sharmishtha Sen | GameDev Day 2026

    · 35 min

    Creating vibrant, immersive game worlds shouldn’t require endless manual modeling or lead to repetitive designs. By leveraging the C# workflow improvements in Godot 4 with JetBrains Rider, developers can turn language models into procedural co-creators while keeping their own artistic vision intact. This 30-minute session builds a live procedural content generation (PCG) pipeline that turns human-friendly prompts into playable environments. It shows how to run a local open-source AI agent with Ollama alongside cloud endpoints to generate typed JSON configuration schemas that feed directly into statically typed C# models. You’ll see how to expose AI parameters and scene references in the Godot Inspector, so you can prompt, adjust seeds, and rebuild environments in real time, with immediate player execution and debugging feedback through Rider. Whether you’re crafting 3D heightmap terrain with FastNoiseLite or designing procedural 2D dungeons with TileMaps and dual-grid algorithms, the session shows how to connect algorithmic generation to handcrafted locations, keeping a solid foundation for tutorial areas, named landmarks, and designed gameplay moments. Speaker: Sharmishtha Sen, Game Developer and QA Specialist, Jet Heart Labs Portfolio: https://nyankonekomi.wixsite.com/samsportfolio Learn more: Godot support in Rider: https://www.jetbrains.com/help/rider/Godot.html Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Rider for Godot: https://www.jetbrains.com/rider/godot/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #Godot #ProceduralGeneration #AI

    Not rated yet
  • Death by a Thousand Ticks: Why Gameplay Systems Become Slow | Konrad Słoń | GameDev Day 2026

    · 57 min

    Gameplay performance doesn’t usually collapse in one catastrophic mistake. It erodes one engineering decision at a time. Through practical Unreal Engine examples, live profiling, and real-world debugging workflows, this session explores how everyday gameplay patterns turn into bottlenecks as a project grows. Following a complete optimization workflow with Unreal Insights and Rider, you’ll pick up practical techniques for building gameplay systems that scale and stay performant. Speaker: Konrad Słoń, Senior Gameplay Programmer, Fool’s Theory Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Rider for Unreal Engine: https://www.jetbrains.com/rider/unreal/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #UnrealEngine #GameDev #Performance

    Not rated yet
  • How We Automated Figma-to-Unity UI Integration With AI Agents | GameDev Day 2026

    · 35 min

    As AI moves into production pipelines, one question keeps coming up: How much UI integration can it really take on? This talk answers that question with a case study of a Figma-to-Unity pipeline that grew over years of production and now runs through an AI agent over MCP. Alina, Senior Unity Developer, and Olia, Lead UI/UX Designer, cover the design foundation, the lessons from building it, and a benchmark of what the agent can handle today. You’ll leave with a working solution and the tools to try it on your own projects. Speakers: Alina Chupakhina, Senior Unity Developer, Playkot Telegram: https://t.me/ai_games_lab Olia Chupakhina, Lead UI/UX Designer, Cubic Games Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Rider for Unity: https://www.jetbrains.com/rider/unity/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #Unity #AIAgents #Figma

    Not rated yet
  • Agentic Development in Unreal Engine with JetBrains Rider | Alexander Dzerakh | GameDev Day 2026

    · 23 min

    Generic AI can write code, but the hard parts of Unreal Engine development happen across editor workflows, engine subsystems, build errors, crashes, and configuration files. This session shows how JetBrains Rider, ACP, and UE-specific skills can give AI agents engine fluency and practical access beyond source code. Through live demos, we’ll cover AI-assisted workflows for architecture, C++ scaffolding, crash triage, actor placement, and automated testing. Speaker: Alexander Dzerakh, Product Manager for Rider (GameDev), JetBrains Learn more: AI agent skills for Unreal Engine in Rider: https://www.jetbrains.com/help/rider/AI_skills_ue.html Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Rider for Unreal Engine: https://www.jetbrains.com/rider/unreal/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #UnrealEngine #JetBrainsRider #AIAgents

    Not rated yet
  • How Epic's Lore VCS Handles Massive Binary Files | Ben Cooke & Ryn Slack (AWS) | GameDev Day 2026

    · 1 hr 7 min

    Game studios have a version control problem most software teams never deal with: repositories full of huge binary files, engine assets, packaged content, textures, and audio, where a single file can be several gigabytes and changes constantly. Git snapshots every file on every commit, which stops working at that size. Centralized tools scale better, but they solve it with edge servers that hold their own working replica, something you have to size and keep in sync ahead of time. Lore, Epic Games’ open-source VCS, doesn’t version whole files. It breaks them into content-addressable fragments, so changing part of a large asset only means moving the part that changed. That one design choice opens up more than faster commits. A new studio location or a distributed team doesn’t need a server pre-seeded with the whole repository, because an edge cache there fills in on demand as people work. CI pipelines get the same benefit, with disposable build agents that only ever pull the fragments a given build actually touches. It works because edge caches hold no authoritative data, the durable copy always lives in cloud storage, and QUIC keeps fragment transfer fast even at real production file sizes. In this session, Ben and Ryn walk through how this works end to end. Then, drawing on their experience as AWS Solutions Architects, they show how to deploy it yourself using the Lore module in AWS’s Cloud Game Development Toolkit. Attendees will leave with a working mental model of fragment-based storage, an understanding of why Lore’s architecture looks the way it does, and a starting point for running it themselves. Speakers: Ben Cooke, Senior Games Partner Solutions Architect, Amazon Web Services AWS for Games blog: https://aws.amazon.com/blogs/gametech/category/game-development/ Ryn Slack, Solutions Architect, Amazon Web Services Learn more: Lore on GitHub: https://github.com/EpicGames/lore Lore documentation: https://epicgames.github.io/lore/ AWS Cloud Game Development Toolkit: https://github.com/aws-games/cloud-game-development-toolkit Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #VersionControl #AWS #GameDev

    Not rated yet
  • Debugging Across Two Runtimes and Two Different Languages | Alex Drum (Hytale) | GameDev Day 2026

    · 55 min

    Your client is C# and your server is C++. How do you debug both of them at once and get something useful out of it? Rider and CLion give you the tools for both, and being able to read the data coming across the protocol while watching what each runtime is doing is a huge boost. This talk is about connecting the two and understanding where one ends and the next begins. That includes how to work out which runtime is lying, how to make a bug that spans both of them reproducible, and why the boundary is the last place to look rather than the first. Speaker: Alex Drum, Engine Developer, Hytale X: https://x.com/MelodicAlbuild Hytale: https://hytale.com/ Recorded at JetBrains GameDev Day Online 2026, a free online event for the game development community. Watch all GameDev Day 2026 talks: https://www.youtube.com/playlist?list=PLRyISO8WW3lQ Explore Rider: https://www.jetbrains.com/rider/ Explore CLion: https://www.jetbrains.com/clion/ Explore JetBrains tools for game development: https://www.jetbrains.com/gamedev/ #JBGameDevDay #Hytale #Debugging #GameDev

    Not rated yet
  • JetBrains Pafos Camp 2026: 12 Days of Competitive Programming

    · 3 min

    12 days, 8 contests, 22 teams, one goal: getting ready for the ICPC World Finals. These teams had already made it through the ICPC regional competitions and championships to earn their place in the World Finals. From August 18 to 29, teams from 19 universities across 14 countries came to Neapolis University Pafos for Pafos Camp 2026. They spent their days taking part in five-hour problem-solving contests and problem-analysis sessions with experienced coaches. In the evenings, they relaxed by the Mediterranean, played board games, and enjoyed long conversations. Congratulations to Segfault go BRRR (Delft University of Technology), Big as Hectic Dreaming (Eötvös Loránd University), and Infinite L∞pers (Karlsruhe Institute of Technology) – the top three teams in the camp standings. Thanks to everyone who made these two weeks happen! See you at the next contest! #ICPC #CompetitiveProgramming #PafosCamp #JetBrains

    Not rated yet
  • Building a Supply Chain Attack With .NET and NuGet | Maarten Balliauw | .NET Day 2026

    · 40 min

    "Haha, npm had yet another supply chain attack!" I'm waiting for the day this happens with .NET and NuGet. The tools are there! A number of interesting techniques exist to smuggle code into someone's codebase, malicious or genuine. In this talk, we'll look at several .NET, NuGet and MSBuild techniques to inject code into a software supply chain. We'll also look at some ways to mitigate the risk (but you can't eliminate it). Speaker: Maarten Balliauw, Duende Software Blog: https://blog.maartenballiauw.be/ LinkedIn: https://www.linkedin.com/in/maartenballiauw/ Bluesky: https://bsky.app/profile/maartenballiauw.be X: https://twitter.com/maartenballiauw/ Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Your AI Agent Says It's Done. Now What? Codex + JetBrains Air in Rider | .NET Day 2026

    · 20 min

    Agents can write a lot of your code now. You still decide what ships. In this .NET Day 2026 keynote, the JetBrains .NET team shows how JetBrains Air brings your agents into Rider, so you can check their work with the tools you already trust. Writing code got a lot cheaper. Being wrong didn't. What you'll see: Matt Ellis hands a real task to Codex inside Rider, then reviews, tests, and debugs the change before sending feedback back to the agent. Matthias Koch gives an agent the dotTrace skill so it can profile a .NET app and find a real bottleneck. Mehul Harry shows how ReSharper now works in VS Code, Cursor, and other compatible editors. Speakers: Anastasia Kazakova, Matt Ellis, Matthias Koch, Mehul Harry Try Air in Rider: https://www.jetbrains.com/air/ides?utm_source=youtube&utm_medium=video&utm_campaign=dotnetday26 Read about Air in IDEs: https://blog.jetbrains.com/ai/2026/10/air-in-ides-eap?utm_source=youtube&utm_medium=video&utm_campaign=dotnetday26 Get Rider: https://www.jetbrains.com/rider/?utm_source=youtube&utm_medium=video&utm_campaign=dotnetday26 Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Refinement-First Processes for AI Development | Stacy Cashmore | .NET Day 2026

    · 38 min

    "Yeah, yeah, but your scientists were so preoccupied with whether or not they could, that they didn't stop to think if they should." — Dr Ian Malcolm, Jurassic Park True in 1993. True today. When developers boast about writing 37,000 lines of code in a day, the question that matters isn't "how much code did you write?" — it's "what problem did any of it solve?" Our job as developers is to solve problems, and volume without value is wasteful. To deliver high-quality code that actually solves the right problem, teams must shift from thoughtlessly generating code to a structured, refinement-first approach. To scale this standard across an entire department, we built a two-stage process: refinement first, build second. Refinement takes a problem through hypotheses, an epic, features, and stories — each with its own prompt specialized to the task. And all before a line of code exists. The prompts are passed to a set of specialized AI agents in Claude Code or Copilot for building, orchestrated with OpenSpec. In building there are also multiple agents that between them handle: architecture, API design, writing tests, reviewing tests, coding, documentation, or logging architectural decisions. And all this in a development environment designed to allow teams to work without interruptions – YOLO mode, safely. This isn't the one true process; it's what works for us, refined through trial and error. Yours will look different. But the basics of it - refine before you build, and let AI specialise rather than generalise - will be a great base to start from. In this session I'll walk the process end to end, showing the real artifacts it produces at each stage: the prompts, the cost of running it this way, and the times it's gone wrong and needed rework. By the end, you'll have a concrete process you can adapt: how to structure refinement so AI doesn't just generate code, but high-quality code that solves the right problem — and an honest account of what it costs to run this way. Speaker: Stacy Cashmore, Tech Explorer DevOps, Omniplan Blog: https://stacy-clouds.net/blog-posts LinkedIn: https://www.linkedin.com/in/stacycash X: https://twitter.com/Stacy_Cash Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Scaling Blazor With .NET Aspire and Azure Container Apps | Michael Washington | .NET Day 2026

    · 30 min

    Escape the Monolith: Scaling Blazor with .NET Aspire and Azure Container Apps Building cloud-native, distributed Blazor applications doesn't have to be a logistical nightmare. Discover how to streamline the entire lifecycle of your web apps—from local development to global scale—using Microsoft .NET Aspire and Azure Container Apps. In this session, we will use the open-source Blazor Data Orchestrator as a real-world architectural example to demonstrate how to break down complex data workflows. You will learn how .NET Aspire simplifies local orchestration, service discovery, and telemetry, and how to seamlessly push that exact architecture to the serverless, highly scalable environment of Azure Container Apps. Speaker: Michael Washington, ASP.NET and C# programmer, ADefWebserver Website: https://blazorhelpwebsite.com/ GitHub: https://github.com/ADefWebserver LinkedIn: https://www.linkedin.com/in/michael-a-washington/ Bluesky: https://bsky.app/profile/adefwebserver.com Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Modular Monoliths: Goldilocks Architecture? | Steve Smith (Ardalis) & Eric Fleming | .NET Day 2026

    · 41 min

    Monolithic apps are the worst! They grow and grow until they collapse under their own weight as a Big Ball of Mud. Microservices are the here to save us! But wait, they're REALLY hard to get right and REALLY hard to manage at scale. In addition to whatever challenges you're facing with modeling the business problems, you now get to add all of the complexities of distributed computing on top of it. And way too often microservices end up being the worst of all worlds: the dreaded DISTRIBUTED MONOLITH. Enter, the Modular Monolith. Simple deployments. Cheaper hosting. Easier to extend. Still capable of supporting multiple independent development teams. Not too simple; not too complex. Maybe the it's Goldilocks solution your application has been yearning for. Speakers: Steve Smith (Ardalis), Cofounder and Principal Architect, NimblePros Blog: https://ardalis.com/blog LinkedIn: https://www.linkedin.com/in/stevenandrewsmith Bluesky: https://bsky.app/profile/ardalis.com X: https://twitter.com/ardalis Eric Fleming, Principal Architect, NimblePros NimblePros: https://nimblepros.com/ Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Messaging Patterns for Modern Software Solutions | Irina Dominte (Scurtu) | .NET Day 2026

    · 39 min

    Modern software systems are becoming ever more distributed and complex, requiring efficient and reliable communication mechanisms to maintain consistency and performance. With many moving parts, applying well-established patterns like Outbox, Inbox, and Sagas becomes crucial to achieving the key 'ilities' you are looking for. In this session, we will dive into practical use cases, demonstrating how these patterns can be leveraged to tackle some of the challenges in modern software architectures. Through real-world examples, you'll learn how these patterns can enhance the resilience and maintainability of your distributed systems, ensuring they meet the demands of today's complex environments. Speaker: Irina Dominte (Scurtu), Microsoft MVP, Software Architect, Particular Software Website: https://irina.codes/ LinkedIn: https://www.linkedin.com/in/irinascurtu/ X: https://twitter.com/irina_scurtu Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Interoperability of .NET | Sam Basu & Andres Pineda | .NET Day 2026

    · 39 min

    .NET is one the most interoperable tech stacks in software development – and if you haven't checked in lately, you're in for a surprise. Modern .NET runs everywhere, coded in rich environments like Visual Studio, VS Code, or Rider. Open-source platforms like Uno Platform take that same shared .NET codebase seamlessly to mobile, desktop, and web – native APIs on iOS and Android, full platform integration on Windows, macOS, and Linux, and performant Wasm apps in the browser. Modern .NET can reach embedded systems like Raspberry Pi and IoT, and lights up smart watches on Wear OS and watchOS. SkiaSharp handles high-performance rendering across it all, while polished design tools keep the developer loop fast and visual. .NET with modern AI Agents/Models, provides particularly powerful workflows. The C# MCP SDK makes standing up MCP Servers easy, and Skills or custom Agents turn Agentic hype into actual developer workflows – all backed by C#'s maturity and the flexibility of Roslyn. XAML remains rich and powerful, while developers get their choice of design patterns like MVVM or MVU, and Reactive patterns bring a declarative edge to building .NET UI. Modern .NET is powerful, flexible and welcoming to all. And .NET developer productivity is easily boosted with contextual AI. This is a great time to be in .NET – let's see why. Speakers: Sam Basu, Lead Developer Advocate, Uno Platform Website: https://samidipbasu.com/ LinkedIn: https://www.linkedin.com/in/sam-basu-332247394/ X: https://twitter.com/samidip Andres Pineda, Senior Developer, Uno Platform Website: https://ajpinedam.dev/ LinkedIn: https://www.linkedin.com/in/pinedax/ X: https://twitter.com/ajpinedam Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • Introducing the SQL MCP Server | Jerry Nixon | .NET Day 2026

    · 37 min

    Modern apps use language models, but how do those models safely interoperate with your company's backend data without putting the business at risk? SQL MCP Server answers that question. It is Microsoft's open source MCP server for secure access to SQL Server, Azure SQL, PostgreSQL, Cosmos DB, and MySQL, running in the cloud or on premises at enterprise scale. It provides a feature-rich database API designed to help models understand and work with your data while enforcing permissions, policies, and operational boundaries. Built on the same high-scale engine that powers Microsoft Fabric's own GraphQL API, SQL MCP Server is designed for both scale and developer productivity. With a rich inner loop and a cross-platform command line, it works just as well for enterprise workloads as it does for engineers innovating on the ground. Speaker: Jerry Nixon, SQL Server, Microsoft Website: http://jerrynixon.com/ LinkedIn: https://www.linkedin.com/in/jerrynixon X: http://twitter.com/jerrynixon Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • C# Interceptors: Native AOT & Performance for Free | Stefan Pölz | .NET Day 2026

    · 40 min

    Would you like to know how incremental source generation and source-level interception grant you Native AOT & performance "for free"? The just-in-time compiler (JIT) is a mighty beast of the .NET runtime. And it becomes more powerful with every consecutive release of .NET. But it comes along with a cost during run-time, when compiling the assemblies containing intermediate language code into machine code. A price we may not pay gladly for highly scalable cloud services. Native AOT, compiling deployments ahead-of-time into executable code, moves this complexity to compile-time. But features that utilize dynamic code emission may stop working. As a solution serve Interceptors which were shipped as experimental C#-only feature in .NET 8 and became GA in .NET 9. An interceptor is basically the inverse of a goto statement that enables the Roslyn compiler to replace reflection-based call sites with specialized implementations. Emitted from (incremental) source generators, codebases become more trimmable, more Native AOT-friendly and can unlock better performance. May Roslyn be with you! Speaker: Stefan Pölz, FlashOWare GitHub: https://github.com/Flash0ver YouTube: https://www.youtube.com/@FlashOWare/ Mastodon: https://dotnet.social/@0x_F0 Bluesky: https://bsky.app/profile/flash0ver.bsky.social X: https://twitter.com/0x_F0 Recorded at JetBrains .NET Day Online 2026, a free online event for the .NET community. Watch all .NET Day 2026 talks: https://www.youtube.com/playlist?list=PLDygEnTxhRkc Explore JetBrains tools for .NET: https://www.jetbrains.com/dotnet/ #JBDotNetDay #dotnet #csharp

    Not rated yet
  • DataGrip Overview, Part 4: Running Queries

    · 3 min

    Download DataGrip: https://jb.gg/t360qo Book a DataGrip demo: https://calendly.com/sobolevskiy In the fourth part of our DataGrip overview, we run SQL queries, view their results, inspect execution plans, and display outputs alongside the SQL code. 00:00:00 Chooser 00:01:00 Services tool window 00:02:00 Explain plan 00:02:14 Name the result tabs 00:02:38 Time of the query 00:02:56 In-Editor Results mode

    Not rated yet

More in Education

See all Education shows