Libertarianism from a Programmer’s Perspective
Libertarianism, simply put, is a set of political beliefs that focus on upholding liberties (i.e freedoms) of individuals. It’s putting freedom (and the responsibility that comes with it) before everything else. The government’s role is to protect and uphold them, and stay the hell away from people’s lives; Let an individual have more control over his life, liberty and property. Hence, limiting the government’s ways and means of cracking down on the rights of people logically becomes one of libertarianism’s biggest goals. Power corrupts, they say, so why increase the risk of it being corrupted even more by vesting more power?
As a novice computer programmer with only two years of experience drinking coffee and creating bugs, I've come across several principles in the programming world and certain core ideas of libertarianism of which I could draw parallels between. I, as a libertarian, find these semblances quite resourceful in explaining and reasoning the philosophy of my political views.
Loose Systems are better
Loose Systems should not be mistaken for systems that are full of issues and problems. They are rather systems that are loosely defined so as to withstand change. Now, it’s quite logical that this does not make sense to a person who’s not familiar with developing software/programs. How could loosely defined systems withstand change? The realm of software development is a one with an incalculable number of unknowns. You could never know what comes in as input to a software, and what changes they would produce. It’s better if you create a flexible system with no hard rules (or a plenty of rules) so that it could as good as possible in as many circumstances as possible. If any amends to the system is needed, you could do them without doing much change to the original structure. Now, if you had a system with a countless number of rigid rules, you have to make a lot of structural changes overtime in order to maintain its viability.
Libertarianism is skeptical of governmental power, and it wants government out of people’s affairs as much as possible. Many of people’s affairs are variables, and we can’t possibly have a plenty of rules over what people do, and expect them to last. People are hard to understand, People change, and with them, what they do. When humans are as such, tight regulation of what people do, and what they own, would be a counterproductive practice. A central ideal of libertarianism is that as long as an activity of an individual does not harm the life, liberty or property of another, it should be permitted. Not allowing an activity on any reason other than that strays from the essence of the libertarian spirit.
Modularity: Keeping things small and independent
Object Oriented Design is a much revered paradigm in the programing community. Object Oriented Design is the practice of making objects/modules which have state and behaviour, and using them extensively to develop a computer program. The state of an object is what it has. The behavior of an object is what it does. A car is a real-life example of an object. Properties such as the color, number of doors, engine displacement make up the state of the object. Actions such as moving forward, braking, reversing make up the behaviour of the object.
In the early days of software development, Object Oriented Design was not supported by the programming languages used to build programs. This meant that all the code had to be written into a file or two. There was little to no reusability; if you wrote a block of code to add two numbers, you have to write it again if your program needs to add two numbers again. So, in the end, what you would have is a file with a big chunk of code, which is mostly repetitive. A software which is programmed such a manner would be much prone to total failure.
Object Oriented Programming, basically, enforces the creation of units (objects) tasked with various activities. In usual practice, the flow of the program is controlled by one main unit, and the tasks of the program are controlled by several other units. All what is done in the main unit is calling their tasks like pushing buttons on a panel. The rest of the work are done by functions defined in other units. This reduces the amount of code required for a program to run by a significant extent. It also ensures reusability of functions; Write once, call/activate anywhere. This makes the program to withstand more failures without failing entirely. Troubleshooting would also be easier as it’s easier to locate and isolate issues.
A big, highly centralized system of governance is not only inefficient, but also a great threat to individual liberty. Hence, it would be necessary to have a rather decentralized system of governance where the process of decision making isn’t unilateral, and many units of it being capable of working on their own without having some bureaucracy frequently meddling with their affairs.
Autonomy, the holy grail.
The more a program grants autonomy to its user, the better. An ideal program or software would grant a significant level of control to its user whilst being user-friendly to a great extent. On the flipside, more control means more ways of failing. That’s the inevitable cost of increased fine control. However, fine control is a great thing once it has been mastered; There are many things which one could do with one tool.
Programmers too could enjoy more fine control, from the various features available in programming languages to those of other tools that are used to build software. As programming tools offer more options and functionalities, programmers would be able to build more flexible and powerful software.
The base of libertarianism is Individual Liberty. All other liberties are derived from that. And with liberty, comes responsibility. There are no safety nets to compensate an individual who ends up getting undesirable results of his/her exercise of liberty. Anyways, what would life be without a few mishaps?
Conclusion
As I’ve mentioned before, Libertarianism is a collection of ideologies. There’s a spectrum with different ends/extremes. I’ve considered the broadest, general definition of Libertarianism when drawing analogies between some its most general ideas and several principles in the field of computer programming. And, of course, these are very abstract or general ideas. I’ve yet to find any political ideology whatsoever being implemented as a whole, the same applies to principles of programming. When it comes to coping with ground realities, compromises have to be made, and it’s outright impossible to enforce one single paradigm on a system overnight.
Then again, almost every principle/idea has its own limitations in implementation. Politics, like programming, is a game of heuristics; It’s all about choosing options having the least of error margins. In the end, every system and ideology out there would fail at one point or another. They all have ups and downs. It’s upto those who make policy to choose the ones that would have more pros than cons.
