One thing you may have noticed when looking at the code of our abstract factory, is that the base classes (interfaces) of each of our abstract objects don’t have much to tell their users: there are hardly any accessors or mutators to be found. This is an attribute of encapsulation called opacity and in this [...]

Last night, I had an idea for a new lock-free algorithm: a single-producer, single-producer queue with a wait-free push and a lock-free pop. The algorithm in question, which is remarkably efficient for, e.g., logging (which is why I called the project HSL for High-Speed Logging) is prone to what I call “spurious popping” – i.e., [...]

In this installment, we will continue our implementation of GSSAPI/SSPI, this time on Windows, where we’ll try to get some credentials. We will look at two topics this time: first, we’ll look at data encapsulation, after which we’ll look at when RAII is a bit too much, and how to handle that.

In this installment, we will be starting an implementation of the same factory we started with SSPI, but using GSS-API. We’ll be doing this one a vanilla Debian-Lenny system, with one caveat: we’ll be using our own compiled version of the Boost libraries. I’ve created a branch in the vlinder-sdk repository for Debian (here) where [...]

In this installment, we will expand the MechanismFactory class for SSPI. We will take a slightly closer look at the SSPI call than we would normally do, and we will also take a look at the Unicode/”ANSI” differences on Windows. Because of this, we will not have time to take a look at the GSS-API [...]

This is an all-new server, but at the same address as before (git.vlinder.ca). Note, though, that as it’s an all-new server, the server’s SSH key has changed. If you were using SSH for any of your access to the server, there’s a good chance that you will both have to register with the server again [...]

The server at git.vlinder.ca has been off-line since midnight and will remain off-line for at least another day due to a hardware problem. It will be back as soon as possible.

In this installment, we’ll be doing a final bit of clean-up and starting to implement a GSS-API/SSPI client program, while focusing on the Abstract Factory Pattern

While going through some old code, for another article I’m writing that will come up on the blog, I came across an implementation of binary search in C. While the implementation itself was certainly OK, it wasn’t exactly a general-purpose implementation, so I thought I’d write one and put it on the C++ for the [...]

In this installment, we will finish the implementation for sending a token from the client to the server. We will answer the remaining open questions and, in doing so, improve the code a bit more. When we’re done, we will have a client that sends a token to the server, and a server that reads [...]