What makes a programming language attractive and competitive? How can we evaluate its quality? There are many different aspects of this problem.

Ease of reading and writing, or: directness of the mapping between the problem in your head and the model you are creating on the computer. This can be highly domain dependent, for instance languages such as LaTeX, Matlab and R are designed with specific problems in mind and cater to users from that domain. Their limits show quickly when you try to stretch them beyond their envisioned purpose. Speaking of general programming languages, I think Python deserves to be mentioned as a language that is extremely readable and writable. It has other shortcomings though – see below. Prolog is also highly read- and writable if it suits your problem.

Runtime performance. Arguably this is one of the few reasons to bother with using C++. For the majority of programming projects though, performance is much less of a problem than one might think, especially if one considers how close the performance of many JVM languages get to C++. When programmers think about their overall productivity and effectiveness in developing and maintaining a system, C++ is often not the best choice, obviously.

Scalability to large teams. The key property here is: does the language do anything to help me, as a developer, work with code that other people wrote? Ease of maintenance may be strongly correlated with usability in large teams. An anti-pattern here is languages that allow for solving the same problem in a huge amount of ways with very variable syntax. For instance, Perl and C++ can lead to notoriously unmaintainable code if used carelessly. Some say that Scala also suffers from this problem. Basically, the language helps here if it prevents me from doing things that other developers might not expect, and that I might forget to document or communicate. This is why Gosling famously called Java a blue collar language; it restricts you enough to make teamwork quite practical. It even restricts the layout of your source file hierarchy. (Now we begin to see that some goals are in conflict with each other).

Scalability to large systems. This is related to the preceding property, but whereas team scalability seems to be mainly about avoiding the creation of code fragments that surprise people other than their creators, system size scalability seems to be about avoiding the creation of code fragments that surprise other code fragments. Here one needs invariants, good type checking, static constraints of all kinds. Scripting languages like Perl and Python, lacking static typing completely, are some of the worst in this regard, since we cannot even be sure at startup time that methods we try to invoke on objects exist at all (Python).

Scalability over time (maintainability). If there is both system size scalability and team scalability, then the system is also likely to be able to live for a long time without great troubles.

Developer efficiency and rapid prototyping. Depending on the nature of the system being developed, this may depend on several different properties listed above.

Availability of quality tools. Mature runtime environments, such as the JVM, have many more high quality tools and IDEs available than a language than Ruby. Mature languages also have more compilers for more different architectures available.

These points begin to give us an idea of how we can evaluate programming languages. However, I also believe that making a good language and making people use it is largely about luck and factors outside the design itself. Just like there’s a big step between imagining and specifying an utopian society and making that social order an actuality, there’s a big step between designing an ideal programming language and achieving widespread adoption for it. We have seen a way forward though: with generalised runtime environments such as the JVM and the CLR, we may develop and deploy languages that take advantage of a lot of existing infrastructure much more easily than before. And what I hope for is in fact that it becomes even easier to deploy new languages, and that new languages are as interoperable as possible (insofar as it doesn’t constrain their design), so that we could see more competition, more evolution and more risk taking in the PL space.

But they also complicate reasoning about programs enormously. Both human reasoning and automated reasoning. Pointers allow any part of the program to have side effects in any other part of the program (if we have a reference to an object that originated there), and they make it very hard to reason about the properties that an object might have at a given point in time (since we generally have no idea who might hold a reference to it – it is amazing that programmers are forced to track this in their heads, more or less). In my effort to design my own language, multiple pointers to the same objects – aliases – have come back from time to time to bite me and block elegant, attractive designs. I believe that this is a very hard problem to design around. Aliased pointers set up communication channels between arbitrary parts of a program.

Nevertheless attempts have been made, in academia and in research labs, to solve this problem. Fraction-based permissions track how many aliases exist and endow each alias with specific permissions to access the object that is referred to. Ownership analysis forces access to certain objects to go through special, “owning” objects. Unique or “unshared” pointers in some language extensions restrict whether aliases may be created or not. But so far no solution has been extremely attractive and convenient, and none has made it into mainstream languages. (I know that someone Philipp Haller made a uniqueness plugin for the Scala compiler, but it is not in wide use, I believe.)

