.mischief.mayhem.soap.

If you ever looked at optimized code generated by Clang, you might have noticed it loves vectorizing.

(I had a more catchy post title, but it’d spoil a surprise).

Last week I noticed some unexpected assembly code in a function calling std::unordered_map::find (yes, I know, friends don’t let friends use STL, but that is a topic for another discussion).

I have been comparing how locks (critical sections) behave on different platforms recently and noticed Windows seemed to be quite different than others.

Recently we have updated some of our compilers (Clang) and started running into mysterious problems, mostly in the physics code.

I had another interesting debugging session recently with quite an unexpected conclusion.

I’ve always felt conflicted about the subscription operator[] in standard containers.

The other day I was looking at a crash dump for a friend.

Today I’d like to share a simple multithreading trick you can use to minimize “bubbles” in your pipeline.

If you’ve been reading this blog for a bit, you might know that when I experiment with new programming languages, I like to write a simple pathtracer, to get a better “feel”.

I’ve recently been asked by a friend for a little help with debugging a problem he was running into.

Grafana is a very popular “analytics platform” or in more professional terms - a system to create pretty graphs.

Microcorruption is my ongoing “distraction” – it’s an online CTF.

I’d be the first to admit I don’t have much experience designing public APIs.

Consider the following, seemingly innocent (and completely made up) fragment of code: typedef std::map<int, std::string> MyMap; void foo(const MyMap& m) { for(const std::pair<int, std::string>& i : m) { if(i.first) { printf("%s\n", i.second.c_str()); } } }

I probably mentioned this before, but SPSC (single producer, single consumer) queue is one of my favorite structures.

Circular buffers are one (if not the) of my favorite data structures for some quick&dirty debugging.

Yet another MSVC story.

I recently transitioned to Visual Studio 2017 and while it went relatively painless, the new and improved optimizer uncovered some subtle issues lurking in the code (to be fair, Clang/GCC has been behaving same way for a long time now).

Ever since I was a kid I was always fascinated by the northern lights and hoped to see them in person one day.

Machine learning and neural networks seem to be all the rage recently.

The Old New Thing is one of my favorite blogs.

Few years ago I published an article about love and care for your cache.

A little bit late, as Halloween was yesterday, but I think std::get_temporary_buffer is scary enough to qualify.

I’ve just returned from the Digital Dragons 2017 conference.

Last week I was investigating a crash originating somewhere in a code that looked like this (GPF in this C++ line): obj->GetFoo()->GetBar().Call(player->GetCat(), this, &MyType::SomeFunc, moreArgs We could discuss the number of indirections or the fact th…

A few weeks ago we had a discussion a forum discussion.

I’ve been doing some minor refactoring recently and - once again - it got my thinking how seemingly tiny C++ changes can affect generated assembly code (and performance).

Back in the day I wrote about the ‘dynamic initializers’ problem.

I’ve been planning on converting my blog to some static site generator for a while now, but the (perceived) amount of work involved seemed scary, so I kept coming up with reasons not to do it.

If you’ve ever done any matchmaking coding (…or played chess) you’re most likely familiar with the Elo rating system (PSA: it’s Elo, not ELO, it’s not an acronym, it’s named after a person - Arpad Elo).

A video from my DD2016 talk has been uploaded and can be viewed here:

A few days ago I came back from the Digital Dragons 2016 conference.

You have probably heard about an AI algorithm defeating a human professional in a game of Go.

Recently, we’ve been collectively complaining on Twitter about going crazy in C++ (as we do every few weeks).

I’m playing in a fantasy football league with some coworkers this year.

I’ve been debugging a rare memory corruption bug recently and - as usual - it turned out to be an exercise in frustration.

An entertaining head-scratcher from today.

I’ve been doing some micro-optimizations recently.

I’ve been planning to write a post about debugging multiplayer games (post-mortem) for a while now, but it keeps getting bigger and bigger, so instead of waiting until I can get enough time to finish it, I thought it’d be easier to share some quick’n’easy…

A nice thing about Twitter is that single tweet can bring so many memories.

(Please excuse the terrible pun, couldn’t help myself).

Last year I briefly described my adventure with writing apathtracer in the Go language.

Had a very interesting debugging session recently.

Recently, I had an inspiring discussion with fellow programmers, we were talking about interesting side projects/programs to quickly “try out” new programming language/job interview tasks.

A short cautionary tale from today.

There’s been some comments to my previous post wondering about C++ compilers and their capabilities.

Few weeks ago I encountered a discussion on a Polish gamedev forum – participants were wondering whether it’s faster to access stack or heap memory.

There may come a time in game programmer’s life when he has to fix a bug in a library he doesn’t have the source code for.

Today’s article is brought to you by a friend of mine.