Philosophy, Technology

John Searle wrongs Computer Programs by denying them the Possibility for Consciousness

This is a great talk, go watch it first. I agree with everything John Searle says, except for his point that a computer program without special hardware can never claim to be conscious.

At 5:10, he says: “All of our conscious states, without exception, are caused by lower-level […] processes in the brain, and they are realized in the brain as higher-level or system features.” He continues: “[consciousness is] the condition that the system is in.” And I agree. But why does he think the same cannot be true for computer programs? Isn’t software “the condition (the state of the bits) that the system (the hardware) is in”?

At 11:00 he goes on claiming that a computation (i.e. manipulating symbols) is only about syntax, while consciousness is also about semantics. It seems that he defines semantics as what arises when symbols are interpreted by consciousness, and I’m fine with that. This however, leads to a circular argumentation when claiming that a computer program cannot have consciousness since it doesn’t possess any intrinsic semantics. Let’s say that semantics arise when symbols are interpreted by a consciousness. Who is to say that a complex computer program cannot do that interpretation just as validly as a human mind can? In a way, he wrongs the computer program exactly in the same way as the materialists wrong him when they tell him: “we’ve done a study of you, and we’re convinced you are not conscious, you are a very cleverly constructed robot.” The computer program might reply, just as he does: “Descartes was right: you cannot doubt the existence of your own consciousness.”

Philosophy, Technology

iOS 7’s Redesign

When the iPhone debuted, it set the standard for a lot of things, among them the GUI of a touch-based mobile operating systems. But that was in 2007, and the design of iOS has gotten a bit stale and heavy by today’s standards. Some even say that “iOS is the Windows XP for mobile devices” – its familiarity is loved by so many that it’s going to be hard for Apple to make radical changes. But yesterday, Apple did just that: it introduced iOS 7 which finally brings a clean redesign of the whole GUI, while keeping all the elements at their familiar places. So, is it any good?


I don’t care much for the new App icons, the rounded corner radius is too large and the Safari icon in particular is just gross. Also, the default home-screen image is reminiscent of some 70s bling, which turns especially awful when seen through a translucent panel; fortunately that image can be swapped out by the user.

But other than that, I like the redesign. It really shines in the Apps as well as the Notification and Control Centers: no visual clutter or heavy chrome, a smaller and crisper color palette, and carefully chosen whitespace and typography. The translucent navigation areas place them clearly on a layer above the content (when scrolling in Safari or playing a movie, they even slide unobtrusively out of sight). The Apps in turn are above the background image, on which the parallax effect is used to form a sort of three dimensional box to peek into.


The new design is not “flat” (whatever that means), but it’s streamlined. And while removing visual clutter always comes at the risk of harming discoverability, I think iOS 7 didn’t go too far. Buttons may be gone, but the interaction elements are at the familiar consistent places and if it’s blue text (or in some Apps red, but always looks like a link) or a wireframe icon, the user knows it’s save to tab.

Everyone should choose a better home-screen image, Apple fix the icons, and then iOS 7 is a solid foundation to improve upon.

Society, Technology

Making a Dent in the Universe

Leadership is the art of getting someone else to do something you want done because he wants to do it.
– Dwight Eisenhower

We all strive to make our dent in the universe. And while too much concentrated power is certainly a bad thing, nobody wants to be entirely powerless.

If power is the ability or capacity to influence the state of the world, then being able to influence the physical world (stones, trees, rivers) may be the primary form of power. The archetypal lone cowboy is always certain to have enough power to provide food for himself and defend himself. But influence over the physical part of our world is a rather crude form of power, compared to the ability to influence the social part of our world – people.

Technology is usually primariliy considered in its capacity to influence the physical world (e.g. building a dam) rather than the social world. But since the invention of mass media technologies – starting with the printing press, then radio, television and now the internet – this has changed a lot. While not requiring all the same skills as mastering other kinds of technology, mastering a certain communications medium (e.g. writing books, blogs or filming) has become a very effective skill in influencing the world. Even more so in the highly connected and collaborative world we live in today.

A very simple form of the ability to influence people is “getting them to do what you want them to”. There seem to be mainly two strategies to this end. Either, you convince them that your idea is so great that they voluntarily invest their time in its support, or you simply pay them to do so. Or you do both.

In an industrialized society, where every year a larger part of the simple mechanical work can be done by machines, your are dependent upon motivated people that don’t simply execute what you paid them for, but actually understand and believe in your idea and want to actively be part of making it a reality. But in our current society, people also need money to get by.

So you’d think convincing them of your idea and paying them at the same time would be the smartest thing to do. But alas, whenever you introduce money as a motivator, things get more complicated. The warm and fuzzy feeling people get when doing some good for free might fade, you have to decide whether to give some people more money than others, etc.

