Part 3 - Masculine and Feminine planes

Started by CultLeader, June 02, 2021, 07:33:25 AM

Previous topic - Next topic


This post will be the spiritual explanation behind the pattern post. You have to understand the pattern if you want to understand this post.

So, in a nutshell, the pattern is when you have a meta executable, that checks as many things as you want, say, database queries, schema migrations, if servers with components have enough resources and so on. Then, once all of your assumptions are checked you generate as much typesafe, tighly restricted code as you want. You can generate backend code that serves REST endpoints and you can generate typesafe frontend code that queries the backend - everything is consistent. You could also generate native app code, say android or swift to interact with the backend - sky is the limit.

This is a divine pattern and permeates all of the creation. Imagine your codebase is a body, so, meta executable is brain that ensures everything is consistent and logical and dictates and has absolute control over the shape of the body. Just like a rooster has control over many hen. The same way in traditional family the man is in the control of the house and has to think how to provide and grow the family.

But I would have you know, that the head of every man is Christ; and the head of the woman is the man; and the head of Christ is God. - 1 Corinthians 11:3
Wives, submit yourselves unto your own husbands, as unto the Lord. - Ephesians 5:22

Examples from the bible are countless.

This is same as God of the bible bossed around children of Israel in Old Testament how Jesus also orders around his followers. Jesus is in the masculine plane and calls all the shots.

Consider your body, eyes provide information to brain, touching and smelling also provides information to brain, yet the brain is responsible for making decisions - one point, so that everything be consistent. What if the arms of one person wouldn't listen to the brain? Imagine, you hold shield in one hand and sword with another, you can cut with one hand but you cannot put shield up to defend against the enemy because other arm is disabled. Is such person fit for battle? We'd call such person disabled, i.e. not of a full capability.

Believers throughout the entire bible got chastized and punished for disobeying God's word. God does not consider himself disabled, he want his body to function properly, i.e. everyone ought to be doing his will. Any deviation from that has negative consequences.

This is the strict order we establish with meta executable and masculine plane. We generate code that must be typesafe and consistent. 95% bad stuff that otherwise would happen only in runtime in a dynamically typed language is now caught in our custom compile time and hence has to work in the production.

The world and its insanity

By contrast, consider average leftist organization. The people cannot conceive such idea, hence all their environments are incosistent and very fragile. Consider all the errors that happen in production, misconfigured switches or routers. Invalid SQL query. Kafka topics that still exists but nobody knows if anyone uses them. Broken contracts by REST API's. There is no order, all is chaos. Such companies hire thousands of people, hence must have deep pockets, get best developers and yet the end result is an utter failure of strife, confusion, misconduct and production failures over and over again.

For where envying and strife is, there is confusion and every evil work. - James 3:16

Average leftist pagan monkey cannot conceive the idea of a masculine plane that checks logically if our codebase makes sense, and only if it does, generates code that enforces the agreed upon boundaries. Also, of course, the side effect of generated code is that all the complexity and coherency of the system is ensured by a masculine meta executable plane, hence, people who write code that plugs into the enforcing code only need to fill in the blanks and use high abstractions provided by the framework. Hence, since these people are doing easier job, and don't need as much technical knowledge, can work only in feminine plane and scale the system with high level abstractions. Consider analysts, which, in my experience, are mostly women. But, people who build the platform (SRE's) are men in general as they must have knowledge of low level masculine plane.

Leftist idiot SRE's build and provide a database, and just give it to the feminine plane. They do not ensure that queries will work in production. This work goes into developers who work in feminine plane and they cannot ensure that, unless they write ton of unit tests, but nobody ever does anyway. If they do build the framework, about which masculine plane is unaware, there are tons of cases where developers do exact same thing but a little differently, and hence you get inconsistent duplication of effort that brings in more problems, confusion and maintenance issues.

How things ought to be done

There must be one ruler that dictates how application developers develop their apps, and they must all use the same abstractions. To avoid duplicated waste there must be:
- One way to query/mutate the database
- One way to store secrets
- One way to interact with queues, with typesafety, of course
- One way to log things
- And so on and so on

Masculine plane has to provide all of these abstractions, make sure they all work together and are perfectly coherent. Masculine plane must ensure there is no duplication of effort and provide this for users of feminine plane to build their abstractions with ease and minimal effort. Only then we can consider it a perfect system.

To achieve this, you MUST represent your problems as data.