If we are to attempt further incremental evolution of the C-family languages, aliased pointers are one of the most important issues we can attack in my opinion.

The rate of publication has decreased. Prior to the last evaluation, 55 posts had been published – about one per week. Since then, only 22 new posts have been added. This is partly because I’ve had more academic tasks to carry out, a condition that is set to intensify gradually from here on, and partly because I tried to change my standards for what I wanted to blog about (in some vague, as of yet unspecified way).

Scala is still a very popular topic to blog about, and rightly so, but I no longer feel that I should write about it for the sake of doing so. Others do a much better job of writing about Scala than I could do, because they spend all their time more time with that language. Incidentally, I’m delighted to see that companies are still switching to Scala quite eagerly, and that Martin Odersky and others launched the company Typesafe to help others with the transition. Learning Scala has honestly been one of the most empowering experiences I’ve had as a programmer, and I believe that there is a vast space of possibilities that has yet to be explored in the language. Maybe it’s not a language for everybody (I postpone my judgment on this for now), but if it were in the hands of the right teams with the right discipline, the world would be in a better state. Also, the Scala IDE for Eclipse has been vastly, vastly improved since 13 months ago, at which time it could barely be used.

I’ve become more and more interested in philosophy over the past 18 months or so, and this started to show up in the blog during this interval, with more and more entries tentatively trying to delineate philosophical questions or positions. Initially I was focussing almost only on Nietzsche, but recently I’ve also been reading a lot of Foucault, as well as some others. I’ve probably not been very pedagogical in writing down my thoughts on these topics, but I fear I will never be a pedagogical writer unless I go through some initial struggling attempts. The ideas I’m most interested in currently are causality (I believe that we don’t understand it at all) and free will (I believe that its existence is highly questionable, but very fruitful to criticise and reason about).

Popularity. By far my most popular post has been this little note on Nomura’s Jellyfish. If I put Google adwords on just that post, I would probably make a lot of money without annoying any other readers. For some reason Google directs a lot of people googling jellyfish to this site. As if programming and philosophy are not more interesting things to Google. Other than that, the Scala posts have been very popular, and following them, Continuous computing, Type theory and Politicization of mathematics… were able to attract some attention.

From now on, until early next year, I have to focus more and more on finishing my Ph.D. studies; it remains to see how this will affect my blogging.

Hence the trouble with obtaining funding for research. In order to obtain funding, you have to communicate something that seems incommunicable without the full commitment of the reader. Grant dispensers want to know a number on a scale: “what’s the quality of this paper between 0 and 1?”, but this quality number cannot be communicated separately from the full substance of the paper and its environs. And thus we end up with keywords, catchphrases that become associated with quality for short periods of time, as a way of bypassing this complexity, an approximate way of indicating that you are doing research on something worthwhile.

This reflects a broader problem in society of evaluating authorities. I cannot evaluate my doctor’s, or my dentist’s, or my lawyer’s work, since I don’t have the necessary competence. Accordingly, I base my trust on the person and some of their superficial attributes, instead of judging the work by itself. It seems that the same kind of thing becomes necessary sometimes in choosing what researchers to fund.

It also points to a faculty that must have evolved in human being since millennia: the capacity for evaluating important properties of things we do not understand well very quickly, for danger, nutrition, etc. Only that this faculty does not translate well to research…

Now for something quite different from the philosophical entries I’ve been writing recently. We finally got the time to release the game “JTron” on Sourceforge. It is there under its new name Jtronic.

This game is designed for programming competitions; participants program an agent that plays the game by obtaining information about its environment and making decisions. The programming language is Java. The game itself combines features of Pac-man and Tron in what we think is an interesting synthesis.

This game was used for the ACM-ICPC regional contest in Tokyo 2010, for the “Java Challenge” part. I’ve had the honour to work with some great people in the Honiden lab in developing this game, and we spent time on it on and off for almost a year. A very educational process, and the final result was not bad at all.

If you can program in Java, you can have fun with this framework by programming your own agent and competing against others (including some pre-made ones that are included in the release), or you can contribute to the game framework itself, should you feel so inclined. It’s GPL licensed. The documentation is still slightly sparse, but we will release more “shortly”.

A similar framework is the “Icy Challenge” that was used in the world final ICPC Java Challenge. It has much nicer graphics than our game. Maybe someone would take the time to make 3D graphics for JTronic?

This is hopefully the start of a short series of posts in which I attempt to relate the concepts of value and value creation, in particular as they were understood by Friedrich Nietzsche, to the modern world, in some kind of way. Comments of all kinds are encouraged!

In the beginning (understood as ancient Greece), there was philosophy. That is to say, most systematic inquiry into matters worth thinking about was collected under this umbrella term. Ethics, politics, epistemology and metaphysics went side by side with physics, biology and astronomy. As millennia passed, the collective human knowledge and scholarly labour grew, and some philosophical disciplines got their own name, cut the umbilical cord, and got to stand on their own feet.

There are many definitions as to what a philosopher is; one definition would be those who study the academic subject of philosophy in academic institutions. The German philosopher and philologist Friedrich Nietzsche wrote at length about what a philosopher really is; in his definition a philosopher is someone who creates values. Nietzsche rejected morals and universal truth as laid down by a God or higher authority; instead they are created by subjective human beings, and by philosophers in particular.

Perhaps [the genuine philosopher] himself must have  been critic and sceptic and dogmatist and historian and also poet and collector and traveller and solver of riddles and moralist and seer and “free spirit” and almost everything in order to pass through the whole range of human values and value feelings [...] But all these are merely preconditions of his task: this task itself demands something different – it demands that he create values.

(Friedrich Nietzsche, Beyond Good and Evil, s. 211, Walter Kaufmann transl.)

We may understand a scholar to be a person who processes knowledge. Good scholarship entails marshalling what has been written and studied previously, perhaps with a view to settling a question or supporting a perspective. Scientists and philosophers can make use of scholars in their work. To the extent that the scholar does more than merely process knowledge, he or she is something more than a scholar.

In contrast, a scientist, as we understand him or her today, is someone who combines scholarship and primary investigation (in the form of calculation, experimentation, measurement and so on) in order to create models of nature and the world, in order to gain the power to explain. The classical scientific process involves repeated refinement of hypotheses until one that cannot be proven wrong has been found.

Today, science, which formerly was known as natural philosophy, has grown enormously large, and to most people probably appears to have much greater value than philosophy. The scientific mindset is widely appreciated and respected throughout the world — perhaps too respected. Scientists learn as one of their highest virtues to be skeptical and to reject assertions that are made without a basis in measurement or theory. Paralysis by skepticism is very much a possibility. To see the danger in this, we have to recognise that a great deal of valuable things in human history have been created without such a basis – by people who have been something like the ones Nietzsche describes.

The dangers for a philosopher’s development are indeed so manifold today that one may doubt whether this fruit can still ripen at all. The scope and the tower-building of the sciences has grown to be enormous, and with this also the probability that the philosopher grows weary while still learning or allows himself to be detained somewhere to become a “specialist” – so he never attains his proper level, the height for a comprehensive look, for looking around, for looking down. [...]

Indeed, the crowd has for a long time misjudged and mistaken the philosopher, whether for a scientific man and ideal scholar or for a religiously elevated, desensualized, “desecularized” enthusiast and sot of god. And if a man is praised today for living “wisely” or “as a philosopher”, it hardly means more than “prudently and apart”.

(Friedrich Nietzsche, Beyond Good and Evil, s. 205, Walter Kaufmann transl.)

