Kubrick vs Scorsese from Leandro Copperfield on Vimeo.

Made me want to watch all those movies I haven’t seen, yet, and watch again various of those I already know.

I took four years of german in university and I think the knowledge has always made me a better programmer.

So, among my reply, I asked the guy to explain that, and later for permission to reproduce his reply here:

I spent twelve years off and on living in Germany as a child in Mainz, as a high school student in Wiesbaden, and in college at the Goethe Institute in Schwabsiche Halle. I eventually got a degree in german and econ from George Washington University in DC.

I didn’t start programming until graduate school at the University of Southern California and I am currently finishing a phd at Virginia Tech.

By profession I have been a Marine Pilot(CH53), management consultant(KPMG),CEO(Datacyr and Topik Solutions), and since 9/11 working exclusively with the US government developing semantic search engines (sesame, lucene, rdf, and sparql). I also spent many years in the data warehouse field building in-memory ETL engines.

Languages come in all shapes and sizes, as you know.

The human species and those members who appear to survive and evolve fitness adaptations better than others, do so through language. The primary goal of any language is to improve search skills(Google) and the tools to control resources(The Third Reich). The structure of both german and c require a very ordered syntax when arranging symbols(info), motion(services), and objects(things) in the mind’s mental model of the world. Unlike english, which allows for some flexibility in ordering the mental model of the world, german enforces a structured approach to control and memory management not found in english. It is no accident that SAP has been so successful as a technology and a company.

I have had to program in a dozen languages and across as many operating systems. Since my work is all about data manipulation, design, and models, I always come back to c when I have to achieve ultimate control (memory) and performance(pointers). Without an early education in german, I don’t believe I would have ever achieved what I have been able to accomplish in the technology field.

My phd develops the theory of semantic intelligence. The theory is based on the concept that human cognition is a type of computational model that can be implemented in software.

Thus my admiration for the elegance of jQuery and your validation plugin as a structure for optimizing search and control in human computer interfaces.

With german as my native language and english as a key requirement for learning to program, I can’t really reflect this well with my own experiences. The four years I learnt a bit o french at school certainly didn’t make a difference. I’d like to hear from others if they had similar experiences when learning other languages.

Vorher und nachher gibt es viel Möglichkeit zum Kennenlernen und Austausch rund um JavaScript. Das Treffen beginnt um 19 Uhr und die Vorträge um 19:30 Uhr. Das ganze findet in den Räumen der Coworking Cologne statt (Deutz-Mülheimer Straße 129, 51063 Köln) – dort fand auch letzten Dienstag ein kurzfristig organisiertes Node.js Meetup statt, mit Ryan Dahl als Vortragenden. Ein paar Fotos dazu hab ich bei Picasa hochgeladen, inkl. einem 3-minütigem Video, einem Ausschnitt aus Ryans Vortrag:

Für Updates könnt ihr CgnJS bei Twitter verfolgen. Hoffe man sieht sich nächsten Dienstag!

Nachtrag: Es waren 24 Leute da, hier auf ein paar Fotos auch zu sehen. Mein Vortrag lief gut (etwa 17 Minuten vorgetragen, dann nochmal so lang Fragen beantwortet), der von Jens Arps zu Mobile JavaScript war sehr interessant und hochaktuell. Konnte ich auch daran merken, das letztes Jahr im November meinem jQuery UI Vortrag niemand nach Mobile gefragt hatte, gestern hingegen war da eine Menge Interesse. Nächster Termin ist dann am 10. August.

git remote add original git://url-to-original-repo

This adds another remote repository. You can use git remote -v to see your existing remotes. There should be “origin” already, pointing to your GitHub fork. You can use whatever name you like for the new remote repository, above I’ve used “original”.

git fetch original

This loads all commits, including branches and tags, from the specified remote repository, using the alias defined above.

git merge original/master

This merges all changes from the original master branch in your current branch, eg. your local master branch.

git push

By default, push pushes everything to your “origin” repository. Which brings your repo up-to-date. That’s it!

Today I’ve finally finished the Autocomplete Migration Guide, which explains how to migrate from ye olde plugin to the new jQuery UI Autocomplete widget. It covers the various options and their replacements, if any. In a lot of cases, we were able to get rid of the options by providing better defaults or by restructuring the API, with the source option being the most prominent example.

