Why I Trade the Terminal for a GUI: A Dev’s Take on GitKraken

Von Cunningham — Wed, 31 Dec 2025 19:40:57 +0000

In the world of software engineering, there’s a long-standing "tough guy" trope: real developers only use the command line (CLI) for Git.

For years, I followed that rule. But as I moved into more complex enterprise .NET and Azure environments, I realized something. My job isn't to memorize CLI flags—it’s to solve puzzles and ship reliable code. That’s why I switched to GitKraken.

1. Visualizing the "LEGO Set"

I’ve always been a fan of LEGO Technic. When you're building a complex gearbox, you need to see how the gears mesh.

Branching in a high-velocity team is the same. When you have multiple developers merging into a main branch while maintaining feature branches, the CLI can feel like building a LEGO set in the dark. GitKraken’s visual commit graph gives me a 30,000-foot view of the project's history, making it nearly impossible to lose a commit.

2. The Power of the "Undo" Button

We've all been there: a git reset --hard that went slightly wrong. In the CLI, that's a heart-attack moment. In GitKraken, there is a literal "Undo" button for almost every local action.

This doesn't make a developer "lazy"; it makes them safe. It allows me to experiment with complex rebases or cherry-picks with the confidence that I can revert a mistake in one click.

3. Focus on the Code, Not the Syntax

I spend my day solving complex LINQ queries and architecting Azure integrations. I want my "brain cycles" to go toward business logic, not remembering the specific syntax for a complex stash-pop or a multi-branch merge.

Final Thoughts

The CLI is a powerful tool, and every dev should know the basics. But for daily enterprise work, I choose the tool that reduces cognitive load. GitKraken isn't a crutch; it's a high-definition lens for my version control.

What about you? Are you a CLI purist, or have you embraced the GUI?

Clean Up Your C# Loops: Flattening Nested Collections with LINQ SelectMany

Von Cunningham — Wed, 31 Dec 2025 18:42:57 +0000

Have you ever dealt with a "List within a List" and found yourself writing messy nested foreach loops just to get to the data?

As a developer who loves puzzles (and LEGO Technic!), I’m always looking for ways to simplify complex structures. In C#, the .SelectMany operator is one of the most elegant ways to "flatten" these nested collections into a single, usable stream.

The Problem

Imagine you have a list of Orders, and each order contains a list of LineItems. If you want a single list of every item sold across all orders, the traditional way looks like this:

var allItems = new List<LineItem>();
foreach (var order in orders)
{
    foreach (var item in order.LineItems)
    {
        allItems.Add(item);
    }
}

This works, but it's "noisy." It’s hard to read at a glance.

The Solution: SelectMany

With LINQ, we can achieve the same result in a single line of code. Think of SelectMany as a way to reach into each parent object, grab the child collection, and spread it out on the table.

var allItems = orders.SelectMany(o => o.LineItems).ToList();

Why this is better

Readability: You state what you want to do, not how to loop through it.
Chainability: You can immediately add a .Where() or .OrderBy()after the .SelectMany to further refine your data without adding more loops.

If you’re moving from a "loop-heavy" style to a more functional approach in .NET, SelectMany is a tool you'll reach for constantly!

DEV Community: Von Cunningham