Blurblogs
Global
Popular
Log in
alvinashcraft's blurblog
Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
164949 stories
·
33 followers

Agentic search doesn't find pages, it assembles answers by Phoebe Sajor
Friday November 13th, 2026 at 5:55 AM

Stack Overflow Blog
1 Share
Ryan sits down with Jeff Wang, co-founder at EXA, to talk about the huge scale required to support trillions of agentic searches, the technical complexities of building custom embeddings and performant vector databases from scratch, and the need to dedupe the massive amounts of redundant content on the web to deliver high-trust answers.
Read the whole story
alvinashcraft
22 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Episode 539 - How to Survive the Job Search Rollercoaster w/ Lindsey Dortch
Friday November 13th, 2026 at 5:55 AM

Guidance Counselor 2.0
1 Share

if you want to check out all the things ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠torc.dev⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠ has going on head to ⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠linktr.ee/taylordesseyn⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠⁠ for more information on how to get plugged in!





Download audio: https://episodes.captivate.fm/episode/481a7f42-c2c1-492e-bf81-7cae2b62cd66.mp3
Read the whole story
alvinashcraft
22 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

AGL 495: Barry Moline
Friday November 13th, 2026 at 5:55 AM

A Geek Leader Podcast - inspiring technical and creative leaders around the world
1 Share

About Barry

Connect
Connect

Barry Moline is a longtime CEO with nearly three decades of experience leading teams and shaping organizational culture across business, government, and trade associations. A Cialdini Institute Certified Trainer, he teaches ethical influence and effective leadership. Barry is the award-winning author of Connect!, a book that reveals how to build great culture and highly collaborative teams. Barry speaks and consults internationally, helping leaders bring people together to achieve extraordinary results. He focuses on enhancing leadership, turning conflict into teamwork, ethical influence and persuasion, and AI leadership strategy.

Today We Talk About

  • Background
  • Leadership
  • Hockey youth to CEO
    • Hockey Referee
    • Taking Charge in big games
    • Fitting in and Being a good teammate
  • Take respobsibility
  • Step forward when things need to get done
  • Volunteer until you make it
  • Teambuilding
  • Ice breakers
  • Serve together
  • Share knowledge
  • Leading through AI change

Connect with Barry

Leave me a tip $
Click here to Donate to the show

I hope you enjoyed this show, please head over to Apple Podcasts and subscribe and leave me a rating and review, even one sentence will help spread the word.  Thanks again!





Download audio: https://media.blubrry.com/a_geek_leader_podcast__/mc.blubrry.com/a_geek_leader_podcast__/AGL_495_Barry_Moline.mp3?awCollectionId=300549&awEpisodeId=12291644&aw_0_azn.pgenre=Business&aw_0_1st.ri=blubrry&aw_0_azn.pcountry=US&aw_0_azn.planguage=en&cat_exclude=IAB1-8%2CIAB1-9%2CIAB7-41%2CIAB8-5%2CIAB8-18%2CIAB11-4%2CIAB25%2CIAB26&aw_0_cnt.rss=https%3A%2F%2Fwww.ageekleader.com%2Ffeed%2Fpodcast
Read the whole story
alvinashcraft
23 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Episode 598: Protect the Tortillas at All Costs by Software Defined Talk LLC
Friday November 13th, 2026 at 5:55 AM

Software Defined Talk
1 Share

This week, we discuss AI agents as pets, the HEB test for Jensen, and Anthropic's S-1. Plus, a tactical pencil for taking notes and defending yourself.

Watch the YouTube Live Recording of Episode 598

Runner-up Titles

  • I'm always recording.
  • Ralph the Security Guy.
  • We're building the machine to build the machine that builds the software.
  • This pencil is completely unnecessary.
  • I knew it was some Randy.
  • If it's good, I gotta get off this ranch and start getting some pets.
  • I'm creating the machine to create the machine to create the software.
  • If you become super successful and massively rich, it just breaks you.
  • Even if you think you're not going crazy, you're going crazy.
  • Where do you think that shit runs?
  • Welcome back to civilization.
  • Imagine they're the manager of an HEB and ask, would this work?
  • We've got to protect the tortillas at all costs.
  • You should have to file your own expenses and book your own travel.
  • If your company has an executive onboarding process, you're on the path to bad.
  • As long as the revenue comes in, none of this matters.
  • Everyone's talking about it, therefore it can't exist.
  • We want more tokens. We want cheaper tokens.
  • Here's a secret about the ROI of enterprise software: no one knows.
  • Unlimited needs an asterisk.
  • One of the core functions of bureaucracy is to de-weirdo your organization.
  • We haven't mentioned Kubernetes this whole time. It's now boring. Victory.
  • No one would ever ask for this, but everyone needs one.
  • I'm prepared to take notes and defend myself.