The next major jQuery UI release should include the new Tooltip widget, paving the way to shut down another plugin on this site.

Here are a few quotes from the lecture, with a few comments. At the end I’m also providing the actual title-giving story for easier enjoyment, as the PDF is really not that great to read – a shame considering the great content.

My first task was to implement for the new Elliot 803 computer, a library subroutine for a new fast method of internal sorting just invented by Shell. I greatly enjoyed the challenge of maximizing efficiency in the simple decimal-addressed machine code of those days. My boss and tutor, Pat Shackleton, was very pleased with my completed program. I then said timidly that I thought I had invented a sorting method that would usually run faster than SHELLSORT, without taking much extra store. He bet me sixpence that I had not. Although my method was very difficult to explain, he finally agreed that I had won my bet.

And thus was born the quicksort algorithm.

The first principle was security: The principle that every syntactically incorrect program should be rejected by the compiler and that every syntactically correct program should give a result or an error message that was predictable and comprehensible in terms of the source language program itself. […] A consequence of this principle is that every occurrence of every subscript of every subscripted variable was on every occasion checked at run time against both the upper and the lower declared bounds of the array. Many years later we asked our customers whether they wished us to provide an option to switch off these checks in the interests of efficiency on production runs. Unanimously, they urged us not to–they already knew how frequently subscript errors occur on production runs where failure to detect them could be disastrous. I note with fear and horror that even in 1980, language designers and users have not learned this lesson. In any respectable branch of engineering, failure to observe such elementary precautions would have long been against the law.

Thats an interesting point of view, and something that can be applied elsewhere. For example, Bruce Schneier writes a lot about how the lack of consequences makes a lot of security or privacy failures possible. If companies aren’t liable when “loosing” their users data, they have not enough incentive to prevent that in the first place.

I was eventually persuaded of the need to design programming notations so as to maximize the number of errors which cannot be made, or if made, can be reliably detected at compile time. Perhaps this would make the text of programs longer. Never mind! Wouldn’t you be delighted if your Fairy Godmother offered to wave her wand over your program to remove all its errors and only made the condition that you should write out and key in your whole program three times! The way to shorten programs is to use procedures, not to omit vital declarative information.

Considering discussions of static vs. dynamic languages, the interesting point here would be to define “vital”. Its easy to argue that vital has different meaning based on the context.

At last, there breezed into my office the most senior manager of all, a general manager of our parent company, Andrew St. Johnston. I was surprised that he had even heard of me. “You know what went wrong?” he shouted–he always shouted– “You let your programmers do things which you yourself do not understand.” I stared in astonishment. He was obviously out of touch with present day realities. How could one person ever understand the whole of a modem software product like the Elliott 503 Mark II software system?

I realized later that he was absolutely right; he had diagnosed the true cause of the problem and he had planted the seed of its later solution.

Now that is an intersting thought. Would you agree to that statement? Are you sure?

Keep in mind that the point is about understanding, not doing all the work by yourself. To be more concrete, this could mean that you should be able to look at all the code and understand every line of it. Or that you understand everything when one of the programmers explains to you what he just wrote.

Are you responsible for other programmers and would you pass these tests?

You know, you shouldn’t trust us intelligent programmers. We can think up such good arguments for convincing ourselves and each other of the utterly absurd.

I’d say that actually applies to most human beings. Think of how politicians can make up arguments for the stuff that they are convinced (or more likely, were convinced) is the right thing to do.

I conclude that there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.

The first method is far more difficult. It demands the same skill, devotion, insight, and even inspiration as the discovery of the simple physical laws which underlie the complex phenomena of nature. It also requires a willingness to accept objectives which are limited by physical, logical, and technological constraints, and to accept a compromise when conflicting objectives cannot be met. No committee will ever do this until it is too late.

Another essential point of view: Simplicity is key, and way harder to achieve. Break complex stuff down to the very basics, until nothing is left to remove (but no more), then build complex stuff based on that, instead of building complex stuff on other complex stuff.

When any new language design project is nearing completion, there is always a mad rush to get new features added before standardization. The rush is mad indeed, because it leads into a trap from which there is no escape. A feature which is omitted can always be added later, when its design and its implications are well understood. A feature which is included before it is fully understood can never be removed later.

What he says.

Programmers are always surrounded by complexity; we cannot avoid it. Our applications are complex because we are ambitious to use our computers in ever more sophisticated ways. Programming is complex because of the large number of conflicting objectives for each of our programming projects. If our basic tool, the language in which we design and code our programs, is also complicated, the language itself becomes part of the problem rather than part of its solution.

Another argument for the importance of simple and powerful programming languages.

I knew that it would be impossible to write a wholly reliable compiler for a language of this complexity and impossible to write a wholly reliable program when the correctness of each part of the program depends on checking that every other part of the program has avoided all the traps and pitfalls of the language.

Something every programmer learns once working on a project above a certain complexity: You change on thing without having any idea on the impact on everything else. The less (inter-)dependencies the code has, the easier it is to determine the impact of changes. Also a major motivation for test-driven design…

Almost anything in software can be implemented, sold, and even used given enough determination. There is nothing a mere scientist can say that will stand against the flood of a hundred million dollars. But there is one quality that cannot be purchased in this way–and that is reliability. The price of reliability is the pursuit of the utmost simplicity. It is a price which the very rich find most hard to pay.

The most important quote here bears repeating: The price of reliability is the pursuit of the utmost simplicity.

To have our best advice ignored is the common fate of all who take on the role of consultant, ever since Cassandra pointed out the dangers of bringing a wooden horse within the walls of Troy.

Nothing to add.

Now, the actual title-giving story that Hoare tells at the end of the lecture. Copied from the PDF linked above, © ACM 1981.

The Emperor’s Old Clothes

Many years ago, there was an Emperor who was so excessively fond of clothes that he spent all his money on dress. He did not trouble himself with soldiers, attend banquets, or give judgement in court. Of any other king or emperor one might say, “He is sitting in council,” but it was always said of him, “The emperor is sitting in his wardrobe.” And so he was. On one unfortunate occasion, he had been tricked into going forth naked to his chagrin and the glee of his subjects. He resolved never to leave his throne, and to avoid nakedness, he ordered that each of his many new suits of clothes should be simply draped on top of the old.

Time passed away merrily in the large town that was his capital. Ministers and courtiers, weavers and tailors, visitors and subjects, seamstresses and embroiderers, went in and out of the throne room about their various tasks, and they all exclaimed, “How magnificent is theattire of our Emperor.”

One day the Emperor’s oldest and most faithful Minister heard tell of a most distinguished tailor who taught at an ancient institute of higher stitchcraft, and who had developed a new art of abstract embroidery using stitches so refined that no one could tell whether they were actually there at all. “These must indeed be splendid stitches,” thought the minister. “If we can but engage this tailor to advise us, we will bring the adornment of our Emperor to such heights of ostentation that all the world will acknowledge him as the greatest Emperor there has ever been.”

So the honest old Minister engaged the master tailor at vast expense. The tailor was brought to the throne room where he made obeisance to the heap of fine clothes which now completely covered the throne. All the courtiers waited eagerly for his advice. Imagine their astonishment when his advice was not to add sophistication and more intricate embroidery to that which already existed, but rather to remove layers of the finery, and strive for simplicity and elegance in place of extravagant elaboration. “This tailor is not the expert that he claims,” they muttered. “His wits have been addled by long contemplation in his ivory tower and he no longer understands the sartorial needs of a modern Emperor.” The tailor argued loud and long for the good sense of his advice but could not make himself heard. Finally, he accepted his fee and returned to his ivory tower.

Never to this very day has the full truth of this story been told: That one fine morning, when the Emperor felt hot and bored, he extricated himself carefully from under his mountain of clothes and is now living happily as a swineherd in another story. The tailor is canonized as the patron saint of all consultants, because in spite of the enormous fees that he extracted, he was never able to convince his clients of his dawning realization that their clothes have no Emperor.

Here are the day-to-day issues that I’m experiencing as a user of Flash components:

Captured keyboard input

My biggest issue: When a Flash movie has focus, it swallows most keyboard events. I use Ctrl+Tab and Ctrl+n (1 for mail, 2 for RSS reader and so on) all the time, but for that to work on a Tab with an active Flash movie, I have to click outside the movie so that keyboard focus is back where it belongs. Completely unnecessary and annoying as hell.

Full screen video slow or hanging

My Lenovo laptop has trouble playing full screen HD video in Flash. It actually runs fine most of the time, it just hangs half second every few seconds. Worse, sometimes video completely hangs in fullscreen mode, while audio continues to play, so depending on the video, I don’t even notice the problem until 10 seconds later. I have to press Escape to go back to normal mode, then go to fullscreen again. Happens way too often.

