• Haskell, the little things (1 of N) - where clauses

    This is the (1 of N) installment of a series of short posts where I list some “smaller” features of Haskell that I’ve found neat and valuable.

  • Pattern-matching without a match

    Emulating pattern-matching in a language without native support for it.

  • Announcement: haz-rs

    A thin abstraction over polymorphic environments for Rust.

  • Rebinding Template Template Parameters

    Rebinding a template template parameter in C++ might be useful at times, or at least fun to do.

  • Type-driven Designing Haskell's filter

    A type-system imposes discipline on programs. And we can make the best out of it by employing correct, precise, and expressive types; ultimately even letting the type-system assisting us in our design. Equipped with well-crafted user-defined types, we can then make some illegal states unrepresentable.

    Additionally, types are great to disambiguate and communicate ideas to fellow programmers.

  • Cross-Compiling C++ Projects with dockcross

    Cross-compilation has a huge impact on the development of cross-platform C++ embedded software. Therefore we have plenty of tools to help us, and dockcross is one of them, which we will briefly discuss.

  • Haunting Bugs with Phantom Types

    Phantom types are useful to encode information about how, when, and where values are supposed to be used, which can catch a class of bugs early.

  • Property-based Testing in Golang

    Testing is a critical part of software development. Let’s see how property-based testing can help us to test our Go programs.

  • Algebraic Data Types and Data Modelling

    Programming is about composition. We usually tackle a problem by breaking it up into smaller and more manageable tasks, which are then composed together into the final solution. Types can play an important role in assisting us.

    Algebraic Data Types bring us yet another interesting way to express concepts in code. Let’s see how they can help us.

  • Expressiveness, Nullable Types, and Composition

    absent is a tiny open-source C++ library meant to simplify the composition of nullable types in a generic, type-safe, and declarative style.