What is Slime Systems?

It is a type of system, designed for flexibility, robustness, and future-proof. It is also the name of this website.

The origin of Slime Systems from the creator

Do you ever have a Eureka moment?
I have one.
My Eureka moment was when I started seeing that programming languages are trying to achieve the same thing in their own way, still, at the end of the day, ending up with the same solution, albeit explained differently.

Example A)
Consider the following statement from an OOP language

object.method(parameter);

, a procedural language can achieve the same thing, but with some rearrangement and new terminology.

function(&receiver_struct, parameter);

Objects can, pretty much, be expressed in non-OOP languages too.
And not just objects, interfaces are quite expressible as well.

Example B)
The currying in functional programming languages

// in JavaScript
const add1 = add(1);
const result = add1(2);
// result = 3

is the same as an object instantiation in OOP languages

// in Kotlin
val add1 = Add(1)
val result = add1.add(2)
// result = 3

; of course, you can curry more than one time, but the concept itself is almost identical.
Combined with Example A, I can, kind of, apply currying in C language.

The wisdom is transferable between languages, while the syntax itself is not. I should also add a spoiler here that, not just currying, compose is also applicable to C language, it just takes an unusual form than when you use it in the functional programming.

I can identify so many similarities like these, allowing me to apply the wisdom of fragmented arts in every environments I encountered so far, on the other hand, allowing me to amass and integrate scattered arts.

At this point in history, the potential of applying acquired wisdom independently from languages and environments has been unlocked, but still missing the crucial piece that made Slime Systems.

The missing piece

The turning point was after I read Clean Architecture by uncle Bob.

Things I like about the book are.

• It lacks concrete examples but full of possibilities.
  Everyone who read the book got their own version of the clean architecture. I got mine, the “Slime Systems”. Everyone else has their own interpretation based on their previous experiences, and no one would end up with the same concrete actions.
• It is a timeless book.
  The author applied his knowledge about writing timeless software to a book. Resulting in a book that lacks concrete example, but relevant for at least another hundred years.
• It is short yet verbose.
  The concept has been represented with so many angles until readers notice that every explanation boiled down to the same simple thing.

Putting pieces together, and I got a type of system that robust, flexible, and future proof. We can’t really call them architecture because they are just a bunch of designs based on the bird’s-eye view of the clean architecture.
Slime Systems are everywhere, a robust enterprise banking backend, a firmware of small devices, a widely reusable and timeless embedded system module. The sky’s the limit of where can you find a Slime system.

Epilogue

The world is a very misdirected place; the community invents the same thing over and over, new languages, new frameworks. Think about it carefully; we will see that most of them bring nothing new to the table. However, if they have fun doing them, then why not?
Just be aware that the solutions might not actually solve any real issue, or there might be another option that does not create more fragmentation.

This blog intends to be the journal of a type of system that defiles the majority and challenges the status quo. See where it goes and what tomorrow brings.