Sociable Software is Modern Software

It has been a train of thought for many a decade, that the physics of software is a combination of algorithms, data structures, languages and abstractions.

In many cases, these components were a part of the development process, especially back when programmers did not have the luxuries of IntelliSense, code navigation, syntax errors and unit testing, which we take for granted today.

Subsequently, great hardship and labour throughout the decades have provided new language constructs and new tools that allow us to express ourselves more naturally in order to build software.

Such developments have since replaced the use of older constructs that at times made it exceedingly difficult to construct reliable and efficient software.

With this in mind, the physics of software development are no longer algorithms, data structures, programming languages or abstractions.

These have now become tools that are leveraged, re-shaped and then thrown away. They of course, still play a certain role but they are no longer as prominent.

In return, the ideas of software development, its process and methods have long changed from what they once were.

The real physics of mass software engineering no longer relies on the tools alone. Now the process heavily relies on people.

The physics of software revolve around people

It would, I think be more exact to say that the physics of software now revolve around people.

That is people's limitations, our endeavours, and our inefficient ability to capture and define achievable goals, to efficiently communicate amongst investments of large amounts of capital and groups of people, and more importantly, our inability to transfer accurate knowledge.

Sometimes a software project begins with an outline on paper and it only takes a simple idea, beginning only as an idea in the mind of a single person. Yet, it is not long before ambiguous detailing and arduous planning become over-complicated.

In no time, resources are unavailable to build the idea from the ground up. This inevitably causes under and overestimation, business processes have to become re-modelled, and our once eternal and natural desire to work together as a group to solve large problems in small pieces becomes increasingly scant.

Eventually, handshakes between designers and engineers to fulfil a designer’s vision soon become blurred and disjointed.

A simple idea that was written down on paper the previous year soon begins to feel like a horrible idea. In the end, when all is well and done no member of the team wishes to truly celebrate.

Solution

What about a software "decision-making" framework, an in house playbook for a team of engineers, designers, and technical project managers to share and compose internal philosophical and ethical knowledge blocks that are required for a team to understand what their objectives are and how to best bring them into realisation.

We live in a connected world, a world where modern software has to navigate the world over and over again.

So it has become more important now than ever to leverage the building blocks for tomorrow’s very largest solutions and ensure that the building blocks we create can be used easily, interpreted easily and securely connected.

It’s not enough for code to be a "black box" anymore.

Code has to talk to other code, it has to be sociable and well-connected and so do the teams building such code.

A futuristic foundation of modern software engineering

It is no fluke accident that the future of code looks like the human brain because the transmission of knowledge within a complex network is, at some level, the nearest metaphor we have for describing the activity of human brains.

Code will soon need to indicate intelligent behaviour and execute using "instinct" as well as establish trillions of connections and regulate trillions of signals.

This principle remains the foundation of modern software development...

It's about making and composing building blocks that other people or other groups of people can understand and use easily from anywhere.

Having said this, we all know we are still a long way from achieving such desires.

Establishing connections between small to large TCP sockets or even cloud technologies is still a very painful (albeit gradually getting better) task.

In fact, connecting computers is still a difficult task for many industries that have to now comply with various international regulations. Software houses will be around for a while.

Even though the magnificence of the open-source community has attempted to battle and centralise the inefficient methods of knowledge sharing, the point is, that there is still a crisis at stake.

Even though the highs and the lows of the Internet provide us with the largest and most sociable platform mankind has ever seen, the reality is that for engineers, programmers and businesses, much of the code is out of reach, overly complex and for the most of us, so large, that constant problems in health, education, economics, transport, and so on, remain unsolved.

The building blocks often used to solve such problems are unfriendly, dense and often over-engineered.

This means, that it becomes increasingly difficult to maintain an efficient platform or process of exchange to connect the brains that could work together to solve these problems together.

Nevertheless, modern software needs to encapsulate more efficiently how humans think and experience the world.

A well connected collaborative team often produces well connected, maintained code.

A productive team on the ground means a productive business model at the top.

But to be able to attain such dizzying heights, we must first start from the bottom up.

Right now to the reader, I may come across as ignorant to the attempts currently in place to solve such problems.

I apologise for this, I just think before we begin to introduce more tools, more languages and more efficient modes of construction, we should first try to tackle the real physics of modern software development and that is "people", how we use software, how we transmit knowledge.

It is an attempt to tackle and redefine the economics and transmission of knowledge within the software development process itself.