Rogue bomber

Mar 25, 2021

This is a yet another show-off blog.

Yet another one-day-build, made specifically for not-so-exciting ShipIt-51 hackathon we are having at work right now.

This is a terrible code written in JS in matter of some 8 hrs.

Click the button below to start playing.

Gantt chart. Part 3

Mar 4, 2021

I have been writing about and improving on my Gantt chart implementation for quite some time now.

In the previous blog I have promised to re-write the implementation in Canvas. And so I did.

And there are few functional improvements:

  • scrolling and zooming in & out is now a thing
  • you can drag the milestones around and stretch & shrink them
  • an event will be fired whenever a milestone is changed (moved / stretched / shrinked)
  • dependencies are now typed: start-to-start, end-to-end or end-to-start are the only supported types

This is a short show-off blog, it won’t contain any technical details. I shall blog about the implementation in the future.

Here, you can even play around with it now!

ShootThem! revival

Nov 13, 2020

Quite some time ago I dag out the sources of an old game of mine, ShootThem! made back when I was at high-school, around 2006.

It has been over a decade ever since I made that game and I had enough inspiration to revisit the code once again.

This is a short update blog about what it used to be and what it became as of now.

Read more

Vim keystrokes cheatsheet

Aug 4, 2020

The time has come for me to list few of the commands and keystrokes that I use (and the ones that I don’t but would like to start) in Vim.

I am actually running a Vim plugin for Visual Studio Code (this and the previous blogs are actually written with this plugin ON) at this very moment.

Bear 🐻 in mind: this blog is aboout keystrokes only, it is not about plugins or configuration I use - I shall cover that one day.

Things I know by heart

  • h, j, k, l for slow but precise character-wise movement
  • w, b for faster forward (and, correspondingly) backward word-by-word movement
  • $ and ^ to go to the last and first word character of the line
  • gg and G to go to the beginning and the end of the file
  • O (capital o) to create a blank line and go to INSERT mode above and below (lower-case o) the cursor
  • f, F and t and T for single character lookup within the current line
  • / and ? to search forwards and backwards
  • c (followed by the object) to change the object; this expands to the following few commands:
    • cw to change the current word under cursor
    • cit to change the text within the current XML tag
    • ca' to change the text surrounded by single quote
    • ci< to change the text surrounded with &lt; and &gt;
    • ci{symbol} to change the text surrounded by symbol, which could be ', ", &#96;; you can also use b( for block of text, surrounded by braces, B{ for block of text surrounded by curly braces or p for paragraph, all instead of symbol
  • v to enter the VISUAL mode, followed by the command:
    • v{select}c immediately change the selection
    • v{select}d cut the selected text
  • y and p copy and paste the selected text (lower-case p pastes above the current line, capital-case P pastes below; capital-case Y copies the entire line, so the duplicate line command in Vim is Y, P)
  • {number}{command} repeat the command number times
  • . (the period or dot symbol) repeats the last command
  • x to remove the character under cursor
  • r{char} to replace the character under cursor with char
  • A to go to the end of the line and enter INSERT mode (“append”)
  • u and Ctrl+r to undo and redo actions
  • > and < adds or removes the indentation

Things that I am still getting used to

  • {number}{motion} instead of h, j, k, l
  • a instead of i to enter INSERT mode after the cursor (as opposed to i which enters INSERT mode before the cursor)
  • H, M and L to go to the top, middle and the bottom of the screen (High, Mid and Low)
  • * and # to search for the word under cursor forwards and backwards
  • {count}/{query}⏎ to go to the count-th occurrence of query; it is same as searching with / and then hitting n count times
  • gd navigates to a definition of an entity under the cursor
  • gf navigates to the path under cursor
  • % moves the cursor to the matching brace, bracket or curly brace
  • g~ toggle the case
  • = format the selection
  • gU makes the selection uppercase

Gantt chart with D3. Part 2

Aug 2, 2020

This is a follow-up to the blog I wrote a bit over three years ago, Gantt chart with D3

In the original blog I claimed to implement something like this:

Yet I ended up implementing something more like this:

Does not look quite same, right? It also does not work quite same and lacks few quite important features too.