In fact, scientists today do not, in my experience, work like the ideal scientist described above. Scientists often use their own judgment and their own values in order to influence how their science is to be used. Einstein and Oppenheimer had opinions about the use and misuse of the nuclear bomb. Creators of vaccine may have opinions on how it is to be distributed and may be able to influence this. Sometimes these value statements made by scientists are pure judgments, applications of an ethic that the scientists already believe in. However, sometimes the situation is so new that the scientists effectively have to create values. To the extent that they do this, these scientists dabble in ethics, morality and philosophy, but this is often overlooked, as is the fact that scientific method itself was created by philosophy.

Nietzsche calls for philosophers to make use of scientists and artists, and create values in the service of mankind. He calls for a new recognition of the true role and dignity of philosophy, which does not at all need to mean a reduction of the value of science, but rather an expansion of the whole system. Philosophy stands naturally above science and scholarship and uses them as its tools. The activity of creating values based on philosophical insight by necessity goes on constantly and should not be confined to little nooks in the margins of society. The full extent of and need for this activity needs to be acknowledged.

Has the situation changed since Nietzsche wrote Beyond Good and Evil in 1886?

Type theory was invented by Bertrand Russell as a solution to his own well-known paradox, which cast doubt on the foundations of mathematics upon its discovery.  The problem posed by the paradox is essentially: given a set of all sets that do not contain themselves, does that set contain itself? Another interesting problem arising from self-referentialism. Type theory resolves this issue by classifying the members of sets according to some type, and in such a system a set definition like this one is not permissible.

(The drama surrounding Russell’s paradox and Principia Mathematica can now also be read in the form of a “logicomix” graphic novel by Doxiadis et al!)

Type theory did not end its life as a metamathematical hack that solved a set theoretical problem. It has now come of age. Type systems are, of course, at the heart of the development of many modern programming languages. Java, C#, Lisp, ML and Haskell are but a few of the ones that depend completely on a nontrivial type system. (Even though C and C++ have type systems, they are kept in a crippled state by the fact that the programmer is allowed to ignore their commandments at will.)

What is the benefit of a type system in a programming language? In the words of Benjamin Pierce,

A type system is a syntactic method for automatically checking the absence of certain erroneous behaviors by classifying program phrases according to the kinds of values they compute.

So, generally speaking, a type system helps distinguish correct programs from incorrect programs. The parser also does part of this job, of course, since many programs that cannot compile will not parse. But there are programs that are syntactically correct but at the same time semantically unsound according to the evaluation rules of the language. Consider the following Java statement:

T x = new U();

This is clearly syntactically acceptable, but is it semantically valid? In order for it to be, either U needs to be the same type as T, or a subtype of T. But Java programmers are free to define new subtypes of existing types in source code. In order for the parser to check the correctness of the assignment, it seems that either the grammar would become enormously large, or it would place awkward restrictions on Java syntax. So we leave more refined aspects of correctness to the type checker, which is applied later, post-parsing.

What does a type system look like? As used in programming languages today, a type system consists of a set of typing judgments. The judgments can be stacked together to form the typing derivation of an expression in the language. Every expression normally has a unique typing derivation, and when a type can be derived, we call the expression well typed. As Benjamin Pierce’s formulation suggests, each typing rule makes some assumptions about the kinds of values that constitute the various parts of an expression, and then says something about the kind of value that will be computed by the expression as a whole.

Type systems can look prohibitive at first sight, since they use quite a few algebraic symbols. But in general, the structure and interrelationships between the symbols is the most important thing to discern from them, and focussing on this aspect makes reading them much easier.

In the following mini-type system, typing judgments will have the form , where is a typing context, is a term, and is a type. Terms are essentially fragments of the source code, and from smaller terms we can construct larger terms using syntactic forms. So for example, if a, b and c are terms, then we might use the if-syntax to construct the larger term

if (a) {b} else {c}

