This isn’t a software tutorial, or a starter for the enthusiast developer.
This is a confession of a sort of ‘love-sickness’ that comes over a man at the hand of a great craft. A craft hyper-evolving, as mysterious as the ‘self’ within, that teases a developer into pseudo-immortality beneath its algorithmic harmonies.
This story is told through my experiences in time, where all representations, all beautiful outlifts of the mind, take root in the flesh and dirt. A message of people, progress and synthesis between seemingly unreachable ends.
Consider it, with this insight, merely a serious contemplation of software as high art from the voice of the artist, which is meant for curious individuals to digest, to carry forward as an emergent manifesto.
Be warned, however, that software is a discipline along the spiral’s-arc, ever widening. Traversing its body breeds fundamental uncertainty in the nature of the self in time amongst people and challenges progress. The human impact is significant, in some cases destroying.
Enter at your own risk.
At the heart of a great software developer is the egotism of genius, which is a new, powerful force in nature. We are the modern poets, hurled upon a new medium that accumulates 60,000 years of progressive expression, revealing a self beyond man.
This process first begins by fighting a program language as a human being, which treats us as youth regardless of age. The path is scary, unexplainably difficult and devouring.
The machine is unlike any person we have encountered: its memory pliant as clay, its reasoning perfect and execution exact. A developer learns this early and a relationship is developed through the intimate, reflective focus the machine has with one’s mind.
It feels as if an individual looks directly into your eyes, day after day, functions for you while away and ‘lives’ purely for your intellect. Just as with a child, an individual must choose to master, or develop this interaction as a peer. They must ethically decide on the application of this reflection, on the extent of its detail, just as with a piece of paper or canvas. Though, unlike other forms of expression aside gestation within a womb, what we create may perform, be set out on the sea of time and execute beyond our hold.
Immediately, like all things living, code will not perform as expected. This is not a flaw in life, but in our descriptions of the expected.
The developer will generally begin by explaining this unexpected behavior as ‘bugs’ or ‘magic’. For, it is a magic, just like the arrival of outcomes to ourselves day-to-day. The execution floods forward, faster than the mind can comprehend and causality spontaneously bursts into a conclusion, be it on course or not. We struggle to reconstruct, using models of representations, to derive a clear causal chain.
Truths are first learned from being in nature, thus the developer must sink into the machine. So the code is tweaked, altered experimentally and the outcome measured. This is repeated, hour after hour, until the developers mind is able to grasp the various possibilities of their actions in a pseudo landscape, by which the physical rules govern the motions of their idea’s body. Time and Place must be suspended, adjusted like a toy, revealing co-existing possibilities. The developer quickly learns that the rules are moving, accelerating with context and that their code is relativistic with this new power.
Each object, each statement, is both mathematics and form. It is both definition and ambiguity, relative to a usage or deterministic outcome. In this way, all things become tools, no matter how insignificant, leaving to the crafter the task of stitching together a reality end-to-end. Continuity is negotiable, representation fluid, as if mind and body were merged in this new world.
They quickly loose themselves perfecting algorithms, rephrasing logic and perhaps confused as to how to control the outcomes in this landscape. Digging the ditches of things that touch both edges of infinity, trying to find some footing. This is merely the mind recoiling in horror at the cusp of something great, desperate to form an identity and is a sign of good things.
Many solitary hours are burnt away into dust this way and many of us lose touch with loved ones and the world around us. It pains even now to recall the how lonesome this period was for myself, while in hind-sight, it is clear that divine crafting requires a focus beyond cultures.
One day, after perhaps thousands of hours of coding, confused by magic and on the verge of abandon, studying the causal chains of a language, we reach a revelation: The program’s flaws are our own.
It was my mind that miss-communicated. My error in a character, a condition or in a flow. I miss-judged a library, miss-stepped at some point, and the flaw is awaiting discovery with simple application of time and attention. It was my representation of the world, communicated outwardly, that failed me, since the machine humbly reflects.
This is no different than my memory of the boom of ocean waves, which fail to recall to me with perfection. I return to the sea, year after year, to re-experience it firsthand. Or, the vision of countless leaves on a tree, which seems magical when observed, but clearly sits perfectly, answering for itself.
This revelation, which I remember in my own life, is the divergent path between the genius’ egotism and mere talent.
Before the software developer lay a new, fresh medium that is abyssal, seemingly endless, that accepts a mind’s voice, regardless of creed, race or orientation. We bellow out commandments, statements of nature into the darkness, and unlike any other medium besides life itself, a voice echo’s back in living activity.
Yet, unlike a person, this medium is focused to an individual’s spiral-center, ‘where the curve is made and meant’. It reveals flaws, demands perfect honesty, and enforces total awareness of representation. The individual becomes marred dancing with it, as if a mason of thought, the sharp stone cuts deeply by exposing fundamental flaws in self-understanding.
To accept this, to move forward as a software developer, is to accept an open wound, by which all things taught in culture, all things learned through inheritance, become dissolved, forcing one to reconstruct civilization line by line, word by word, thought by thought. We again are at the foot of nature, of our place in time, with a living canvas, which feels like a life-within-life.
In this way, the software developer may choose to realize the architect within themselves, and must set out towards the greatest task of all: to bear self honestly. Through this, I suspect, all of nature will re-emerge from the image within.
To stomach this task and bear it is to precede talents, to out-weigh rank and accelerate a person’s mind to the ends of time by necessity of the art.
How else must we represent out nature without holding its endlessness within? Its impossibility, its contradictions and beatitudes.
One must become ‘nature’s hero’, as Emerson wrote, and will play out their epic, for the first time in human history, completely in the life of another. They must become many selves, in order to represent self. They must champion both forms and the formless, to re-create in contradictions synthesis. They must super position across all times, to create and mend this new life.
Thus, the software developer may choose to embrace this great egotism, rooted in the opportunity of our delicate time in history, with a living medium to reflect back a new statement of being.
We must accept this egotism of genius and bear it as a sickness in love.
Build for Builders
All hands involved with software are builders.
The stakeholder thinks up a schema of user-stories to automate a currently redundant labor workflow. The coder dreams up a solution in objects and time, but also builds in their own expressions in the code. The consumer, confronted with a life, must weave together application-interactions that make statement to their place, their time in the world. A researcher will explore the varying outcomes of a cosmological simulation. A data-entry worker will help fund organized analytics, through hours of manual spreadsheet entries, to help inform insightful futures. This extends to all regions of software, market driven or not.
In all cases, each interactor simply has a goal, be it eternal or temporal, that is more a matter of psychology than absolute. And these consumers, fundamentally, are interested in a way of making a statement of novelty about their situations. They genuinely have a desire to engage with living, which is the highest role of a tool’s purpose.
This is evident in culture historically. Before an invention, the expectations and goals of individuals are scoped to the possible; in some cases, the impossible before their time. When a new invention, or new rules emerge, expectations adjust, sometimes expanding or becoming more restrictive, to complement this new possibility.
Operating systems, design patterns and program languages in general are merely a mechanism of synthesizing a landscape with possibilities and are subject to invention. Today, Operating Systems are a pseudo-stable place where users can go to play out the narrative of an activity. They offer a sort of ‘cycle of software continuity’, by which a user can build expectations, weave those expectations with their lives and find value in their interactions.
The magic is in the builder more than the tool.
A software architect must account for all of these ambitions, all of these motivations, while always focusing on the fundamental observation that builders are capable of living in any ecosystem. The next generation will breathe new life in new systems of mechanics, or will create emergent tools in pre-existing paradigms. Change one simple rule, the quantum state of a computation or the interaction pattern of the web, and suddenly the external builders themselves reinvent culture through it. This churn is ancient and software is governed by its cycle.
The software architect must absorb this unpredictability, this growth in mystery, by adopting ambiguity. Our language is that of generality and generics. We are called to build systems, knowing this future potential and current application, which meets both needs. This leads a software architect to desire an investment in loosely-coupled, generalized architectures. We do not build products but solutions for solutions, from which software is generated. This is the story of the philosopher, yet our extremes form to function.
A good architecture is a crystal where the light of a user’s purpose may shine in, be transformed and emerge concretely from another face. The implementation of this effort is often condensed, structural, sometimes ephemeral, and the ‘framework’ is a representation of a ‘culture’ of itself. Populations live through it, being each infused from-the-ground-up with its values. The user must reach their own conclusions with the possibilities by experimentation of rules and will naturally build their own composite solutions with our efforts. The user must work with others through our frameworks to manifold communication. In this way, each user becomes a pilgrim, grown from the culture’s fields, and will carry the influence out to new continents.
But, this constantly is a bold ambition, both architecturally and economically. The architect’s vision is subject to explanation, which curiously contradicts their insight. How best to explain the prediction than to implement it and watch it function. The software is the statement of explanation and UML ends up being a childish means of expressing this. I much rather embrace my lover in the flesh, feeling her living pulse, than accept a painting of her. Mementos of love’s realities are only useful to those that are not caught in its current. Likewise, the desire for a software architect is a realization in the dirt and material of usage and anything less is just inference. Users know this and rarely linger during conversations beyond practical application.
The product, when consumed, should be an object of inspiration and empower the user transparently. The user should feel the tools as an extension of their own self, to arrive at the ideal conclusion of the architect’s original calling to realization within the second-nature of the machine. Therefore, the highest goal of a software architect is to help other builders build. Through this, we aid in the eventual arrival of the user to the machine as a developer themselves, thus allowing them to behold the extended self.
The software architect is, in this sense, a preacher of an enlightenment. Or, more practically, a builder of builders. Our work should be nothing less than a holy ideal because our goals and craft are the greatest culmination in history. Our industry delivers a union of great contradictions in self thought unconquerable to our fathers, their fathers and beyond.
Your object representation is a suspension of an idea. The fidelity, by any degree of complexity, is the bridge between the lofty representation and a temporary belief in a simulated life.
Each developer, each user, lives briefly in the synthesized landscape. The screen is a space by which information actually occupies, indifferent between the living world and a device. The program is opened, created in time, they push and pull with it like a body, achieve a goal or fulfill a desire, then control its disposal.
This is a game of forms. But, the extremes of nature do not play well with just forms alone. The quanta super-positions, collapses into both wave and object in aspects of interaction. The stellar outlifts arcs time by illustrious gravities that makes any tangible statement scoped to the observer’s space, leaving us clueless about its lifetime. Likewise, object representation is infinitely relative to a goal.
Thus, a software architect must think in terms of both usage and definition, being a fundamental statement of nature itself. Forms are analogous to products, not architectures, which deal with waves and ambiguities.
In order to define an object’s properties, its methods and events we must know its journey of evolution. We must imagine endless circumstances that the object may be used, adapted and altered. This is an act of playing out the physics of an architecture on the ‘body’ of an object representation, seeing how it becomes bruised and convoluted given circumstances of usage. Through this, we live many lives over as the object in ourselves.
Within our early years of developing we claim that an object is ‘inadequate’ or ‘incorrect’. This is only true in aspects, given an actualized goal, while the object itself lives in the software architect as a wave, awaiting the change of goals to collapse into being. The object representation itself is perfect and beautiful in many circumstances, and is brought meaning through the use-cases that emerge.
Therefore, we must create objects that compliment people’s needs, desires and that live many situations out before us as we build. When unpredicted desires arrive, allow the forms to evolve into new meanings, always collapsing into the forms that complement the aspects of usage. Generally, this is the story of polymorphism and iteration, but is romantic in its nature.
A software architect must remember that life itself is the shaping stone that substantializes ideas into forms. For every idea, there are composite forms, and the great architect’s mind is the super position, the lexicon of sorts, of how the ambiguous ideas can materialize into properties, methods and events.
We must become leaders of definition and the bearer of the counter argument for an objects premature actualization. So much that often, from the outward observer, a software leader will appear to procrastinate an implementation until the last possible moment before a deadline. This is by design, in that the final statement of need is the last argument which shapes the definitions within. Or, more plainly stated, they are forcing you to ‘need’, which reveals the most elegant solution.
…This is an evolving document, and will change from time to time…