I just released my first VST plugin! I’ve been polishing it on music jams for about an year. In this post I’ll tell some bits about euclidean drums and why I made this at all. And write a little bit of guidelines on it’s features. Intro As a progmetal guitar-synth player, I have a crazy pedalboard with tons of effects: OF COURSE that thing needed a drum module. Sometimes I do drums on synth jams, and I want to be able to play guitar or Exquis at the same time as switching drums and adding fills. Of course, the result is much better when you’re a dedicated drummer with full attention, but sometimes the drummer is away, or someone puts you in charge. Anyway, it’s a lot of fun to play harmonic instrument and switch drum pattern with odd number accents and also play that on your instrument.

I’m admitting that continuing making the c(x) language has grown into a full-blown side project again in past months, after a 10 year break… This post can be seen as a short tour into what the current implementation is capable of, but more precisely - how Effects work here, with a bunch of working examples! TLDR getOdd : Int -> Option Int // implementation omitted checkPositive : Int -> Throw Int // implementation omitted program : Int -> (MyIO || Throw || Option) Int program number = y <- read Int x <- getOdd number z <- checkPositive y return (x + z) myIOHandler = MyIO & has read = ... // custom read impl a <- read Int b <- myIOHandler (program a) print (show result) // 1 1 -> ok 2 // 2 1 -> none // 0 0 -> none // 1 9 -> exception "fail" Intro Shortly, it’s a language where you can write typelevel code with the same language as usual runtime code. Functions are unified with types, and runtime values can be dependencies for types as well, even though it’s statically typed and compiled. Previously I’ve been referring to it as a gradually typed language, but now I don’t think so: constraints and proofs can be established by minimal checks on runtime input. Once a constraint is established, the compiler can use to erase all type logic.

Here is a simple chord visualization tool to quickly find chords using instruments based on different kinds of grids. Select tuning, tonal system, scale, grid type, and other things.

Dependent types, refinement types, gradual types, rank-n polymorphism, etc, – we are moving in the right direction

Simultaneous turns are useful for providing balanced parallel turn-based gameplay, but they will also provide you with a lot of design challenges

Grids are great for tactical gameplay of turn-based games because they allow discrete movement steps. That means that you can bind positioning to other resources such as movement points, action points, food, etc. Grids divide the infinite variety of movement options into a few specific ones, which can be considered separately by the player’s tactical mind. The most popular grid types are hexes and squares. But what about triangles?

This fog looks almost like volumetrics but takes almost no time to render

There was some unsolved issues in my old Medium article, dozens of people viewed it every day and tried to use it nevetheless, so I deleted it. Now there are no issues, and it’s possible to link and flawlessly use protobuf without restrictions

Design and Implementation of Programming Language with Generalized Sets, Types, and Functions as First-Class Values