in a java-like language. The typing context is essentially just a map, mapping already typed terms to the types assigned to them. As we type increasingly large terms, we gradually add more information to the typing context. The symbol is just notational convention and has no particular meaning. The judgment is read as “term t has type T in typing context “.

A fragment of a minimal system might look like the following.

Three typing rules have been introduced here, T-ASGN for assignments, T-IF for if-statements, and T-BINOP for binary operations on integers, like + and -.
Every rule has the same structure: above the line, assumptions that must hold true for the rule to be applied; below the line, the conclusion we may draw if the assumptions are true.

Above, the following example was given.

T x = new U();

Using T-ASGN, we can type an assignment statement like this one. The assumption T <: U says that T is a subtype of U. We have also assumed a lookup function vartype which gives the declared type of the variable we assign to. In English, we can read the rule T-ASGN as saying: “Assuming that the type of the right hand side is a subtype of, or the same type as, the declared type of the variable, the assignment will evaluate to a value that has the declared type of the variable”. Of course not all programming languages implement assignment in this way.

In the T-BINOP rule, we must of course substitute an actual operation on integers for the special word intBinop for it to be valid. For addition, the rule can be read as “Assuming that the left hand side and the right hand side are both integers, then the result is also an integer”.

Finally, the T-IF rule says “assuming that the truth condition is a boolean, and that the two alternative paths have the same type, then the if-statement evaluates to the same type as that of the two conditional paths”.

The shape of the type system follows the evaluation rules for the language quite closely, so that a well-typed term is also always possible to evaluate. We can thus avoid accepting programs that might get stuck without any valid evaluation rule at some point. (Consider what happens in Python if you try to invoke a method on an object, and the object doesn’t have a method with that name.) We are not limited to tracking just the kinds of values being computed in a type system. We can track various kinds of safety properties, such as memory regions being violated, as well, or we may track multiple properties at once. Type and effect systems is one way of tracking both values being computed and resource violations.

A good source of more information on type systems applied to programming languages would be Benjamin Pierce’s Types and Programming Languages.

But of course they reside somewhere. Cables and machines embody the apparition that users interact with, and these cables can be found and cut. The machines can be shut off. Traceroute tells me which path the data is taking. But the thread that binds the body to the spirit is thin, and the two evolve in a largely independent manner.

With cryptographic methods, such as the I2P network, it is possible to hide the exact location of a system, disperse it across the fabric so widely that it cannot be excised without destroying the fabric itself.

The effect is the same as if the system had no physical existence at all. It now exists in a kind of spiritual realm, where it can only be touched with great difficulty.

Various technologies have come out of academic experiments, volunteer work and government sponsored research to assist with encrypted communication. PGP/GnuPG and SSH are classic mainstays. Onion routing, as implemented in the TOR system, is an effective way of concealing the true origin and destination of data being sent around. Darknet systems like the I2P project aim to build a complete infrastructure for an entirely new kind of Internet, piggybacking on the old one but with anonymity and encryption as first class fundamental features.

I think we are only at the start of a coming era of political conflicts centered around communications technology, and that more and more issues will have to be ironed out in the coming years and decades. The stakes are high. On one hand control and political stability, on the other hand individual rights and democratic progress. This is not new. One thing that I think is potentially new and interesting though, is how mathematics and computer science ought to become increasingly sensitive and political in the coming years.

Today disciplines like genetics and stem cell research are considered controversial research areas by some people since they touch on the very foundations of what we think of as life. Weapons research of all kinds is considered controversial for obvious reasons, and the development of a weapon on the scale of nuclear bombs would completely shift the global power structure.  One fundamental building block of communications control is the ability to encrypt and to decrypt. These abilities are ultimately limited by the frontiers of mathematical research. Innovations such as the Skein hash function directly affect the cryptographic power balance.

Most of the popular varieties of encryption in use today can be overcome, given that the adversary has sufficient computing power and time. In addition, human beings often compromise their keys, trust the wrong certificates, or act in ways that diminish the security that has been gained. Encryption is not absolute unless the fact that something has been encrypted has been perfectly hidden. Rather, it is a matter of economics, of making it very cheap to encrypt data,and very expensive for unintended receivers to decrypt it.

