Arc tries to be a language that's dirty in the right ways. It tries not to forbid things, for example. Anywhere I found myself asking "should I allow people to...?" I tried always to say yes.

Paul Graham has just released in the last days the first version of Arc, a language he is designing not only to be a better Lisp but also to unleash the hacker way of good programming.

Here is a summary of the polemic characteristics of Arc:

In fact, Arc embodies just about every form of political incorrectness possible in a programming language. It doesn't have strong typing, or even type declarations; it uses overlays on hash tables instead of conventional objects; its macros are unhygienic; it doesn't distinguish between falsity and the empty list, or between form and content in web pages; it doesn't have modules or any predefined form of encapsulation except closures; it doesn't support any character sets except ascii. Such things may have their uses, but there's also a place for a language that skips them, just as there is a place in architecture for markers as well as laser printers.

Paul talks about what he considers the dirty way of good programming, that means a language that restrains the programmer the less it is possible, yet with powerful mechanism of saying a lot with a few words.

He talks about once have thought that structures with, for example, typed fields where really necessary but he no longer fells that way. He says that the completely loosed couple structures like Lisp lists (any number of elements, without named fields and of any type) are the best option for what he tries to define as exploratory programming

There's a similar opposition between the use of lists to represent things and the use of "objects" with named, typed fields. I went through a stage, after I'd been programming in Lisp for 2 or 3 years, where I thought the old way of using lists to represent everything was just a hack. If you needed to represent points, surely it was better to declare a proper structure with x and y fields than to use a list of two numbers. Lists could contain anything. They might even have varying numbers of elements. I was wrong. Those are the advantages of using lists to represent points.

And he states:

The most important thing is not to constrain the evolution of your ideas. So the less you commit yourself in writing to what your data structures represent, the better.

I think the comments above pretty much illustrate the programming school behind this new language, and I must say that, besides adopting a totally different way of programming, I do respect this different approach or paradigm and I'll try to watch closely the Arc evolution.