Keyboards were invented for typewriters. Typewriters are mechanical machines used by humans to avoid handwriting. Since the first typewriters were invented somewhere around the 18th century, they were rather clumsy, and the machinery used wasn’t really working too well, which is why something as awkward as the QWERTY-layout was invented. The QWERTY-layout, still used today, had its justification in the fact that early typewriters had problems when adjacent keys were used simultaneously, which lead to those keys blocking each other. At this point, in the year 1867, keyboard innovation stalled. No real invention has ever had an effect on any keyboard that is widely used until today. There have been some, like the Dvorak layout, a proposed alternative to the QWERTY-layout, but none of these made it’s way to the mainstream, unfortunately.

Today, we are using beautiful, ultra-turbo-high-speed computers that are still equipped with QWERTY-keyboards. And the nonsense doesn’t stop here, we even shrunk those keyboards down to create digital equivalents. This is just ridiculous. I am in no way doubting that a trained writer can actually write fast using an iPhone, iPad or Android Keyboard, but the reason is certainly not the superior design of those keyboards, but our ability to adapt to even the worst of circumstances.

Of course, numerous attempts have been made to improve the typing experience by adding suggestions, which is done on both Android and iOS, and by invisibly changing the “Hit Box” of each key, which is also done on both platforms. I have done qwerted, which did that highlighting both extremely and visually. There have been similar attempts to do this by Thickbuttons, and maybe some others. IBM recently filed a patent that deals with arranging the keys on a touch keyboard to adapt to a specific user, certainly interesting. But it just masks the fact that this approach is seriously flawed, as it still relies on the basic QWERTY-pattern, instead of something better.

Another approach that has become quite popular lately is the Swype‘s approach. When using Swype ( or SlideIT, and there are certainly a few other similar apps for all systems except stock iOS ), the user just moves over the keys the input consists of. Their homepage has some demo videos if you are curious. Again, the foundation is the old-school QWERTY-keyboard, and even though this concept is highly interesting and working reportedly very well, I consider it broken by design.

The question is: why are we wasting a huge amount of screen real estate displaying keys that won’t ever be typed ( or touched over ) ? Take for example Q and X. Those keys are so rarely used after a word has started, it’s unnecessary that they are displayed by default. But it’s getting better: We can even predict very reliably which words are likely to be typed even after a few words or letters have been typed. If you don’t trust me on this one, you should try Google Scribe. The techniques used here are based on n-grams ( at least a part of it ). N-Grams describe a set of n words, which can then be evaluated in terms of probability. Google has extracted a huge set of n-grams from their datasets which can be obtained at the LDC.

Someone must have come up with a great idea to revolutionize touch input. Like, not some fancy new feature, no, a completely new approach. Do you know Dasher? Something like that, of course massively polished.

I hope you are getting my point here, and I’m sorry I don’t have anything more to offer but a few entry points if you want to read further. This is really interesting field and, if time allows, I’d like to do some work here. What are your ideas?

I am currently developing a Proxy app that visualizes requests and gives you the ability to plug-and-play like filter and modify requests, which makes it a quite powerful tool for debugging web applications, mobile apps and so on.

Of course, this tool is built using Cocoa and Core Foundation. Interesting enough, Core Foundation brings a Type called “CFHTTPMessage”, which handles a lot of low-level message parsing and processing, and is really handy and quite easy to use.

There is one drawback: CFHTTPMessage is not designed to handle both the order in which the headers arrived in a message and duplicate header fields. The first point is somewhat irrelevant, as the HTTP1.1 standard points out that servers are not supposed to depend on any order in the clients – it’s really only a minor issue. The latter point is complicated. HTTP relies on duplicate headers a lot, consider this HTTP request ( Real life!! )


POST /wp-admin/admin-ajax.php HTTP/1.1
X-Requested-With: XMLHttpRequest
Accept-Charset: ISO-8859-1
Accept-Charset: utf-8;q=0.7
Accept-Charset: *;q=0.3
Accept-Encoding: gzip,deflate,sdch
Content-Type: application/x-www-form-urlencoded
Origin: http://momo.brauchtman.net
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1
Cookie: word
Cookie: wordpress_xxxxxxxx
Cookie: wordpress_logged_in_xxxxxx; httponly; expires=Tue
Referer: http://momo.brauchtman.net/wp-admin/post-new.php
Host: momo.brauchtman.net
Accept-Language: de-DE
Accept-Language: de;q=0.8
Accept-Language: en-US;q=0.6
Accept-Language: en;q=0.4
Accept: */*
Content-Length: 1160


There are quite some duplicates here. So the clever guys at Cupertino just forgot to handle duplicate headers at all? No, not really. But they just didn’t document what they are doing with it, which isn’t that clever at all, but fortunately, the sources are available here. So after a bit of digging, I found out that duplicates are simply appended to a former header with same key, which sucks – the delimiter used is a simple comma, which is quite regularly found in header values, which makes splitting an art for itself.

Diaspora, the self-claimed privacy aware, personally controlled, do-it-all, open source social network. let’s examine each of those ambitious claims one by one.

Privacy aware. The question here is really: can a network be privacy aware? Is an infrastructure even able to make such promises? As long as this promise is just written, it makes only little sense to me, as privacy is most often not a question of the protocol or idea running a service, but rather of it’s implementation and mostly dependent on its users.

Personally controlled? Facebook is also controlled by it’s users. The problem is actually not control in the net itself, but control towards additional use of your data, e.g. for advertising or some other third party stuff. Again, a protocol or idea won’t be able to change that problem. Just by allowing a net to be just that, there is still a considerable chance of data being accumulated by one provider, like facebook, again. And, as long there is some data concerning you on a database server that is not exclusively administrated by you, your data is not personally controlled.

Do-it-all. I’d rather not comment on that one. But that’s what it is about here. Do-it-all. If it sounds too good to be true, it’s not. Doubtlessly, those smart guys are ambitious and gifted ( at least concerning PR ), but do-it-all is a bit.. over the top. Small steps. Just develop one application, show it, next one. It’s okay and cool and I really appreciate that the protocol can be used for anything, but that also implies complexity. And time.

Open-source. That’s just fine, but at the moment, it’s not. Neither the sources they’re working on, nor the protocol, which is, of course, the more interesting part, are available anywhere. Being a programmer myself, I really understand why the project source is not available at such an early development stage, but it’s crucial for this protocol to become published, even in an early version, as soon as possible.

The protocol, the heart of diaspora, is what invites other people to read and study it. Which may have some desirable consequences: I’d like to build a diaspora node, for example. And I’m pretty sure some other people like to as well. But even more interesting are the ones analyzing it from e.g. a security perspective, commenting on it’s scaling ability or just throwing in new ideas?

Diaspora is fine. I really respect the guys running this project, they are doing a great job, right idea, right time, nothing more powerful. But still, they should really take their time to consider changing some things. Let’s create a google group, let’s share some technical details with the ( really interested ) mass, let’s communicate.

I’d define a problem worth solving as something that has 3 attributes: It is persistent, in a sense that it reoccurs too many times, that it has an impact on some activity or workflow. That is something worth resolving. Another point is the “factor of annoyance”. Remember the  Microsoft’s Paperclip? High factor of annoyance. One dialog asking for a bit of love in the form of a ok-button? Not that annoying. But keep in mind, that’s all a very subjective rating. So if you find Dialog Boxes more annoying than speaking Paperclips, just change the order accordingly.

The third factor is the most important one: the Time spent working around. The attributes mentioned above may be pointless if it takes no time to work around the issue. If something takes a serious amount of time to be worked around, solved, corrected or understood, it’s time to do something. Recently, GMail and my Mac synced. The result was a Address Book disaster. Time to correct it: 3 hours. That’s a problem.

Anything that’s built to return money should solve a problem or improve something. Anything else? Naaa..That’s my point. What is yours?

There is to date no working revenue model and system for people contributing to open source projects. First of all I want to clearify that from my point of view, it’s not about money creating free software, it’s partially fun, maybe a result of paid work or simply a productive hobby, yet we are living in a world where money counts. So we are happily spending money for everything, while trying to fade out the fact that a lot of stuff we use in our daily lives ( and just be it some free and open source server software we don’t use directly ) is a result of people working for free, out of idealism or whatever.

We need something to show those people our respect. While I’ve been donating like .. 3 times in my live ( each time about 2-5€ ), there are certainly people donating more, and people donating less or not at all. And it depends on how well a project is organised, a good marketing and mostly the project size, it’s highly unlikely that a simple cli-tool meant to be used for just one specific task will be a vital target for money transfers.

So what about a pool, a common adress to receive donations with a ( fair, as far as possible ) system to distribute those amounts among active projects. I haven’t thought about a precise system on how to split those amounts, yet I’m sure that capable people will be able to do so, in a fair manner, which is a cornerstone of this project.

Factors influencing the distribution could take e.g. project activity, team size, download counts etc. into account, although the different uses demand a highly customisable system.

What do you think about it ( Still hoping for comments ) ?

At least for me, this fun suddenly ends when it comes to controllers and their more-or-less tight integration to according views. The traditional, but still largely used, MVC-pattern worked perfect for monolithic, big pages with each one having a clearly defined function.

Today, the world changed. AJAX is still hot shit, and using it without a) blowing up the lines of code in both the view and the controller requires either writing a lot of unreusable helper-functions or depending on templates ( or partials ), anyhow, prepared lines of view code.

But the core idiom of AJAX, the ability to exchange single parts of a website without touching the rest of it, is and cannot be addressed efficiently using these two methods, at least not with the claim that development is fun. It’s not fun ( at least not here.. again ) to include templates over and over and over again. Web development is still, tell me I’m wrong, struggling with the Presentation rather than solving complicated Model-related tasks. And there is either no one concerned or I am way to stupid to get the point.

I’m really looking for a metalanguage describing a web-interface, with all it’s bindings to data, to related controllers and a framework being able to process such a thing ( including caching and so on ), making it straightforward to develop an ajax-based interface, tailored to one’s needs.

For those of you pointing at one of the many JavaScript Frameworks, like GWT, enabling such a functionality: It’s not what I mean. It’s a more general, server-side processed approach, enabling slim clients and fast page processing.

Edit: I know, editing posts is not best practice, but this small additions isn’t wort another post. So I was really thinking a lot about what I wrote here, and I’m quite confident that the main point is indeed the fact the code that logically belongs to the viewer ( something that loads a list for an autocompleter ) is still around in the controller which creates a scenario we usually try to avoid using MVC.. view code in the controller. And updating the view once again requires updating the controller code, most likely at least. What is the other option? To let that simple code be created by a helper at the time it’s needed. Same for Content-type switching orgies to format the output properly. I’m on it, to make coding a little more fun.

And if I’ve been missing some hot new thing ( I’ve been playing with CouchDB, jiha ), please let me know.

Simply , Unpack this file ( tar bz btw ) in your rails app’s root folder and call rake db:superdumper. This will create a file called database.dot in your root folder, containing your database scheme, including associations, in the so-called “dot” format, used by the open-source GraphViz package as input. If you don’t have that package, install it, via ports or apt or whatever applies to your platform. 

In Detail what you have to do is here ( assuming you unpacked the file already.. )
 

rake db:superdumper

This task will automatically dump your scheme and call GraphViz, resulting in a pdf file in the root of your app with the name database.pdf. If it’s not your database schema smiling at you, let me know.

First of all, everyone doing something seriously should be able to get a certificate on his or her field of work. If you’re a professional, why bother taking a test and tell the world you made it? I’m getting your point here: a test only for the sake of a test isn’t worth it, right.

Web standards are a very serious matter. Of course, the average internet user doesn’t bother if a page doesn’t look cool or something, even flash-based pages impress. But when it comes to accessability, typography, usability, web standards try to give developers a good set of tools one can use to improve the overall experience of both the developer and the consumer. There is no direct impact of whether you’re still using tables or already using divs to layout your content, but in the long run it will pay out, even if it’s only that you made it to decrease your traffic costs.

Another very important reason is that web-development and web-design is still terribly underpaid. Many of my friends are doing such things for .. almost nothing, while some well-established companies are building terrible html4 pages and getting a huge load of money for it. And that’s where a certification would kick in. And by proving customers that you are indeed worth it, everyone with the real ability to build web-based stuff would certainly have the realistic chance to increase his or her income.

In my opinion, this certification should be something free, a community should build it, I don’t know how but I’d be glad to have such a thing.

I’m still a bit frustrated that there is nothing like a general file metadata format. While every OS nowadays has its own metadata-supplying filesystem, there doesn’t seem to be a way to exchange that information or reuse it. Neither to publish it online, in a useful manner. I was thinking about a format that enables one to store almost arbitrary information in for a file. Album art, MD5-hashes, Author information, keywords. Anything that helps to categorize a file. Thus, a download would start by clicking on the metadata file, a nice screen would popup showing the file type, the supplied information, giving you the ability to get a quick overview about a file.

This could help to prevent the download of malicious software etc.. And it would help to store files correctly without user interaction. As a teacher of mine noticed correctly, it’s impossible to store and organize files in a useful way using the old-school directory-filename scheme, plus the good old 3-char extension, e.g. avi or txt. Something more sophisticated is needed, and would add a bit more usability to this web.

This is once again just a rough idea, and I would love to hear your comments.