Marcin Bunsch

With the endlessly accelerating growth of AI tools comes a problem of using AI without understanding the problem. I recently read this article by Namanyay in which he does a good job conveying the problem of newer developers jumping over learning opportunities to get to the solution.

It’s a huge temptation to move fast and get to the answer, and we all do this from time to time, but it’s specifically bad when you should be grinding on the fundamentals to build the foundation of your understanding. I think that Namanyay points it out well in his blog post.

There is another layer to it though, one that I like to refer as the Kobayashi Maru Moment. I believe each person should experience it in their professional career to get better. It’s where you fail so hard, your ego gets pummeled into the ground. You get into a no-win situation, you have to concede defeat and deal with the consequences.

Continue reading >

Code of Delta is a document I wrote for the team I was heading at Synthesis. It laid down the ground rules and is a summarization of my professional philosophy. I realized I never published it, so here it is.

Welcome to Delta.

If you’re here, it means you are either thinking of joining Delta or you’ve already joined and want to know who we are.

In physics, ∆ is used as a symbol for change. Which is what we are - we are the driving force of change. We make shit happen.

Our motto is „Find a way or make one”. There is nothing that can stop us, because we do not give up. We are smart and capable, when faced with an obstacle, we find or make a way to remove it.

I want to be clear - the goal of Team Delta is to be the best. We will work hard, we will work smart and we will work well. I will put pressure on you and I will expect much. At the same time, I will make sure you have anything you need to succeed.

This document will lay the ground rules so that you know what to expect and what is expected of you.

Continue reading >

Working in tech is great, until you get called at 3am to fight a fire because something in the tech you built just broke. These situations are stressful, tiring and in general - not fun. Ideally, they would never happen, but that’s not how the world works.

Over the course of my career, I’ve been in more than a few of these crisis situations, and I’ve learned a few things about how to prepare and deal with them. I kept building up notes, and I thought I’d share them with you.

I’m breaking up this process into 3 parts:

• Preparation
• Response
• Recovery

We’re going to go over each of these parts, and I’ll give you some examples of tools that you can use to help you in each of these phases. I’m also going to share learnings from my own experience and tips on how to improve the process.

Continue reading >

In a recent article, provocatively named Death to C, Jon Evans proclaimed that we should no longer use C, rather move to Rust for our low level needs.

The author proposes replacing C with Rust, which looks like a great tool to get awesome performance in a production application and sleep well at night not worrying about a segfault, which a tremendous advantage. He also wants to put C and C++ to rest:

Those old warhorses have served us well, but today they are cavalry in an era of tanks. Let us put them out to pasture and move on.

I understand not wanting to hand-write C code in production to minimise risk, but not abandoning it completely. Studying C gives you - as a developer - enormous benefits and skipping it is a mistake. In the introduction to Learn C The Hard Way, Zed Shaw has brilliantly explained why C:

The C programming language’s only failing is giving you access to what is really there, and telling you the cold hard raw truth. C gives you the red pill. C pulls the curtain back to show you the wizard. C is truth.

Of this quote, I especially like the “truth” bit - three words, with which Zed has captured the essence of C. It is a simple and elegant language, so simple that you hit the walls of gigantic complexity very early on, because you need to do the basic things yourself. It’s extremely difficult to write good, secure C code, which makes it very dangerous, and to quote Zed again:

Why use C then if it’s so dangerous? Because C gives you power over the false reality of abstraction and liberates you from stupidity.

C is the sharp, hurtful reality of how a computer really works, how memory is manipulated and how you’re really just moving bits around. Instead of avoiding it, let’s embrace it. C is difficult, because C is truth.

One of the reasons I built Dotz was to see how it would survive change. The first release was simple exactly for this reason - I planned to return to add more features and see how simple or difficult it would be. I managed to add a new feature to Dotz recently - when you connect the dots so that the lines form a shape (like a rectangle or square), all dots of the same color will disappear, adding to your score. As I introduced this feature, I reflected on this refactoring exercise and SOLID principles.

Step 1: Make it work

My initial approach was to take the easy road by modifying the Move class directly. I realized that it was missing some core functionality, such as getUniqueDotCount or getGroupedDots methods. I’ve also fixed an issue in destroyDots which appeared only after it was forced to remove a lot of dots from the screen.

At the end, I’ve expanded it to check if a square was present and schedule more dots of the same color for removal.

I coded, tested and released it. And that’s when it hit me. I did two things: I fixed issues within the Move class and I’ve modified its behavior. Now, fixing issues is fine. Modifying existing behavior in the same class has short legs - what if I want to add more functionality? What if I wanted to give a choice between game modes?

Continue reading >