Don’t get me wrong, the original implementation did serve project needs, but it was not something anybody could simply use in their project management software and expect customers to love it.

Hence I came up with these complaints about the implementation:

Namely, there are three main issues that I see:

  1. there is a place for mistakes: milestones are allowed to depend on later milestones or simultaneously going ones
  2. there is no clear distinction between the dates each specific milestone starts or ends
  3. if the milestones overlap with current timeframe, current day is not highlighted on the chart (and that often is useful)

Apart from that, there are few technical challenges preventing his whole thing from becoming a real application component:

  • dependency lines look ugly with those sharp corners
  • the implementation is not based on any framework neither does it declare its dependencies (like D3 or MomentJS)

Now I want to revise the original implementation and make it a bit more usable, just like this:

Read more

Erlang in 5 minutes

Jan 10, 2020

X = erlang, Y = 5, io:format(“Learn ~s in ~s minutes”, [ X, Y ]).

Welcome to a 5-minute Erlang introduction!

First things first:

  • Erlang is a functional programming language
  • erl is the REPL shell
  • Ctrl + G and then q or q(). to exit the shell
  • c(file_name). to load the code from file

Now, to the language constructs:

  • every statement has to end with a dot (.) symbol
  • multiple statements are separated by comma (,) character
  • constants start with a Capital Letter
  • atoms (yes, like in Ruby) start with lowercase letter
  • atoms are allowed to contain spaces (sic!), but then they have to be quoted: 'atoms are awesome'
  • atoms can also have the at sign (@)
  • anonymous functions are defined as fun() -> return_statement end.
  • last statement before end must not end with comma
  • function signature is function_name/number_of_arguments: factorial/1, format/2
  • comments start with percent (%) symbol
  • lists are [ TheOnlyElement ] or [ Head | TailElements ], where TailElements is also a list
  • pattern matching just works [ Head1 | Head2 | Tails ] = [ 1, 2, 3, 4 ]
  • strings are just "strings"
  • tuples are quirky { elt1, elt2 }
  • maps are even weirder #{ key => value }
  • operators are almost fine:
    • comparison: < (less than), > (greater than), >= (greater than or equals to), =< (equals to or less than), == (equals to), /= (not equals to), =:= (adds type checking on tops, JS equivalent of ===)
    • assignment / pattern matching: =
    • math: +, -, *, /, div, rem (Pascal way)
    • typechecking: is_atom/1, is_function/1, is_number/1, is_boolean/1, is_pid/1, is_list/1, etc.
  • list comprehentions are similar to lists: [ N || N <- [ 1, 2, 3, 4, 5 ], N rem 2 == 0 ].
  • files are modules, defined with few statements:
    • -module(module_name).
    • -export([ list_of_function_signatures ]).
    • -import(module_name, [ list_of_functions ]).
  • calling module’s export be like module_name:function_name(arguments).

Quick recap:

%%% module comment

% exporting the functions from the module
-export([ factorial/1 ]).

% importing the functions from the other module
-import(my_other_module, [ new_factorial/1 ]).

% constants with pattern matching - will assign the value to non-defined constant on success
X = 5.

% redefinition is prohibited
X = 10. % exception

% functions can also be constants
PlusOne = fun(X) -> X + 1 end.

% or, multiline
PlusTwo = fun(X) ->
  X + 2


% the standard way
bad_factorial(N) ->
  N * factorial(N - 1).

%% function documentation
% functions can have *guargs*, which are basically pattern matching
% also, function overloading is split with semicolon (;)
factorial(N) when N =< 1 -> 1;

% last overload ends with dot (.)
factorial(N) -> N * factorial(N - 1).

% some return types
string_fn() -> "hello, world!".

list_fn() -> [ 1, "elements could be of different types too", -3.14, atom ].

function_function() ->
  fun(X) -> X mod 2 end.

dict_fn() -> #{ "key" => -3.14 }.

tuple_fn() -> { elt1, elt2, "elt 3" }.

%% note how overriden_function/1 has different definition than overriden_function/2
overriden_function(List) ->
  overriden_function(List, 0).