Crashes browser

For years I thought only the Java browser plugin was able to reliably crash my Firefox browser. Today Firefox crashed when trying to play a full screen video. I got worse as Tabmix Plus was unable to restore my open Tabs (about a dozen), and loosing any user input is among the biggest sin software can commit. I wouldn’t care for the plugin to crash and require a browser restart, but crashing the browser isn’t acceptable. I’d disable Flash by default if that would happen regularly.

Stability, performance, thats likely to be important for Adobe to be working on. The keyboard event capturing? I hope so.

Sidenote on the “open mobile web”

If someone argues that you don’t need Flash on the iPhone as Apple embraces the open web and DHTML5 and everything: Try to play a background sound on Mobile Safari. As that isn’t possible for whatever reason, the only way to port Flash games to the iPhone is via Apple’s closed App Store. Even if they add support for playing back a simple MP3 file, I doubt we get anywhere near stuff like this (click on Launch App to see the Flash stuff) anytime soon.

Zum Titel: Ich erhoffe mir dieses super Yoda Shirt.

Eclectic Method’s The Tarantino Mixtape on Vimeo (HD available only on their site)

Their Tarantino Mixtape is not quite new, but has to be mentioned when looking at this Tarantino plus Cohen Brothers mashup. The beginning is actually very similar, which probably isn’t a coincidance. Mixing in Cohen movies is certainly a good move, though the music mixing isn’t quite as good overall – the transitions are rather weak. Though mixing Samuel L. Jacksons’ bible quote with Don’t Let Me Be Misunderstood from Kill Bill I, climaxing into wild shooting scenes is awesome.

Tarantino vs Coen Brothers on YouTube

Harvey Keitel’s “Bam. Bam. Bam.” from Reservoir Dogs is in both, and if you’ve watched The Tarantino Mixtape first, you’ll certainly like the appearance on the second mix. I do. And now I also want to watch Kill Bill I and II again. I probably should give up on waiting for the Kill Bill Director’s Cut – both movies as one, as originally intended – and just watch them as-is. Still have the shrink-wrapped DVD lying around here… And I want to watch all of the movies in here that I haven’t seen, yet. And watch Inglorious Basterds again. Oh my…

PS: If you like the Eclectic Method mashup, be sure to check Lock up your Videos. There are a few goodies on their vimeo channel, too, but its rather random and not nearly on the level as the Tarantino Mixtape or LUYV.

The chapter on branching from Pro Git is a good start for learning branching in Git. And the next step, remote branches, has its own chapter as well.

In order to be able to repeat the necessary steps, I’ll describe here how to create a local branch, commit some changes, and then push that branch to your Github repository.

The following command creates a new branch and switches to that:

git checkout -b "newbranch"

To see the local branches and which one is the active one, use:

git branch

That should now display a list like

master
* newbranch

Where the asterix marks the new active branch. With that, you can modify stuff in the branch. Then, to add all modified files to a commit, along with a message:

git commit -a -m "Message along with modifications"

Now comes the interesting part, pushing the branch back to the remote repository, Github in my case:

git push origin tooltip

Git knows that “origin” refers to git@github.com:jquery/jquery-ui.git, so it’s enough to add the name of the branch.

This works so far, but isn’t optimal yet: To push from the tooltip branch, I need to use “git push origin tooltip” again. I’ve found two ways to fix this, both way to complicated for such a simple requirement.

Either manually edit your .git/config file and add the branch, you should then end up with something like this:

[branch "master"]
	remote = origin
	merge = refs/heads/master
[branch "tooltip"]
	remote = origin
	merge = refs/heads/tooltip

For my “tooltip” branch, I added the entry below the entry for “master”, and just replaced “master” with “tooltip”.

To avoid editing that config file, I found this to work:

git branch -D tooltip
git checkout --track origin/tooltip

With branch -D I forced a deletion of the local branch, then used checkout with the –track option to check it out again and have Git set up the config entries for “tracking”. There should be an easier way to do that.

Update: Apparently you can configure Git to automatically setup the tracking via:

git config --global branch.autosetupmerge true

You can leave out “–global” to apply it only to the current project. Seems to be more useful as a global setting…