So what do you do? It might very well be that either the state will provide a basic income to all its citizens, or that companies will do so for their employees – as long as they seem to be doing something broadly in the interest of the company. In the meantime, you can hope to find or found a company doing something close to that, or roll your own and look for some crowd funding.


Parallel and Concurrent Programming Models

This is a simple (non-exhaustive) categorization of different approaches for parallel and concurrent programming, inspired by Parallel and Concurrent Programming in Haskell (PDF). They state that parallelism and concurrency are two solutions to two different problems (as do others).

  • Parallelism (i.e. data parallelism, is deterministic)
  • Concurrency (i.e. threads or task parallelism, is nondeterministic thus cannot be expressed in purely functional code)
    • locking shared resources
    • blocking/synchronous channels (e.g. CSP) and asynchronous message passing (e.g. Erlang)
    • cancellation: asynchronous exceptions
    • software transactional memory (STM), i.e. group code into atomic blocks

Instead of concurrency, event loops with callbacks (as in Node.js) can be used to solve the problem of multiple external agents interacting with each other.

The paper also notes:

In the world of concurrency and parallelism, there is good reason to believe that no one size fits all programming model for concurrency and parallelism exists, and so prematurely committing to one particular paradigm is likely to tilt the language towards favouring certain kinds of problem.
We might wonder whether the compiler could automatically parallelise programs for us. After all, it should be easier to do this in a pure functional language where the only dependencies between computations are data dependencies, and those are mostly perspicuous and thus readily analysed. In contrast, when effects are unrestricted, analysis of dependencies tends to be much harder, leading to greater approximation and a large degree of false
dependencies. However, even in a language with only data dependencies, automatic parallelisation still suffers from an age-old problem: managing parallel tasks requires some bookkeeping relative to sequential execution and thus has an inherent overhead, so the size of the parallel tasks must be large enough to overcome the overhead. Analysing costs at compile time is hard, so one approach is to use runtime profiling to find tasks that are costly enough and can also be run in parallel, and feed this information back into the compiler. Even this, however, has not been terribly successful in practice [Harris and Singh]. Fully automatic parallelisation is still a pipe dream. However, the parallel programming models provided by Haskell do succeed in eliminating some mundane or error-prone aspects traditionally associated with parallel programming.


Haskell, XQuery, JavaScript or Opa for web development

This is a follow up on a previous post of mine, XQuery, Node.js and Opa – which is the “new Java” of web development?. So here comes the table…

Haskell XQuery JavaScript Opa
Purely functional as pure as it gets not so pure but mostly functional cumbersome to write functional code not pure but functional
Statically typed yes yes no yes
integrates well with a database with RDMSs (via HaskellDB) and with a native Haskell store called acid-state with XML-DBs with MongoDB or CouchDB with MongoDB or CouchDB
Web server good good, e.g. Sausalito or eXist Node.js e.g. Node.js
Web client (browser) experimental Haskell to JavaScript compilers experimental, see XQuery in the Browser great (native) good (compiles to JavaScript)
GUI code executed seamlessly on client and server no no yes, using Meteor or Derby yes, integrated
Templating system yes, e.g. HStringTemplate not that I know of yes, e.g. Handlebars yes
Parallelism and distribution wide range of facilities for parallelism, maybe less distribution on multiple servers? current implementations spawn a new process for each request, inside that no parallelism afaik requests handled by the Node.js event loop which is non-blocking but unfair and starving. Inside WebSockets can be used uses Node.js, but automates distribution

… and now some explanations. Keep in mind that these are my research notes, I’m no expert (yet ;)).

This started when I was thinking how nice a language Haskell was, purely functional, monads, lazy evaluation and a rich static type system. What more can you ask? Going from top to bottom in the table, unfortunately Haskell doesn’t integrate that well with NoSQL databases as XQuery and JavaScript do with XML databases and MongoDB respectively. When you have to use a different language to query your database than what you use for the application tier, you have an impedance mismatch: you have to convert all the data back and forth and have to think in different ways depending on what tier you’re on as well as having to decide what should be handled in what tier. A similar impedance mismatch arises when you have to use a different language on the client-side (i.e. the browser where we’re stuck with JavaScript) and on the server side. Ideally, you write your GUI code once and it is transparently executed either on the server (upon the initial page load) or on the client (upon further navigation by the user). To pull this off, it seems to help a lot to have a templating system which also separates presentation and computation/business logic. Finally, it would be nice if you could easily (and without introducing hard to find errors) parallelize your code to run on multiple cores of a machine as well as distribute it to run on a cloud. Maybe I’ll have to look at Clojure or Erlang for that as well.

Opa seems to do a lot of things right, the question is how it fares in practice and also how open its application stack really is. For Haskell, we’ll have to wait until it compiles properly to JavaScript, and I’ll have to look at whether there is a database that performs and integrates well with Haskell, otherwise it seems to rule (except that it’s hard to learn). XQuery seems well suited for large amounts of XML data and JavaScript is pretty easy to learn, so it might become the new (concurrent) PHP. So, we’ll see… 😉


