• Decompiling Duden dictionaries

    Duden is the largest producer of digital German dictionaries. Unfortunately, they are distributed in an obscure proprietary format, meant to be used with Duden-Bibliothek software.

    My goal was to reverse engineer the format and write a converter to text-based DSL, supported by both GoldenDict and ABBYY Lingvo (through the official compiler).

    In this blog I describe interesting parts of the Duden format and what problems I encountered while trying to translate it into DSL.

  • C++ atomics

    Each CPU architecture has its own memory consistency model and the means to control the visibility of memory operations among different cores and hardware threads. The memory consistency models of high level programming languages, on the other hand, is an abstraction layer over the hardware consistency models. They aim at providing portability while maintaining efficiency and hopefully providing ease of use.

    C++ is among the few languages that have formalized their memory consistency models (other prominent example is Java). Unfortunately, by only studying the mathematics of high level memory consistency models, it’s impossible to understand how they relate to the underlying hardware.

    In this blog I attempt to shed light on this relationship using a few simple C++ programs that I test on several popular CPU architectures.

  • Creating a tiny C++ task library

    Tasks are a popular concurrent programming mechanism. It allows decomposing a computational problem into a set of isolated sub-problems, i.e. tasks. This decomposition exposes the underlying parallelism of the problem. Meaning that at least some tasks can be executed in parallel, and without any explicit synchronization.

    This post covers the design and implementation of a very simple yet useful task library.

  • Simple Data Flow Analysis

    This is a toy problem to show basic Data Flow Analysis (DFA) techniques.

  • C# quirks

    No language is free of quirks. Here I have a few C# quirks that I came across recently.

  • Cryptography in license verification routines

    In the last post I touched upon the possible uses of cryptography in the license verification routine of shareware applications. In this post I will discuss the common use cases and give some recommendations.

  • PostScript and the bad IDEA

    The strength of cryptography doesn’t only depend on the algorithm selected. It is mostly how cryptography is used that is important. Here I examine an application that made use of a cryptographically strong algorithm in its license verification routine, but due to mistakes made during the implementation, it was possible to circumvent the cryptography.

  • Bit Swizzling

    Here I want to show how low-level bit manipulation can lead to curious results in the memory layout of 2D matrices.

subscribe via RSS