For instance, there must be a single list in the meta executable that has all the queues in the company, all with their typesafe signatures, capn proto generated schemas and such. If feminine plane component wants to put that queue to use, for instance, put element into it when it receives HTTP request, masculine plane must ensure that:

  • Typesafe rest endpoint is generated and user only implements the typesafe function that receives typesafe, already parsed payload body of REST request, hence, he doesn't parse anything by hand and cannot ever make a mistake
  • Typesafe function is provided for user implementing the function in feminine plane, that will accept typesafe queue element, and masculine plane generated code takes care of serializing the payload, say, with Capn Proto and putting it into, say, Kafka queue.
  • All logging for the component must be declared upfront, specific, typesafe structs with their fields
  • All monitoring for interaction with provided abstractions (HTTP endpoint, typesafe kafka queue) must be generated automatically, say, prometheus global variables must be generated to be incremented upon usage of abstractions
  • If all the above following is defined as data in the masculine plane, by higher level abstractions, grafana dashboard of interactions with queues and rest endpoints can be easily generated from data

No need any longer for nonsense of skimming through million lines of codebases to find all the times database is used through gazillion different libraries and stuff.

Only one way to do everything, hence, duplication of effort should be impossible, hence, minimal waste in the system, and we could finally declare what no leftist cuck could ever dream declaring of - having a perfect system.


This is radically different from pagan software developers today, that comprise 99% of developers. There used to be specific gods that do specific thing back in the day. Say zeus, god of thunder, aphrodite god of love, aristaeus god of bees. Pagan stupidity limits them to thinking that if they want rain, they had to pray for zeus, love - pray to aphrodite. This paganism is permeated in software developers today.

All of the mentioned responsibilities today are listed as separate "gods" that maintain bunch of crappy, incoherent yamls that never work the first time anyway. Say, you want to go to kubernetes, go to that team, write some yaml. Or, you need a database, go to that team. You need secrets, go to that team. This is paganism and its a mental disorder. Pagan monkeys cannot fathom the idea that all of these services simply ought to be developed as a single perfectly coherent codebase whose components perfectly interact with each other. They cannot imagine one all powerful God, like the God of bible, who made everything and knows everything and is perfectly consistent and has no contradictions. When pagan monkeys imagine a god, like in doom eternal, in final part, ancient gods part II turns out that god was banished and suspended and is not all powerful and was killed by his creation. This is pathetic pagan monkey god that is not all powerful and fell a prey to his creation. Pathetic.

Say, you need a database for component, you need to declare in masculine plane as data:

  • Database name
  • Its tables with columns
  • What typesafe queries it will have
  • Component that will use given databases typesafe queries
  • Write some filler code in feminine plane
  • If component is ever deleted and nobody uses database make sure to notify everyone and optionally have ability to drop or backup data

Done with your day. No need to ask anyone to deploy anything and schedule meetings of making everything work together.

Imagine connecting kafka to clickhouse in masculine plane, you would declare that this typesafe queue is to be dumped into that table. Masculine plane could check and enforce:

  • That signature matches
  • That the table is somehow used and not end up in legacy forgotten unused territory like kafka queues
  • Ingestion rate is monitored and so on

Sky is the limit and things are radically better once we establish masculine planes and feminine planes and everyone's responsibilities are clear. This is how you can develop things faster with few people than thousands of monkeys at google or facebook fixing production issues daily due to lack of coherency between developers. Also, this is how you can ensure you have minimal amount of components that accomplish everything, for instance, you don't need MySQL and Postgres, since you implement these abstractions yourself you will be motivated to use minimal set of tools you can to solve everything and to increase the value of entire system by having the least interactions between components. For instance, you wouldn't need to think how to ship table changes to Kafka from Postgres and MySQL if you only pick Postgres and need to implement only Postgres->Kafka flow without implementing MySQL->Kafka flow.


Also what is interesting, since with masculine plane you can generate completely independent coherent modules, there could be no proof at all that code was generated. Container could be running in kubernetes with minimal dependencies, and is in perfect harmony with the rest of the system, yet an outside observer that would inspect binary code would have no idea that executable was mostly generated and has no shared code with most of the system. This is like having a soul, thing that keeps us sane in these troubled, attrocious, imbecile leftist times and keeps us going into the LORD's direction. There is nothing on the outside that tells us we are connected to the LORD, yet we are and are in perfect harmony with him and his mind.

For who hath known the mind of the Lord, that he may instruct him? But we have the mind of Christ. - 1 Corinthians 2:16

So this is the reasoning behind the pattern and explanation of divinity with neccessary masculinity and its interaction with the feminine plane.

Illustration of architecture comparing paganism vs feminine and masculine planes:

I know which one I prefer ;)