XQuery, Node.js and Opa – which is the “new Java” of web development?

I know it’s dangerous to draw conclusions from analogies, but what are we supposed to learn from, if not from the past?

This was before my time, but from what I gather, the programming language and development environment Smalltalk failed because the competitor Java came along which borrowed a few concepts from Smalltak but additionally had…

  • a C-like syntax that was familiar to almost all programmers
  • applets to run the code in the browser,
  • free (initially as in beer) development tools provided by Sun, and
  • is statically typed.

As of today, Java is one of the most widely used programming languages in a variety of domains, taught in schools and universities and known by every respectable software developer. Although Java applets in the browser were since displaced by first Flash and more recently HTML5+JavaScript.

The web as a platform is only gaining in importance and everybody is waiting for the “next big thing”. A language that could be used through all three tiers of web development: database queries, server-side programming, plus client-side programming of the browser. There are a number of contenders, such as Opa, XQuery (e.g. using Sausalito which uses Zorba) and JavaScript (e.g. using MeteorDerby or SocketStream which all run on the Node.js server). But which one, if any of those, will ensue to be the dominant one, the “new Java”?

Since the only language that is supported by all major browsers on all major platforms is JavaScript, we’re pretty much stuck with it on the client side. (I think it’s rather doubtful that Google’s Dart will catch on). So whatever language will win, will necessarily need to compile to JavaScript – or be JavaScript.

So how do they compare through the lens at the analogy with Smalltalk and Java? While XQuery and Opa are statically typed which is an advantage in my opinion, JavaScript scores high in having…

  • a C-like (and by extension Java-like) syntax that is still very familiar to almost all programmers (and those that don’t like that can still use CoffeeScript),
  • native support in the browser,
  • free (as in freedom and as in beer) tools and libraries.

Zorba is also distributed under the permissive Apache license, but it is not even a complete Application Server. Opa is available under the GNU Affero General Public License which requires any provider making use of it to open source his code as well. On the other hand, Node.js, Meteor, Derby and SocketStream are all available under the permissive MIT license which make them even more free (in the sense that you don’t have to contribute back to the community if you don’t want to).

So if history is any indication, JavaScript might have an edge over the other contenders. What do you think? Which one (or what other language/tool set) will win?

Society, Technology

Why do some people hate Apple

I just entered “why consumers should care about design” into Google, excluding results about health care and what I stumbled over was not exactly what I was looking for, but interesting nonetheless. It was this article by The Guardian: Why do some people really hate Apple? The author writes:

Buying or using products that engage our emotions strongly will inevitably alienate those who don’t share those emotions – and just as strongly.

This may well be true. But the article doesn’t go on to ask why this is the case.

Many (but not all) people having used an Apple product for some amount of time fall in love with it one way or another. There is something catchy about those beautifully designed products. While touching and interacting with them they connect with something deep within us. And the longer you use your iPhone, carrying it with you every day wherever you go, the more personal your relation with the device becomes.

So why is it that people not using and not owning such a product react almost equally as strong in the opposite way? Why do some people hate Apple and all their products? Are they simply jealous? I don’t think it’s that simple. I think that when you buy a new Apple product your non-Apple-using friends feel similar to when they would see you falling in love with somebody they think is not good for you. That new flame who is only after your money, for example. They see you acting irrationally and falling prey to an evil force that persuades you of buying expensive products that aren’t any better than all the others. What they don’t see is all the joy you are having with your new love.

On a more rational note, do I think it makes sense to buy Apple products? An often voiced criticism is that they are expensive toys that actually can do less than their mundane counterparts. It is probably true that you can think of a few things that you cannot do or at least cannot do as easily with an Apple product as with that of another manufacturer (like moving your music files to your iPhone without using iTunes). But the things you want it to do 99.95% percent of the time it does splendidly on the other hand. By not incorporating some exotic features Apple is able to offer a very streamlined design with few distractions. It is intuitive and efficient to use, letting the user easily accomplish his goal without forcing him to think about all the technology that enables his experience.

But of course there are also those restrictions that do not only serve the simplicity of the product but are mostly there to increase Apple’s profit. And I hate those just as much as everybody else. But the sad truth is that at the moment there are no other computers or phones that are designed as well as Apple’s. And by design I don’t just mean that they look beautiful and stylish. By design I mean the process of the people creating the product pushing themselves to improve it again and again and again. Thinking carefully about the best solution, questioning every tiny detail – is it really necessary? – making the device from hardware to software as simple and enjoyable to use as humanly possible thus saving millions of people countless hours of frustration.

I think design is important. But so is open source and freedom. Right now, there is this trade-off and everybody has to choose for himself where to draw the line.