I'm happy to announce Metalang99 v1.12.0, Datatype99 v1.5.2, and
Interface99 v0.8.0!

Metalang99 has undergone the process of refactoring and concepts
unification, e.g., now choice types are represented as tuples.

Datatype99 has one bug fix: `derive` has been made into a proper
functional macro instead of a plain identifier.

Interface99 ships with the improved syntax: `iMethod`/`defaultIMethod`
have been renamed to `vfunc`/`vfuncDefault`, added `VCALL_*` macros
for convenient virtual table calls, and a mechanism for convenient
`self` downcasting through `VSelf` & `VSELF(T)`.

Two significant releases have just been pushed!

Metalang99 ships with a new collection, sequences, and the macros
`ML99_boolMatch` & `ML99_boolMatchWithArgs` to match a boolean value.

The new version of Interface99 features default method implementations
and reduced syntax boilerplate:

    #define State_IFACE                     \
        method( int, get, void *self)       \
        method(void, set, void *self, int x)

    interface(State);

I have a basic understanding of a file system, programs, and all these
kinds of machinery. Now to handle all of this on my computer, I do
need a shell language. A shell language is also a programming
language, so ideally, I should be a programmer too. But that's not
all: additionally, I should know a knowledge CLI options of such
common utilities as `find`, `grep`, and `ls`. Ideally, the most common
options should reside in my brain memory just not to waste my time
surfing StackOverflow. By the way, StackOverflow is also an almost
totally programmer's resource.

The farther we go, the more absurd the situation becomes. I can say,
computers are totally usurped by computer programmers, The Gods of
Bits & Bytes (TM). Users can either scroll the mouse, or please
programmers to do stuff, or go to hell.

Metalang99 v1.8.0 has been just released.

It ships with a new function called `ML99_charLit`; it converts a
Metalang99 character to a C character literal:

    // 'q'
    ML99_charLit(v(q))

The plain version is available under the name `ML99_CHAR_LIT`.

> However, I wouldn't go as far as to say that simple symbol systems we're
> dealing with here in logos are sufficient to model anything remotely
> resembling the matrix, because they aren't. In order to do so, you have
> to master the semantics of derivative.

_A_ matrix, not _the_ matrix :)

Of course, that matrix shown in the film is far more advanced than
we'll likely to create, but the idea (I believe) is very close to
Logos, if not the same.

> What you know you can't explain, but you feel it. You've felt it your entire life, that there's something wrong with the world. You don't know what it is, but it's there, like a splinter in your mind, driving you mad. -- Morpheus

The actor proposition is incredibly interesting.

Take a look at how Logos works:

 1. First, you write a piece of Logos code, and a special program
translates it to bytecode.
 2. This bytecode is then loaded into the Logos virtual machine.
 3. Many actors connect to this virtual machine.
 4. Eventually, they start to communicate with each other.

The Logos code you wrote specifies how actors are supposed to
communicate. Actors, in their turn, can stand for programs as well as

> Point about hierarchies and you position about it.
> OOP was instroduced to solve complexity problem over hiding it under abstractions layers, this descisions was applied because considering that people thinking in same manner.

> If you reject this considerations, than you need to introduce another mechanism of managing complexity.
> (I agree with old-school's position that peoples thinking in terms of sets hierarchies and simply moving up and down over it)

The concept of modality aims at solving this problem.

Modality is just a set of constraints bound to a particular
proposition (function). They can decide whether to transfer the
execution to the main proposition or reject it [1]. Moreover, they can
not only restrict but also add some tiny layer of behaviour, thus
alleviating the need for decorators (OOP) or monads (FP). You can see
from the link that they do it in a more natural way, without type

Metalang99 v1.4.1 has been just released [1]!

This release comes with a few small bug fixes for neat compiler
diagnostic messages, implemented in the previous release.

[1] https://github.com/Hirrolot/metalang99/releases/tag/v1.4.1

Just published a blog post [1] explaining why I've chosen preprocessor
macros instead of external codegen. Check it out!

[1] https://hirrolot.github.io/posts/whats-the-point-of-the-c-preprocessor-actually.html

Metalang99 v1.4.0 has been just released [1]!

This release ships with neat diagnostic messages via `_Static_assert`,
even for compilers other than GCC (such as MSVC, Clang).

[1] https://github.com/Hirrolot/metalang99/releases/tag/v1.4.0