Software developer. Functional programming enthusiast.

Hello stranger, nice to meet you! Sit down, relax and have a cup of functional programming. My name is Ilja Tkachuk (also known as timCF). I'm software developer, live in Tallinn, Republic of Estonia.

I have been programming since 2012. At the beginning I had some experience of development in imperative languages like C++ and JavaScript, but I did well only when I switched to functional languages like Erlang, Elixir and Haskell.

Today my main skill is functional programming and I'm strong expert in BEAM/Erlang VM platform, Erlang and Elixir languages. I have strong understanding of multithreading and interaction between Erlang processes. Of course in commercial development I'm using mainstream frameworks like OTP, Phoenix and Ecto.

Future plans - to become more familiar with static-typed functional languages. If static-typed languages for BEAM/Erlang VM like Alpaca, Gleam or Elchemy will be successful - I will be happy to switch. Also I have a huge interest in Haskell programming language and I'm doing my own personal project using Yesod Web Framework.

  • Things I do like

  • Functional code
  • I like functional languages. The concept of immutable data greatly improves code readability and simplifies the development of multithreaded applications.
  • Strong static types
  • For most of my career, I've worked with dynamically typed languages like Erlang and Elixir. BEAM Erlang VM, Erlang and Elixir languages, OTP and Phoenix frameworks are great tools to solve any kind of problem in telecommunications area. And I like to work with this toolset. But in my opinion this toolset is not perfect because of dynamic type system. Of course, static analysis tools like Dialyzer improve the situation, but not enough. Some time ago I began to study Haskell language and I really liked it. Safe, readable, predictable, simple source code and the most powerful type system ever. I'm not very experienced in the Haskell language, but I like Haskell and I'm very interested to use it more.
  • Apple & MacOS
  • Mac computer is superior and stylish hardware with modern enterprise UNIX software. Just works from the box. Perfect tool.
  • Responsibility
  • Personal responsibility distinguishes a professional from a beginner in any field of activity, including software development. If a developer positions himself as a professional - only he is responsible for the code written by him. A professional can work alone on high-level tasks without a layer of managers between him and business side. A professional knows how to solve the problem properly without blurring the responsibilities between team members, management and business. If a professional needs something to solve a problem - he just gets it directly from the right people. The professional does not need external motivation because he always knows what he is doing and why.
  • Automated tests
  • I never commit uncovered / untested code. 100% test coverage is standard for my commercial projects. Automated tests greatly simplify future refactoring and other code changes. And of course it's nice to be sure that every line of code was called at least once and worked as expected.
  • Documentation
  • I always write documentation of my projects. It is very important to formulate thoughts in the form of text starting from a technical task. I write technical documentation manually in markdown language and I deal with auto-generated (from source code) documentation as well.
  • Nordic countries
  • I like the northern nature. And I like the sea. I definitely like the northern European countries Norway, Sweden, Finland, Estonia and I dream about Iceland and Faroe Islands. Canada and the northern border of the United States also look good.
  • Things I do not like

  • Imperative code
  • I understand the great importance of imperative languages. I just do not like them. Mutable data and imperative constructions make high-level code more confusing and unobvious (especially in case of multithreading).
  • Weak dynamic types
  • I'm absolutely against the weak dynamic type system in programming languages. It is usually assumed that such languages accelerate the development process, but in reality the quality of the code falls disproportionately. Weak dynamic type system is the world of stupid runtime errors like "undefined is not a function" and unobvious implicit type conversions (like in JavaScript).
  • JavaScript & NodeJS
  • JavaScript is my most unloved language. Type system is weak and dynamic. Runtime system is single-threaded (concurrency in JS is not real multithreading). JS does not have a unified system of modules. JS does not have a unified structure of project. JS does not have a "normal" classes and OOP. JS does not have any types inference. JS does not have unified technology for working with asynchronous code. JS has absolutely mad NPM with very low-quality packages. And finally this language is very popular, and this is the only language that works in web browsers so sooner or later you have to deal with it even if you do not want to. In spite of all of the above I'm pretty experienced in JS ecosystem - I have production experience in JavaScript, CoffeeScript, LiveScript, PureScript, Sass, Jade (Pug), React, React Native and many other libraries, languages and frameworks... And my experience suggests that it is better not to use these tools if there is another working alternative.
  • Microsoft Windows
  • Most GNU utilities do not work properly in Windows. Windows does not have normal package manager like apt-get or homebrew. UNIX operating systems are just much better suited for work.
  • Scrum & bureaucracy
  • I think it's possible that for some people scrum is working pretty well. But not for me. Scrum process and useless regular meetings make boredom and greatly slow me down. It seems that the scrum is working well when everything is going according to plan and the team is working with high rank professionals, but in reality this never happens.
  • Hot countries
  • I just do not like the hot climate, it's physically hard for me.
Haskell (ML family)
Yesod Web Framework
BEAM/Erlang VM
Elixir metaprogrmming
Elixir
Erlang
Bash
GIT
SQL
noSQL
Scala
Clojure
Livescript
Twitter Bootstrap
CI
Phantomjs Engine
Brunch builder
React
React-Native
Jekyll

Modern solution for online reservations

Puppeteer client library (web-scraping oriented)

Utilities for builds and deploys of Haskell programs

Cellular automaton

Compile-time named arguments

Compile-time enumerations

Symmetric equivalence relation for pair of types

Ordering relation protocol

Elixir terms in system env

Configurator with static schema

Memoization of function calls

Type-safe constructors for Elixir structures

100% safe types conversions

Type-safe constants for Elixir

Project configuration focused on code safety

Funny (and inefficient) singly linked lists

Crazy functional stuff for JS

I am the author of this test task

Pipe matching for Clojure

This static website

Slides about Erlang/OTP/Elixir

Other open-source projects on my github

Scalar blindness
open slides
download video

It’s mostly about common practice of scalar types overloading. I’ll explain by examples why this practice is bad and will show how to completely fix it with properly designed algebraic data types (in Haskell) and how to decrease this pain a little bit in Elixir with macro.

Location
Tallinn, Republic of Estonia
Email
tkachuk.labs@gmail.com
Skype
tkachuk.i.m.
Telegram
+7977 815 5221
Phone
+372 5811 4271