% the power of pattern matching!
overriden_function([ Head ], Acc) -> Acc + Head;

overriden_function([ Head1 | Head2 ], Acc) -> Acc + Head1 + Head2;

overriden_function([ Head | Tail ], Acc) ->
  overriden_function(Tail, Acc + Head);

overriden_function([], Acc) -> Acc.

complex_function(A, B) when A =< B -> A;
complex_function(A, B) when A > B -> B.

complex_function(A, B, C) ->
  X = complex_function(A, B),
  complex_function(X, C);

complex_function(A, B, C, D) ->
  X = complex_function(A, B),
  Y = complex_function(C, D),
  complex_function(X, Y).

fst({ First, _ }) -> First.

snd({ _, Second }) -> Second.

evens(List) -> [ X || X <- List, X rem 2 == 0 ].

keys(#{ Key => Value, _ => _ })

There also are few good resources on this: and

A response to response to hello world

Jan 10, 2020

Recently I’ve received an email from StackOverflow newsletters with a link to a quite controversial (at first glance) blog, A response to Hello World by Caleb Doxsey. This blog is a response to another curious read, Hello world by Drew DeVault.

In the former article, author compared the performance of a tiny “Hello, World” program in Assembly to the same program in Go. He then tried to optimize the program in Go to run faster and towards the end of an article comes up with a program that is faster than its Assembly counterpart.

And this totally makes sense, since if you give it a good read, you will notice that author did optimize the program in Go but did not do that for the Assembly program.

I have decided to burn few hours of my life and jump onto this topic, since, in my opinion, author did not do a fair comparison.

Read more

Linq is awesome, right?

Dec 11, 2019

Recently I’ve seen a curious blog on, C# and .NET Core Appreciation Post. The most beautiful piece of code I have ever seen… this month!.

In short, author was amazed by how beautiful Linq is, supporting their feelings with this code snippet:

public User GetUserByToken(string token) {
  var user = (from u in Users
              join t in Tokens on u.Id equals t.UserId
              where t.Body == token
              select u).SingleOrDefault();

  return user;

Let’s tear this example apart and check how really performant beautiful Linq is!

Read more

Type casts in C++, explained

Mar 21, 2019

As explained by my colleague, former professional C++ developer (now writes schwifty Java). Below is a quick explanation of four basic C++ type casts. Just for the matter of shorter post, consider each cast taking a template type T and a parameter value v like this: const_cast<T>(v).

  • const_cast - removes the const from the type of v (think of casting const char* will produce char*)
  • static_cast - C-style, unchecked explicit type casting (just like in old 90s: (int) 3.14)
  • reinterpret_cast - hard low-level treating a block of memory as type T, no matter what resides in that memory
  • dynamic_cast - does the runtime checks of param type and template type

Partial application vs currying

Mar 20, 2019

Here’s a quick explanation of the difference between currying and partial application.

For a one- or two-argument functions there is little to none difference. But for function with multiple arguments…

Say you have a function f(a1, a2, a3, a4) (it does not really matter what it returns or what the arguments are):

  • currying it will give you a function of one argument, which will return a function of one argument (and so on and so forth), calling which (the last one-argument function) will give you same result as calling the original function f with all the arguments of single-argument functions passed at once (curried): curry(f) = f1(x1) => f2(x2) => f3(x3) => f4(x4) === f(x1, x2, x3, x4)

  • partially applying a function to some N values will give you a function of smaller amount of arguments, where the first N arguments are already defined: papply(f, 1, 17) => f1(x3, x4) === f(1, 17, x3, x4)

In Javascript, the two could be implemented like this:

function curry(f) {
    function curry(f) {
    const currySub = function (fn, args) {
        // Surprisingly, `fn.length` returns the number of arguments of a function `fn`
        if (args.length < fn.length) {
            return function (x) {
                return currySub(fn, args.concat([ x ]));

        return f.apply(null, args);

    return currySub(f, []);

function papply() {
    const f = arguments[0];
    const args0 = Array.from(arguments).slice(1);

    return function () {
        const args1 = Array.from(arguments);

        const args = args0.concat(args1);

        return f.apply(null, args);