It is not possible to freeze encryption at a certain arbitrary level, or to restrict the use of it. Computers are inherently general purpose, and software designed for one purpose can almost always be used for another. If the situation is driven to its extreme, we might identify two possible outcomes: either general purpose computers are forbidden or restricted, or uncontrolled, strongly encrypted communication becomes the norm. Christopher Kullenberg has touched on this topic in Swedish.

Those who would rather not see a society where widespread encryption is commonplace would perhaps still want to have what they see as desirable effects of computerisation. In their ideal world they would pick and choose what people can do with computers, in effect giving a list of permitted and prohibited uses. But this is not how general purpose computers work. They are programmable, and people can construct software that does what they want. If the introduction of non-authorised software somehow is prohibited, and all applications must be checked by some authority, applications can still usually be used for purposes they were not designed for. This generality of purpose simply cannot be removed from computers without making them useless – at least that is how it seems today. It seems that it would take a new fundamental model of computation that selectively prohibits certain uses is needed in order to make this happen. (In order to make sure that this kind of discovery is not put to use by the “other camp”, those of us who believe in an open society should try to find it, or somehow establish the fact that it cannot be constructed.)

Mathematics now stands ever more closely connected with political power. Mathematical advances can almost immediately increase or decrease the resistance to information flow (given that somebody incorporates the advances into usable software). The full consequences of this are something we have yet to see.

One of the first schools of thought he brings up is utilitarianism, whose central idea appears to be that the value of an action is placed in the consequences of that action, and not in anything else, such as the intention behind the action, or the idea that there are certain categories of actions that are definitely good or definitely evil. What causes the greatest happiness for the greatest number of people is good, simple as that. From these definitions a huge amount of difficulty follows immediately. For instance, is short-term happiness as good as long-term happiness? How long term is long term enough to be valuable? Is the pleasure of ignorant people as valuable as that of enlightened people? etc. But let’s leave all this aside and try to bring some notion of computability into the picture.

Assume that we accept that “the greatest happiness for the greatest number of people” is a good maxim, and we seek to achieve this. We must weigh the consequences of actions and choices to maximise this value. But can we always link a consequence to the action, or set of actions, that led to it? Causality in the world is a questionable idea since it is a form of inductive knowledge. Causality in formal systems and in the abstract seems valid, since it is a matter of definition, but causality in the empirical, in the observed, seems to always be a matter of correlation: if I observe first A and then B sufficiently many times, I will infer that A implies B, but I have no way of knowing that there are not also other preconditions of B happening (for instance, a hitherto invisible particle having a certain degree of flux). It seems that I cannot reliably learn what causes what, and then, how can I predict the consequences of my actions? Now, suddenly, we end up with an epistemological question, but let us leave this too aside for the time being. Perhaps epistemological uncertainty is inevitable.

I still want to do my best to achieve the greatest happiness for the greatest number of people, and I accept that my idea of what actions cause what consequences is probabilistic in nature. I have a set of rules, A1 => B1, A2 => B2… An => Bn which I trust to some extent and I want to make the best use of them. I have now ended up with a planning problem. I must identify a sequence of actions that maximises that happiness variable. But my brain has limited computational ability, and my plan must be complete by time t in order to be executable. Even for a simple problem description, the state space that planning algorithms must search becomes enormous, and identifying the plan, or a plan, that maximises the value is simply not feasible. Furthermore, billions of humans are planning concurrently, and their plans may interfere with each other. A true computational utilitarian system would treat all human individuals as a single system and find, in unison, the optimal sequence of actions for each one to undertake. This is an absurd notion.

This thought experiment aside, if we are utilitarianists, should we enlist the increased computing power that has recently come into being to help manage our lives? Can it be used to augment (presumably it can not supplant) human intuition for how to make rapid choices from huge amounts of data?