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.
151216 stories
·
33 followers

Celebrating a Remarkable 2025: A Year of Innovation and Growth by Bjoern Meyer
Wednesday December 17th, 2025 at 5:56 AM

Text Control Blog Feed
1 Share
2025 is coming to an end. Now is a great time to pause and reflect. What a year it has been for us! We are reflecting on the milestones and achievements of 2025 and highlighting the innovation and growth that occurred across various sectors.

Read the whole story
alvinashcraft
3 hours ago
reply
Pennsylvania, USA
Share this story
Delete

GCast 206: Mastering GitHub Copilot course, Using GitHub Copilot with Python, Part 1 by David Giard
Wednesday December 17th, 2025 at 5:55 AM

David Giard
1 Share

GCast 206:

Mastering GitHub Copilot course, Using GitHub Copilot with Python, Part 1

Learn how to use GitHub Copilot with a Python application. This video covers sections 1 and 2 of the "Using GitHub Copilot with Python" lesson. It shows how to use GitHub Copilot Chat in Ask mode and how to use inline chat.

Links:
https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming/
https://github.com/microsoft/Mastering-GitHub-Copilot-for-Paired-Programming/tree/main/Using-GitHub-Copilot-with-Python

Read the whole story
alvinashcraft
3 hours ago
reply
Pennsylvania, USA
Share this story
Delete

Interesting links - December 2025
Wednesday December 17th, 2025 at 5:55 AM

rmoff's random ramblings
1 Share

Well it’s that time of year already! Whilst munching on a mince pie, enjoy the final Interesting Links for 2025.

It’s been a busy twelve months for me; this time last year I was signing off from my last company, which went on to be acquired—and last week I found out that my current company (Confluent) is to be acquired by IBM. Despite my reaction against any kind of cheese moving, I figure this is going to be an interesting development and a whole new experience for me :)

Just one blog post of my own to share from this month—a write-up of some investigation that I did using Neo4j and graph analysis to identify astroturfing on Reddit. It turns out that there are marketing agencies out there who think it’s a good idea to spoil things for everyone else by offering astroturfing-as-a-service to at least two vendors in this space who paid them for it 🙄.

My previous employer has kindly allowed me to host my previous blog posts here on rmoff.net, which I’m delighted about. If you’ve not seen them already, here are some of the highlights:

And so…on with the interesting links!

Not got time for all this? I’ve marked 🔥 for my top reads of the month :)

Tip
 Medium posts often skulk behind a gate, so I’ve hyperlinked to the Freedium version and included a link to the original using a ⓜ️ icon should you prefer to visit that (or if freedium goes offline).

Kafka and Event Streaming

  • Aviv Dozorets published a new tool, klag, billed as a replacement for the deprecated Kafka Lag Exporter.

  • 🔥 Sandon Jacobs has an excellent lightboard explainer of the new Queues for Kafka introduced with KIP-932.

  • Jepsen’s test reports are always interesting to read, including this recent one in which he uncovers issues in NATS JetStream.

  • I mean, if a Kafka alternative isn’t written in Rust these days, is it even worth writing? Snark aside, walrus claims higher performance than Kafka, although it isn’t API compatible.

  • WarpStream have always published good blog posts, and this one from Maud Gautier continues the trend, with technical details of how they added support for Protobuf with Schema Registry.

  • This post from Yifeng Liu gives some practical advice on how to architect Kafka topics, specifically with regards to duplication (which is sometimes totally OK, the author argues).

  • Platformatic’s Node.js client has had a 223% speed boost—Paolo Insogna describes how.

Stream Processing

Analytics

Data Platforms, Architectures, and Modelling

Data Engineering, Pipelines, and CDC

Open Table Formats (OTF), Catalogs, Lakehouses etc.

RDBMS

General Data Stuff

AI

I warned you previously…this AI stuff is here to stay, and it’d be short-sighted to think otherwise. As I read and learn more about it, I’m going to share interesting links (the clue is in the blog post title) that I find—whilst trying to avoid the breathless hype and slop.

Note

A request to you: Are there any good blog posts out there documenting how companies are actually implementing their user-facing AI features?

For example, Strava has the awfully-named "Athlete Intelligence" (AI - geddit?!) - but I would love to see how it’s built.

It feels like there’s a chasm between "ooooh you can build this" from the vendors (hi!) and the reality of actually building with it. Perhaps that’s always the case, but for hype stuff it’s even more valuable to hear [unfiltered] stories of how people really build with it.

And finally…

Nothing to do with data, but stuff that I’ve found interesting or has made me smile.

Work

Fun

Write

Listen

Note


Read the whole story
alvinashcraft
3 hours ago
reply
Pennsylvania, USA
Share this story
Delete

The Open Web at a Crossroads: A Conversation with Vint Cerf, Brewster Kahle, Cindy Cohn & Jon Stokes by Internet Archive & Authors Alliance
Wednesday December 17th, 2025 at 4:55 AM

Future Knowledge
1 Share

What made the early web so thrilling, and how do we reclaim that spirit today? In this special episode, recorded at Georgetown University’s historic Riggs Library, leaders who helped build the internet and those fighting for its future come together to chart a path forward.

Featuring Brewster Kahle (Internet Archive), Vint Cerf (Google), Cindy Cohn (EFF), and Jon Stokes (Ars Technica), and moderated by Luke Hogg of the Foundation for American Innovation, this conversation looks back at the web’s origins to imagine what a truly open, innovative, and empowering internet could still become.

This conversation was recorded on 10/27/2025. Watch the full video recording at: https://archive.org/details/wayback-to-the-future-celebrating-the-open-web

Check out all of the Future Knowledge episodes at https://archive.org/details/future-knowledge 





Download audio: https://media.transistor.fm/aaef27b5/15ab6d6f.mp3
Read the whole story
alvinashcraft
4 hours ago
reply
Pennsylvania, USA
Share this story
Delete

Teaching AI Modern Go: Solving the "Stuck-in-the-Past" Problem with Antigravity by Roman Budnikov
Wednesday December 17th, 2025 at 4:55 AM

DEV Community
1 Share

Last month, I changed my workflow. I switched from vim as my primary code editor to Google's new Antigravity AI IDE. It's an agentic platform that has significantly boosted my performance in writing, testing, and modifying code.

Go is evolving fast. Recent versions introduced helpful features like integer ranges (Go 1.22 for i := range 10) and standard library improvements (Go 1.24 testing.B.Loop). Unfortunately, most LLMs suffer from a "stuck-in-the-past" problem. Because they are trained on older code, they often suggest outdated code that works, but are no longer "idiomatic" or preferred in modern Go.

Here is how I use .agent/rules to teach the LLM new tricks and enforce modern best practices.

The Problem: Outdated Defaults

For example lets take LeetCode problem: 1. Two Sum. Here is an example solution in Go:

func TwoSum(nums []int, target int) []int {
    seen := make(map[int]int)
    for i, num := range nums {
        comp := target - num

        if idx, ok := seen[comp]; ok {
            return []int{idx, i}
        }

        seen[num] = i
    }

    return nil
}

If you simply prompt the Agent with: write benchmark for TwoSum function, it will likely generate a benchmark that looks like this:

func BenchmarkTwoSum(b *testing.B) {
    // Create a larger input for benchmarking
    nums := make([]int, 1000)
    for i := 0; i < 1000; i++ { // Old style loop
        nums[i] = i
    }
    target := 1997 

    b.ResetTimer()
    for i := 0; i < b.N; i++ { // Old style benchmark loop
        TwoSum(nums, target)
    }
}

The issues:

  • It uses for i := 0; i < 1000; i++ instead of the modern Go 1.22 for i := range 1000.
  • It uses b.N manually instead of the modern Go 1.24 b.Loop method.

The Solution: Agent Rules

To handle this, we can use Rules. In Antigravity, a Rule is simply a Markdown file where you define constraints, stack preferences, and style guides. (See the documentation for setup details).

We can create specific rule files to "patch" the LLMs knowledge base.

1. Modernizing Benchmarks (benchmark.md)

Create a file named benchmark.md to instruct the agent on the new testing API:

The `b.Loop` method is now the preferred way to write benchmarks in Go 1.24+.


func BenchmarkExample(b *testing.B) {
    // ... setup ...
    for b.Loop() {
        // optional timer control for in-loop setup/cleanup is handled automatically
        // ... code to measure ...
    }
    // ... cleanup ...
}

Always use b.Loop() instead of b.N in benchmarks.

2. Modernizing Loops (loops.md)

Create a file named loops.md to enforce modern iteration syntax:

Each iteration creates a new instance of the variable. There is no need to declare `v := v` inside the loop for closure safety.

for _, v := range data {
    go func() {
        // safe to use v here directly
    }()
}

`For` loops may now range over integers. We should use `for i := range 10` now.

for i := range 10 {
    fmt.Println(10 - i)
}

The Result

After creating these files, click the Reload Rules button in the editor. Now, retry the prompt: write benchmark for TwoSum function or be specific: apply benchmark and loops rules to generate a benchmark.

You will see the Agent's implementation plan acknowledge the new context:

[NEW] search_test.go
* Create `search_test.go`.
* Implement `BenchmarkTwoSum`.
* Use `b.Loop()` structure.
* Construct a large slice of integers and a target that is found near the end or not found to test worst/average cases.

The resulting code is cleaner, modern, and follows the latest Go specs:

func BenchmarkTwoSum(b *testing.B) {
    nums := make([]int, 1000)
    for i := range 1000 {
        nums[i] = i
    }
    target := 1997 

    for b.Loop() {
        TwoSum(nums, target)
    }
}

Going Further: Enforcing Style Guides

This feature is powerful because it keeps your code consistent. It forces the LLM to follow your team's rules instead of guessing or using random styles.

For example, you can feed the LLM the entire Uber Go Style Guide. Or use specific libraries.

Example: Enforcing Error Wrapping errors.md

If you want to ensure all errors are wrapped using cockroachdb/errors instead of standard returns or fmt.Errorf:

Do not simply `return err`. Always wrap errors using `github.com/cockroachdb/errors` to provide stack traces and context. Use `Wrap(error, string)` or `Wrapf(error, string, ...interface{})`.

func getUser(id int) error {
    if err := someDatabaseCall(id); err != nil {
        // Wrap the original error with added context
        return errors.Wrapf(err, "some database call id %d", id)
    }

    return nil
}

It is annoying when LLMs provide code that is stuck-in-the-past By using .agent/rules in Antigravity, you can stop fighting the LLMs old habits. Instead, you can collaborate with an Agent that understands your specific tools and style. Rules bridge the gap between what the LLM knows and the code you actually want.

Read the whole story
alvinashcraft
4 hours ago
reply
Pennsylvania, USA
Share this story
Delete

Getting Started with MCP on Windows by Nick Randolph
Wednesday December 17th, 2025 at 2:38 AM

WeAreDotnet - Recently posted
1 Share


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