Rundown

Relevant to your Interests

Nonsense

Listener Feedback

Conferences

SDT News & Community

Recommendations

Edited and produced with PodEditor, the native Mac podcast editor.





Download audio: https://aphid.fireside.fm/d/1437767933/9b74150b-3553-49dc-8332-f89bbbba9f92/3cd4583e-0689-4571-a8ff-1f6dd453224d.mp3
Read the whole story
alvinashcraft
23 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

All your packages are belong to us (Interview)
Friday November 13th, 2026 at 5:55 AM

The Changelog: Software Development, Open Source
1 Share

AI agents can write the code, choose the packages, and run the install. Who’s checking what they just invited onto your machine? This week I’m joined by Ahmad Nassri, CTO of Socket and former CTO of npm. We get into the trust built into a package install, the new ways attackers are using agents, and what it takes to keep building without handing over the keys or your wallet.

Join the discussion

Changelog++ members get a bonus 6 minutes at the end of this episode and zero ads. Join today!

Sponsors:

  • WorkOS – WorkOS is building the infrastructure for the AI era. Explore three new product previews: Airlock for secure AI agent permissions, Atlas for deploying AI-built internal apps, and Passport for seamless, passwordless access to work apps. See the announcements, demos, and highlights in the WorkOS init() 2026 recap.
  • Parallel – Web infrastructure for AI to search, extract, monitor, and reason over the world’s information.
  • Deepgram – Speech-to-text, text-to-speech, and voice agent APIs for developers building voice AI applications.
  • Fly.io – The home of Changelog.com — Computers for agents, from sandboxes to production. Give your agent its own hardware-isolated Linux computer. Deploy what it builds without changing platforms.

Featuring:

Show Notes:

Something missing or broken? PRs welcome!





Download audio: https://op3.dev/e/https://pscrb.fm/rss/p/https://cdn.changelog.com/uploads/podcast/690/the-changelog-690.mp3
Read the whole story
alvinashcraft
23 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

C# 15 Labeled Break Continue by NDepend
Friday November 13th, 2026 at 5:55 AM

NDepend Blog
1 Share
November 13, 2026 9 minutes read

C# 15 labeled break and continue: two Boolean flags in C# 14 vs continue orderLoop and break orderLoop in C# 15

With C# 15, a break or continue statement can name the loop it targets. Put a label on a loop, such as outer:, and then write break outer; or continue outer; from any nested loop. Microsoft calls this feature labeled break and continue.

C# 15 and .NET 11 shipped in November 2026, so you can use labeled jumps today. This short post covers the syntax, the rules and the compiler errors. It also looks at the IL and at the new IDE0410 code fix. Finally, we ask why such a basic feature took 15 versions to land.

C# 15 Labeled Break and Continue at a Glance

  • Labeled jumps ship with C# 15 / .NET 11. C# 15 is the default language version for projects that target net11.0, so there is nothing to opt into.
  • You can label any loop (for, foreach, while, do, await foreach) and any switch statement.
  • break label; exits the labeled loop or switch. On the other hand, continue label; starts the next iteration of the labeled loop.
  • Plain blocks, if, try and lock can’t be targets, unlike in Java.
  • A wrong target produces error CS9393 or CS9394.
  • Under the hood, the compiler emits the same IL as a goto.
  • Also, the new style rule IDE0410 spots the old flag and goto patterns and rewrites them.

To use labeled jumps, simply target .NET 11 or later in your csproj:

<TargetFramework>net11.0</TargetFramework>

The Problem: Escaping Nested Loops Before C# 15

Here is a common scenario. A shipping job walks through orders, and each order has several lines. An invalid line must skip the whole order, while a recalled product must stop the job at once. Before C# 15, break only exits the innermost loop, so you needed Boolean flags:

static void Process(Order[] orders) {
   bool stopShipping = false;
   foreach (Order order in orders) {
      bool skipOrder = false;
      foreach (OrderLine line in order.Lines) {
         if (line.Quantity <= 0) {
            skipOrder = true;     // skip this order
            break;
         }
         if (line.IsRecalled) {
            stopShipping = true;  // stop everything
            break;
         }
      }
      if (stopShipping) break;
      if (skipOrder) continue;
      Ship(order);
   }
}

public record class OrderLine(string Product, int Quantity, bool IsRecalled = false);
public record class Order(int Id, OrderLine[] Lines);

Two flags and four extra statements serve only to carry a decision from the inner loop to the outer one. Moreover, the order of the checks matters. Declare a flag in the wrong scope, and the next order inherits a stale value.

The Usual Workarounds

C# developers have relied on three workarounds for decades:

  • Flags, as shown above. They work, yet they spread a single decision over several lines.
  • goto. In fact, the C# specification itself said: “To transfer control across multiple nesting levels, a goto statement shall be used.” However, many teams ban goto.
  • Extracting a method and calling return. This is often clean, but it moves the logic away and forces you to pass local state around.

C# 15 Labeled Break and Continue Syntax

With C# 15, you label the outer loop and name it in the jump statement. As a result, the same method shrinks to this:

static void Process(Order[] orders) {
   orderLoop: foreach (Order order in orders) {
      foreach (OrderLine line in order.Lines) {
         if (line.Quantity <= 0) continue orderLoop;  // skip this order
         if (line.IsRecalled) break orderLoop;        // stop everything
      }
      Ship(order);
   }
}

Here are some remarks:

  • The label goes right in front of the loop, followed by a colon, just like a goto label.
  • continue orderLoop; jumps to the next order, while break orderLoop; leaves the outer loop.
  • Without a label, break and continue keep their usual meaning and target the innermost loop.
  • Name the label after the role of the loop. Microsoft’s samples use outer, but orderLoop tells the reader what you exit.

Here are both versions side by side in Visual Studio. Notice the dotted underline under the second break on the left: that is the IDE0410 hint, covered below.

Visual Studio: ProcessCSharp14 with the stopShipping and skipOrder flags vs ProcessCSharp15 with a labeled foreach

Breaking Out of a Loop From a switch

This one has annoyed C# developers forever. Inside a switch section, break exits the switch, not the enclosing loop. Now a labeled break solves it:

lineLoop: while (reader.ReadLine() is string line) {
   switch (line) {
      case "":
         continue;           // already targets the loop
      case "END":
         break lineLoop;     // before C# 15, break only left the switch
      default:
         Console.WriteLine(line);
         break;
   }
}

Note that a plain continue already worked here, since a switch is never a continue target. Conversely, you can also label a switch and leave it with break from a loop nested in one of its sections.

The Rules of Labeled Jumps

The feature comes with a short list of rules. Each error code below comes straight from the C# 15 compiler:

  • break label; accepts an enclosing loop or switch statement. Any other target produces error CS9393: No enclosing loop or switch statement with the label ‘label’ out of which to break.
  • continue label; accepts loops only. For instance, a labeled switch leads to error CS9394: No enclosing loop with the label ‘label’ out of which to continue.
  • The target must enclose the jump. Thus a label on a sibling loop triggers CS9393 too.
  • Plain blocks, if, try, using and lock can’t be targets. Java lets you break out of a labeled block, but C# 15 does not.
  • A jump can’t cross a lambda boundary (CS1632) or a local function boundary (CS9394).
  • A jump can’t leave a finally block (CS0157). On the other hand, when a jump leaves a try block, the finally blocks it exits run first.
  • In a: b: while (...), only b labels the loop, so continue a; fails.
  • Finally, with LangVersion 14 or lower, you get CS9327: Feature ‘labeled break and continue’ is not available in C# 14.0.

Beware of Duplicate Label Names

One trap deserves its own section. A label’s scope is the whole block that declares it, nested blocks included. Therefore two sibling loops in the same block can’t both use outer:

outer: for (int i = 0; i < 3; i++) { /* ... break outer; ... */ }
outer: for (int j = 0; j < 3; j++) { /* ... break outer; ... */ }
// error CS0140: The label 'outer' is a duplicate

Reusing the name on a nested loop fails as well, with error CS0158: the label shadows another label by the same name. So meaningful names such as orderLoop also avoid these collisions. By contrast, a label may share its name with a local variable, because labels live in their own declaration space.

