RPython and Economics


I want to draw your attention to a highly technical topic: RPython. In doing so, I wish to expound why economics is best when government stays out of the way and only applies general, well-defined and fair rules.

First, definitions to get you up to speed.

A compiler is a special computer program that takes code written in one language and compiles it into another language. Generally, when we talk of compilers we’re talking of programs that start with code written in a language humans can understand being compiled into the code that microchips use to do real work.

An interpreter is a computer program that behaves somewhat like a microchip, by accepting code written for the interpreter and executing each tiny action one after the other.

Generally, interpreted languages are much, much slower than compiled languages, but they have the benefit of running on a wide variety of systems small and large.

“Python” is a computer programming language. It’s also a project and a community.

“CPython” is the dialect of the Python language that the main Python project supports. It’s written in a language called “C” and is an interpreted, not compiled language.

“RPython” is a dialect of Python that is readily compiled. There are different versions each with their own unique rules, but the dialects are much more similar to each other than with CPython. There are significant differences between CPython and RPython, but they are small enough that it’s still roughly Python.

The PyPy project was hatched to try and write a Python compiler in Python itself. They ran into a roadblock. CPython was simply too hard to compile, and thus, run faster than the interpreted version. Other projects have tried similar things with the same result. Hence, they took some time to change CPython slightly to do what they wanted. Thus, RPython was born. Or rather, 5 or 6 different versions of RPython were born, each being similar to each other.

Does it sound chaotic to you? Good. This kind of stuff is very confusing and only a handful of people in the world really understand enough about it to make any sense of it. Myself, an avid Python programmer (CPython, actually) haven’t been able to do much more than poke around and look at the various goings-on around RPython.

Now, this core group of hard-working and interesting people have been, for the most part, duplicating each other’s work and banging on the same problems. Some have slightly better solutions, others do not.

The important thing is that people are allowed to try what they want, at their own expense. Some investors came along and threw money into the pot, and at one point someone got a grant from the EU to pursue PyPy and thus RPython.

Today, I read this email thread in the Python discussion mailing list: Standardized RPython – it’s time. It appears that some people think that by standardizing RPython, the various implementations can benefit from each other’s work to some degree or another.

Now, we see this kind of thing all the time in the real world. Who doesn’t want some kind of order in our economic system? Who wants to go to the grocery store and see 500 different kinds of cheese that are indistinguishable from one another? I mean, some standardization is important if we simply want to do anything at all.

But what’s interesting is that we don’t need government to set these kinds of standards, and in fact, it’s probably a really good idea not to. In this case, some of the PyPy developers think that they may make some more changes to their RPython language, so standardizing would be a waste of time and may actually hurt their progress. They have a point.

Really, the only person who can decide whether to adhere to a standard or not are the people themselves. You can’t dictate what standards apply and how to apply them. You can, at best, offer a standard and see if people like to use it.

When we have a government authority set a standard that must be followed on penalty of fine or imprisonment, we are really hurting ourselves. There are some people that may have something beneficial to offer us that don’t adhere to the standards. We may not even choose the right standards to begin with!

In my mind, there are some things government must do, some things it is good at doing but doesn’t necessarily have to, and other things it does which it most likely shouldn’t do.

It’s high time we stopped behaving and voting like government is always right and the free market is always wrong. We should carefully consider moving back to earlier times by allowing markets and individuals to choose which standards they want and keep government confined and limited to those things which it is best at doing.


2 Responses to “RPython and Economics”

  1. Tim Parkin Says:

    I sort of agree but without a the form of government that is the EU, pypy would not have existed in it’s current state. A free market would never have developed pypy (there is no money in it). Totally agree on the fact that top down dictation of standards is a bad idea though – a good democratic government (which we don’t have) would allow people to decide that though :-)

    • Jonathan Gardner Says:

      You’re absolutely right that the EU invested in PyPy and PyPy owes its success to that.

      The EU also has looser laws with IP surrounding software, making it a place where innovation is slightly more likely to occur.

      I think my original point stands, though. If we allow government to set rules for all aspects of our lives, then we will lose our innovative capacity. People are much better at governing themselves and forming rules between themselves than the government is.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: