Implementing Datadog in iOS: A SwiftUI vs UIKit Perspective

I’ve been diving deep into implementing Datadog in iOS applications and wanted to share my experience with both SwiftUI and UIKit approaches and the related elements of the work. Let’s break this down into what works, what doesn’t, and why you might choose various options when using Datadog (or deciding not to use Datadog).

The Setup

First things first, you’ll need these Datadog SDK packages:

dependencies: [
    .package(url: "https://github.com/DataDog/dd-sdk-ios", from: "2.27.0")
]
Continue reading “Implementing Datadog in iOS: A SwiftUI vs UIKit Perspective” →

Stop Wasting Time on Teams: 3 Additional Hacks for Fixes You Need

Here’s an unvarnished truth: if you’re still clicking around Teams like it’s 2010, you’re wasting time. Stop complaining and learn these three hacks your future self will thank you.

NOTE: No, I’m not becoming a Microsoft Teams blogger, it’s just these along with a few other prospective features can help when stuck dealing with Microsoft Teams. Since I have to be tortured with such an app, I’m just offering this meager help via blog entries. Otherwise, you can rest assured I’ll be back to regularly scheduled software development and related technical topics very soon!

1 >> Stop Clicking >> Use Slash Commands & Keyboard Shortcuts

  • What to do: Hit Ctrl + E (Win) or ⌘ + E (Mac) to jump to the command bar (yeah, there’s a command line, also see docs), then type / and a command:
    • /dnd to set Do Not Disturb
    • /call [name] to ring someone immediately
    • /files to see your recent docs
  • Plus: Memorize the basics:
    • Ctrl + Shift + M to mute/unmute
    • Ctrl + Shift + O to toggle your camera
    • Ctrl + N to start a new chat
  • Why it matters: Teams is famously sluggish, stop letting the UI slow you down. If you can’t spare ten minutes to learn these, fine then keep clicking.
Continue reading “Stop Wasting Time on Teams: 3 Additional Hacks for Fixes You Need” →

When the AI Ghost Vanishes

You’re cruising along, vibe-coding your way through a new feature, and—poof—the AI assistant goes dark. Maybe it hallucinated a library that doesn’t exist. Maybe it repeated the same wrong snippet ad nauseam. Welcome to the moment of reckoning: your blind faith in “make me the code” meets cold, hard compiler errors.

Spinning the wheel of madness: You tweak a comment here. You change “public” to “private” there. You pray to the Codegen Deity. You hope it understands your increasingly desperate prompts.

Lose an hour or a day: You still haven’t fixed the NullReferenceException, and your caffeine cold-brew is now room temperature.

Blame the tool that’ll fix it!: It’s obviously a bug in the AI, right? Right? RIGHT? Your sanity is going to ebb, beware the blaming of tools!

This cycle feels familiar because it is, the tooling is great at scaffolding code, less so at understanding your context. When it bails on you, you’ll need a plan B.

Continue reading “When the AI Ghost Vanishes” →

The Terror of Microsoft Teams & Workarounds

If you’ve used Microsoft Teams, you’ve had issues and likely have spent hours working through things that you shouldn’t have had to deal with. I have endeavored to help others work their way through mitigating Teams calamities. I’ve put together this short list of my own workarounds.

Here are three things Teams consistently screws up—and what you can do if you don’t want to keep banging your head against the wall:

1) Messages Lag & Drop in the Web App

What’s happening: The browser version of Teams is a resource-heavy single-page app. All that JavaScript, caching and real-time syncing means your chat can stall, duplicate, or even fail to show new messages for minutes.

Continue reading “The Terror of Microsoft Teams & Workarounds” →

A Simple Git Branching Strategy for a Small Team (Because We All Know Git Is Fun!)

Git. It’s the tool that makes some of us developers wonder why they didn’t become a carpenter. But let’s face it: Git is here to stay. And for a small team—like, say, 3-4 developers working on the same codebase—getting your branching strategy right can be the difference between smooth sailing and a storm of merge conflicts that will make you question every decision you’ve ever made in life.

So let’s dive into a “simple” strategy for keeping Git under control. No complex workflows, no corporate jargon—just a few solid, time-tested practices to keep you from drowning in source control hell. Because seriously, git is actually super easy and a thousand times better than all the garbage attempts at source control that came before.

The Core Branches (Yes, There Are Only Two You Really Need)

If you’re working on a small team, you don’t need to be fancy. Forget about multiple branches for every single thing under the sun—just stick with main and feature branches. That’s it. Keep it simple. We don’t need a thousand different integration branches or some mythical release branch. Keep it neat.

  • main: This is your production-ready code. The one branch that should always work, always deployable, and always sacred. No exceptions.
  • Feature branches: These are where the magic happens. New features, bug fixes, the stuff that makes your app worth using. Each feature gets its own branch. Think of it like a sandbox—do whatever you want there, but don’t drag your mess into main.

Example 1: The Plain Old Feature Branch (The Easy Way)

Continue reading “A Simple Git Branching Strategy for a Small Team (Because We All Know Git Is Fun!)” →