How Labeled Break Works Behind the Scenes

The .NET runtime knows nothing about labeled jumps. Instead, the compiler lowers a labeled break to a plain branch instruction, exactly like a goto. To check this, we compiled these two methods in Release mode:

static int SumWithGoto(int[][] grid) {
   int sum = 0;
   foreach (int[] row in grid) {
      foreach (int cell in row) {
         if (cell < 0) goto done;
         sum += cell;
      }
   }
   done:
   return sum;
}

static int SumWithLabeledBreak(int[][] grid) {
   int sum = 0;
   outer: foreach (int[] row in grid) {
      foreach (int cell in row) {
         if (cell < 0) break outer;
         sum += cell;
      }
   }
   return sum;
}

Both methods compile to the same IL, byte for byte. In other words, a labeled break is a structured goto. It costs nothing at runtime, but the compiler restricts where it can jump. In contrast, the flag version needs an extra local and an extra test on each outer iteration.

IDE0410 Rewrites the Old Patterns for You

.NET 11 also ships the style rule IDE0410: Use labeled jump statement. It detects flag and goto patterns that a labeled jump can replace. To see it at build time, raise its severity in .editorconfig and set EnforceCodeStyleInBuild to true in your csproj:

[*.cs]
dotnet_diagnostic.IDE0410.severity = warning

Then dotnet format style --diagnostics IDE0410 --severity info applies the fix to a whole solution. We ran it on the flag version of Process(), and it produced the labeled version, braces aside. Three details stood out:

  • The fixer names the label after the loop variable, here loop_order. You may want to rename it.
  • It removes one flag per pass. Our method has two intertwined flags, so the second one only went away on a second run.
  • For a goto, it moves the existing label onto the loop and turns goto done; into break done;.

C# Labeled Break and Continue FAQ

What are labeled break and continue in C#?

They are break and continue statements followed by a label, such as break outer;. The label names an enclosing loop or switch statement. Thus you can exit or continue an outer loop directly from a nested one.

Which C# version supports labeled break and continue?

C# 15, which shipped with .NET 11 in November 2026. C# 15 is the default language version for projects that target net11.0.

Can a labeled continue target a switch statement?

No. A labeled continue only targets loops, and the compiler reports error CS9394 otherwise. A labeled break, however, accepts both loops and switch statements.

Can I break out of a labeled block or if statement in C#?

No. Unlike Java, C# 15 only accepts loops and switch statements as targets. A label on a block, an if or a try leads to error CS9393.

Is a labeled break just a goto?

At the IL level, yes: both compile to the same branch instruction. However, a labeled break can only exit an enclosing loop or switch. Unlike goto, it can’t jump backward or into another block.

How do I convert existing flag-based loops?

Enable the style rule IDE0410 and run dotnet format style --diagnostics IDE0410. The fixer replaces flag and goto patterns with labeled jumps, one flag per pass.

Conclusion: Better Late Than Never

In his video on this feature, Nick Chapsas welcomes the quality-of-life gain, yet he finds it goofy. Such a basic feature should have been there from day one, and he wonders why it took until version 15. We share that feeling.

Java has had labeled break and continue since its 1.0 release in 1996. JavaScript, Kotlin, Swift, Rust and Go support them too. Meanwhile, the C# specification answered the nested-loop question with goto for nearly 25 years. Yet the champion issue only opened in December 2025, even though its specification admits that requests date back decades.

Nick makes another point worth repeating. Humans may hesitate to adopt the new syntax, but AI coding agents will use it to produce simpler code. We agree, and IDE0410 pushes in the same direction. A fixer that runs in CI removes flags mechanically. Fewer flags also mean less state to track, for a human reviewer as much as for a model.

Still, don’t let labeled jumps hide a design problem. Three nested loops in one method usually call for a refactoring, and an extracted method with an early return often remains the best answer. Labeled jumps shine in the remaining cases: a short nested scan, or a parser loop around a switch.

So yes, it feels odd to celebrate in 2026 a feature that Java shipped in 1996. But better late than never. C# 15 finally lets you say which loop you mean, and the compiler takes care of the rest. To go further, read the Microsoft reference on jump statements and our posts on the other C# 15 features: closed hierarchies and unions.

The post C# 15 Labeled Break Continue appeared first on NDepend Blog.

Read the whole story
alvinashcraft
23 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories