Top secret .NET handles – Part 1 – Dependent handles

.NET publicly has documented 4 kind of handles: Weak (also called Short Weak) – Don’t keep target object alive and will return null when object is gone. The target will become null when the object enters for finalization. WeakTrackResurrection (also called Long Weak) – Don’t keep target object alive and will return null when object is gone….


Calling C functions from Python – part 3 – deep dive into ctypes implementation in CPython

Last time we’ve looked at using ctypes to call C API, and writing extension module using Python/C API. Now we can finally tie these two together – looking at how ctypes is actually implemented using mix of Python/C API and Python code. You can find CPython source code here. ctypes’ C implementation is here ctypes’ python implementation…


Calling C functions from Python – part 2 – writing CPython extensions using Python/C API

In my previous post we’ve briefly looked at using ctypes module to call C APIs. In this post let’s dive into a completely different approach – writing a C extension using Python/C API. From the C extension you can then call whatever C/C++ code you want. This is a pretty popular approach to expose a 3rd party…


Calling C functions from Python – part 1 – using ctypes

Recently I’ve been evaluating Python interop technologies for a project at work and I think it’ll made an interesting blog series. Let’s say your have following C code (add extern “C” if you are in C++ land) and compile it into a dynamic library (dll/.so/.dylib): int Print(const char *msg) { printf(“%s”, msg); return 0; } int Add(int…


Calling node.js sqlite callback function using promise and await

Callback pain I was experimenting with sqlite package with node.js the other day and the async programming style is rather painful, so I did some experiment to wrap it with promise + async/await to make it easier to use. This post shows you how to do that. For example, let’s say I’m working with a database with…


C++ coroutine tutorial

I’ve been experimenting with coroutines recently and I found that information on C++ coroutines are very difficult to find. I’m planning to write a series of C++ coroutine blogs on how to use C++ coroutines, how they work, and how to write your own library that uses C++ coroutines. My last post Basic Concepts are…


Writing your own lock-free reader/writer lock

It is sort of puzzling for me why C++ standard doesn’t have a implementation of reader/writer lock. So just like every other C++ developer, I’ve decided to roll my own.  A typical implementation might be using semaphore / mutex. However, this has a major disadvantage that it requires entering a lock mutex every time a…


Sharing .NET generic code under the hood

If you come from a C++ programming background, you are most likely already familiar with C++’s template code bloat problem. Each template instantiation gets its own copy of the code (of course, compiler/linker can optimize by throwing away unused methods). The reason being that C++ template are more like C macro on steriods. I know…


C# value type boxing under the hood

I recently had some really interesting discussion with a .NET typesystem expert in the team, and during the conversation he had pointed out an interesting aspect of .NET value type boxing when using constraints. Intrigued by that discussion, I decided to take a further look. See the full article here in my new blog  


Moving my blog to GitHub pages –

I haven’t posted in a good while – it’s because I’ve been busy working on .NET native! Now that things has settled down for a bit, I’ve decided to resume writing posts. After spending some time thinking, I’ve decided that I prefer writing my blog posts in plain text/markdown and working on Git repos, rather…