Hello!

I'm Oleksandr Buzynnyi, 28 yo deep learning engineer.

Here is my tech blog, contacts and maybe I'll add something else later.

Need to start from something :D

Some little facts:

Currently I have 5+ years of machine learning and deep learning commercial experience.

Curious about intelligence in all forms and flavours, contemporary polymatic research, complexity science, statistical physics, thermodynamics, informational theory in context of AI etc.

Contacts:

Codewars (since Nov 2015)
Github (since May 2016)
Gitlab (since Jun 2022)
Mastodon : @sophronesis@soc.ua-fediland.de (since Oct 2022)
Telegram (links dump)
Email : $ echo "c29waHJvbmVzaXNAZGlzcm9vdC5vcmcK" | base64 -d
Bitcoin : bc1qxawfjk0y9d69frdk2l6c6qzty8z8f4kpqmjpv9
Monero : 88McNuddP9t9gNnNdKp8jeLY1V9h5ztA9Rgn1gHRStEcMvHtiWaxmqB64pZq1iJqWcTSbcjpYJxjp87rsashm6e6Q7Q2e3V

On nix

2025-02-08

I've been using nixos for almost a year. I can't remember that something out of the tech world in the last several years was such a rabbit hole as this.
This feels like you are discovering a parallel universe inside the Linux world, that is pareto-optimal on several axes at the same time.
Yes, there are downsides, but they are immensely outnumbered by the benefits included.

Here is a list of all the positive and negative stuff I encountered using Nix:

Good parts:

Nix is resilient: config one time and it won't break later. this is guaranteed by reproducibility up to a hash, unlike Docker, which each time generates different containers for the same Dockerfile
Nix is fault-proof: you can roll back to the previous build of the system if something goes wrong. This is extra important in the work environment
Nix is DLL-hellless: You can't have dependency conflicts. Each package only pulls compatible dependencies.
Nix is easy to tinker with: You can change your drivers in one line of configuration. Same for DE, WM, etc. this gives you the ability to iterate configuration relatively fast, because you don't have to solve already-solved problems
Nix fixes are sharable: if you fix some problem - most of the time you solve it for everyone. Just share your config and it can be reused by anyone. Basically it feels like you live inside a Docker container.
Nix ecosystem is enormous: Nixpkgs have 120k packages - most of all package managers currently, with support for many architectures besides x86_86. More than 100 tools in awesome-nix: https://github.com/nix-community/awesome-nix
Nix community is more friendly compared to other distros
NixOS is best to be experienced first inside a Virtual Machine and then migrating your configuration to the main hardware
You can easily convert your current Linux distro to nixos with nixos-anywhere and nix-infect
You can use the same toolset (flakes + nixpkgs) to construct different objects:
- Fixed development environments for anyone to use on Mac, windows (through WSL) and any Linux distro
- Whole operating system (nixos)
- Dotfiles and user space enviourment (home manager)
- Iso image of nixos
Fast way to test applications (just use nix-shell to launch any application without installing it)
- Even faster way with comma (automatically searches nixpkgs and finds a package with given binary)
Best for people who at least used arch. less hassle than with arch/gentoo, but the same or even more level of customization
Nix supports remote builds, which greatly helps speed up build of several identical machines
Nix is the logical next step after virtual machines (packaging the whole system) and containers (packaging only part of the system). In nix, you just package only direct dependencies that are required for a given app.
You can basically install your whole system from your GitHub link and nixos installer
To make building more verbose and understandable nom (nix-output-monitor) can be used
If for some reason package from an unstable branch can't be built - you can just replace it with one from stable and really swiftly get a working version

And not-so-good parts:

Feels like you need to invest 10% more energy than before, but completely remove the need to repeat yourself to set the same stuff basically hacking your solution and making it sharable are merged in one step
Not recommended if you are just starting to use Linux
Documentation is a weak side here. You will need to search solutions in archwiki, lurk into .nix build files, other people dotfiles, etc.
Currently, best form of education on nix is available on vimjoyer's channel on youtube
Can take more space than regular distro because of older generations
But the size will be basically the same if you regularly clear the cache
Takes time to master. You have the same Linux kernel and gnu toolchain around it, but everything else around it isn't the same. But in my opinion, if you master it - you will get more comfy than in any other distro.
Nix-env (just don't use it and ignore tutorials that do use it)
Relatively long system update time (takes at least 30 seconds on my notebook)
- Running new packages with nix-shell takes a relatively small amount of time, as the package needs only to be downloaded
Harder to install software outside nixpkgs
- It isn't really a problem when you learn nix, as you can write build script yourself using examples from nixpkgs
Problems running random binaries from internet due to dynamic linker being in different place
- Can be solved with: patchElf, buildFHSUserEnv, nix-ld, nix-alien, madness, steam-run, distrobox, docker (more on this here)
SystemD usage. Unfortunately, you can't run nixos with gnu/hurd with runit init system, at least directly
- At least you can use guix or nixbsd for such a task

UPD: As I've tried to post this, my docker container for site and ssl refused to be reconfigured due to an instance limitation, basically validating the point about Docker not being reproducible

Also, my config can be found here.

Telegram autoscheduling

2023-05-20

Link to the project: https://gitlab.com/sophronesis/tgautoschedule

I've been posting on telegram for several years now and learned many things on how to do this more efficiently. One of the things I choose to optimize is scheduling. You can't just dump 100+ posts onto your subscribers, most will just feel overwhelmed from it, scroll past 3-5 memes and move to next channel. Not good.

The first thing to do was just using plain built-in scheduling. It's decent, but has some limits, such as:

100 scheduled messages limit (I know, Durov is squeezing extra storage, yeeaaah...)
you need to manually put each message on timer with fixed time, you can't just dump everything you find interesting to a meme grinder, it takes lots of unnecessary manual labor to convert this turbulent flow to a laminar one.

So i came with the only possible conclusion - to make my own scheduling script. I started with Telethon, but quickly found out that you can't use copy_message() method there.

So let's define the basics. We have one channel that we will call "Queue" which we use to store scheduled edge memes for them to later be posted to another channel called "Target". The only thing this script does is it gets a random message from "Queue" using some given sampler function, sends it to "Target" and if it's successfully posted - deletes an original in "Queue". That's not rocket science, everything is plain and simple.

To use it you need to do several things:

Get your "api_id" and "api_hash" from https://my.telegram.org/ (Go to "API Development tools" -> "Create new application" -> "Create application" and fill the rest)
Put your "api_id" and "api_hash" to config.json in your folder
Put your username or some unique name to "username" to config.json
Modify the createSchedule() function or create your own and replace the name in scheduleF = createSchedule with your own function. Just remember that the scheduling function should output a list of events (transferring of messages) for a current day. Each event is tuple with 3 elements:
- time of day in "hours:minutes" to post on
- source channel name (both plain channel name and @username are valid)
- target channel name
Run src.py and enjoy the reduction in time needed to maintain your shitposting channel

Site launch

2023-04-24

Finally after more than 5 years I'm ready to launch my personal site as I see fit. Currently it's just more like skeleton of what I want to do with it, but it's enough to be published. Main site design (all as one html page) was inspired by John doe's site. Static site is generated with minimal resources (pages/blog posts are stored as markdown files and compiled to html).

Currently it have (will be updated later):

Working RSS feed (not just example.com link)
Contacts page

And what I plan to do in some time:

Old content from telegram/github/gitlab as blog posts here
Restyle site to change to more darker color scheme / JS-free dark mode
Possibly multilanguage pages (EN/UA)

Wildpipes project

2022-08-19

Wildpipes is a project to ease transfer text or image data to or from different destination points with terminal.

Gitlab page

Project started as two simple bash aliases to get clipboard data or to send data to it. It's all implemented in pure bash so won't add extra time overhead, just pure syntactic sugar.

Input destinations: