I was sitting at lunch the other day with my friend and business partner, Kevin, discussing direction and next steps for
Propits. During the course of the conversation there was a moment where we disagreed with one another on a seemingly fundamental point about the direction that we are taking, and are preparing to take as we move forward with this great social experiment.
Now, disagreements will happen. It wasn't even a big one, and was resolved quickly, but it got me thinking about how I code, and the vision that we started with for the Propits network. I started thinking about the different "levels" of coding, and what it means to write code that really matters.
Propits is a new and unique endeavor. I don't know of any other company or group that has tried to do quite what we are trying to do. The ultimate goal is to bring people's understanding of economy and money in general back to what money was created for: a physical expression of an internal feeling. That's not an easy thing when every time you turn on your TV there is some well-dressed, seemingly educated man sweating with panic over the "bad economy". All the vision and hope in the world will only change a small number of minds. There needs to be something more.
When you first learn to program computers, you learn some basic concepts of programming. Things like loops, conditional branching, variable assignment, etc. Nothing too complicated. Loop over some bit of code until something called "a" equals 10. You learn to do this in a single language. After you can solve standard problems with that language, maybe you learn another and another. At some point you can honestly say, "I am a programmer", at which point it's time to start looking at higher-level concepts.
The actual code that runs the Propits network isn't terribly complicated, aside from some math. Sure, there's a bunch of stuff to make sure that rounding errors don't make the money disappear into the ethers, but that is all industry-standard stuff. There's the user handling code that keeps track of all the information of each person that uses the system, even that's not a terribly large amount of information, and it's relationships can easily be expressed in human language (something that doesn't always happen in information theory). The genius of Propits is the vision. The idea that it represents and expresses through its use and function.
Once a coder has learned a couple of languages, discovered the things that the major ones are good for, or not good for, figured out how to write all the standard algorithms and patterns, it's time to look at programming techniques. A programming technique being a methodology, or mentality, that you enter into the coding experience with. A process that you follow to accomplish some goal. Some of the google-worthy methods are Test Oriented Programming, or Aspect-Oriented Programming, Xtreme Programming, Getting Real, etc. They are language-agnostic, and can be applied to any project or group (with greater or lesser success depending on the project and group). They aren't "programming" as such. They are the patterns of work that people have found arise naturally to solve some problem that always comes up regardless of how you program, or in what language. Specifically to solve business or inter-personal problems, as apposed to just "why does this thing always crash when the user presses shift?!". Once they have been named, and books have been written about them, these meta-concepts become "things" that other people adopt into their day-to-day work. For the most part, this is where the industry stops encouraging growth in it's coders.
Propits uses a programming methodology that I like to call "Kick it out the door, it's not that fricken complicated". The basic idea of this coding method is that the system isn't that complicated, so get it out there. To date, the only real problems that we have had fall into two categories: 1) Our credit card processor freaks out (not our fault, and is now resolved), and 2) Sloppy code written at 2 in the morning (solved by not pushing code written at 2 in the morning). The total lines of code in the system is less than 2000. You've probably read more text in this blog post than exists in the entire site. Because of it's simplicity and small size, and the fact that it's me and Kevin sitting at the kitchen table kicking this stuff out, there really isn't a methodology of coding as such. Just a vision, and a driving desire to make it a reality. That's what makes Propits cool.
As I said before, the industry tends to stop developing its coders past the level of "Here's how we do business, now go do it". I understand this. If a programmer never grows beyond that they will be able to write code that works well, quickly, and make more money for the effort. Capitalism is based on the idea of efficiency and constant production, so it makes sense to stop there. There are programmers who will say "It's not about the money. It's about the code, man", but you won't find their manager or HR rep. saying that. But there is more. There is coding for change. Meta-meta concepts that arise from the knowledge and constant use of different programming methodologies and techniques. Actual "things" that come up consistently if you are constantly writing code with certain goals in mind. I could write a book on the topic, but I won't because there aren't really words for it. Imagine writing code with the mentality of the user in mind at all times, and making the code that they never see, that never connects to any interface they use in any meaningful way, change the way they interact with the system at a fundamental level. Change the way they think about computers and their place in the world. That's Coding for Change.
Propits is an Idea for Change, half-conceived by me because of my meditations on the economy, and half-conceived by Kevin because of his other-worldly ability to express anything as math. The code is Code for Change because how it directs the flow of data fundamentally alters the flow of ideas. The only thing left is enough people using it to have that really matter. Enough people who see the value of open-hearted generous giving, and open-hearted receiving. My explorations into code now involve getting really good at all the basics, and being able to make programs that not only express themselves and their use in a basic way, but which also change the views of anyone who encounters it in such a way as to express it's value.
Until I figure that out, though, we need evangelists! :)
Check it out,
spread it around, and give us
feedback. If we get 50 people on board, nothing changes. If we get thousands on board, we have a chance.
In the end, we're going to do this regardless. We're going to do it because it's important to do. We're going to do it because we believe in it. It will work, must work, because we just won't stop (and we have contracts with people who will charge us a lot of money if we do stop). Even if it doesn't change the world, it will change the people who use it. Be one of those bright, intelligent people who understands what money is for and what economy is. All you have to do is click, and smile.
