Previewing at 1.0, Cornerstone, a GUI Subversion front end has been released.

Daring Fireball, as ever, with the wry commentary:

It strikes me as an odd coincidence that two serious Subversion clients would debut at a time when many developers are starting to switch away from Subversion to distributed revision control systems such as Git and Mercurial.

Kieran Healey has followed my lead and posted his sociology BibTeX files on GitHub. I could only be happier if someone forked me. C’mon, baby, fork me, fork me!

Update Kieran posts about it here.

As any occasional reader of Edward Tufte will know, sometimes a well designed graphic can simply and effectively convey complex information. The need for graphics may be greater in the sciences than in philosophy, but even here, it can sometimes help. For example, I had a hard time explaining to my students the difference between the intrapersonal principle of the association of impressions and the interpersonal principle of sympathy until I quite literally drew them a picture. Ruby enthusiasts, now have at their disposable an easy means of producing simple yet attractive charts from quantitative data. Googlecharts is a ruby wrapper for the Google Chart API available at GitHub. To install:

$ sudo gem install googlecharts -s http://gems.github.com

Subversion 1.5 is out. This is a major release that promised to address many of the problems with merging. New features include:

• Merge tracking (foundational)
• Sparse checkouts (via new –depth option)
• Interactive conflict resolution
• Changelist support
• Relative URLs, peg revisions in svn:externals
• Cyrus SASL support for ra_svn and svnserve
• Improved support for large deployments on FSFS, via sharding
• Improved FSFS optimizability, via immutable file isolation
• WebDAV transparent write-through proxy
• Improvements to copy and move
• Speed improvements, cancellation response improvements
• Easier to try experimental ra_serf DAV access module
• API changes, improvements, and much language bindings work
• More than 150 new bug fixes, enhancements

If you are still using subversion, or if subversion suits your needs better than distributed alternatives, then this is a must have release.

SecureMac has reported an AppleScript Trojan Horse in the wild. They recommend running MacScan 2.5.2 to fix the vulnerability. For those not afraid of Terminal fu, there is an easier fix:

$ sudo chmod 0555 /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/MacOS/ARDAgent

Version 1.4 of Aquamacs, the Aqua-native build of Emacs, has just been released, and has a number of interesting features making it an even better OS X citizen:

• New multi-tabbed interface similar to Safari. This makes switching between open files faster and more intuitive.
• Full screen editing now available. This allows you to focus just on editing your files without distraction from other applications.
• Aquamacs no longer creates backup files by default: less clutter in your files.
• Now uses standard “unified” toolbar, with improved icons, for greater ease-of-use.
• Improved LaTeX support.
• Numerous improvements in text search.
• Can check for program updates from the application menu.

The LaTeX improvements include the inclusion of AUCTeX 11.85, better error reporting and improved syntax highlighting, and improved icons. Aquamacs 1.4 can be downloaded here.

Some solutions to life’s inconveniences can be forehead-slapping obvious.

A paradigm shift in academic publishing is occurring—a move from dead tree sources to online resources. As I have had occasion to comment (here and here), this is a Good Thing™. However, the old paradigm is not without its virtues, perhaps not all of which will be preserved in the new paradigm.

Searching online is not like searching by other means. For all its advantages, sometimes something can be lost. For example, I find it much harder to browse for DVDs on Amazon than it was browse for them in a DVD store. A certain potential for fortuitous serendipity has been noticeably diminished. With respect to dead tree journals, it was convenient to go to the departmental library and flip through the new journals for a good sense of what was coming out. My departmental library, however, has been canceling subscriptions as our university library is making these journals available online. Sensible, but a lost opportunity for browsing.

Now for the forehead slapping. Most journals that publish material online provide convenient RSS feeds of recent issues. (Most but not all—the venerable Journal of Philosophy doesn’t. I must write to the editor about this, and I encourage philosophers out there to do the same.) I spent twenty minutes this afternoon subscribing to feeds. Now I can browse recent issues from my newsreader in my office. Why didn’t I think of this before? The paradigm shift is still ongoing. And even I, as an editor who has actively promulgated it (by instituting a new publishing model for the Aristotelian Society with more to come) can yet remain blind to the obvious possibilities.

When I am done filling out my subscriptions, I will post a list of philosophy feeds.

Academics tend to be pretty good at sharing resources. For example, most publish their research online. This is really helpful since it can take a year or two after submission to finally see its way into print.

One useful thing that academics share, though less often than their research, is their bibliographies. LaTeX is predominant in academia, though not universally so. So many of these online bibliographies are BibTeX files. See Benj Hellie’s BibTeX file as an example.

Sometimes, these have been converted to HTML. Sometimes, as in Benj’s case, the author simply posts the text file (BibTeX is a flat file database kept in plain text). This has some limitations. One problem is that the author has to periodically export to HTML, and even if he is posting the text file, it still needs to be uploaded to the server. Unlikely that this is done after each change to the bibliography.

From the users side, there are problems too. Suppose I have downloaded Benj’s BibTeX file. Some time passes, and I want to take advantage of Benj’s hard work. Some of the entries I already have, some are new. Some of the new entries may overlap with entries that I have made independently. Manually merging this material can be a pain, even with diff tools.

All of this would be a lot easier if academics used distributed version control to share their bibliographies. Suppose the distributed version control system in question is Git. When an author makes a change to his bibliography, then all he need do is to commit the change and push to the remote repository:

$ git commit mybibtexfile.bib
$ git push

From the users side, to download the bibliography all he need do is clone the git repository:

$ git clone git@github.com:PhilGeek/bib.git

After that, fetching and merging new changes is easy as:

$ git pull

Well, I am putting my money where my mouth is and publishing my BibTeX file in an open Git repository hosted at GitHub—http://github.com/PhilGeek/bib/tree/master. To clone this repository:

$ git clone git@github.com:PhilGeek/bib.git

Even if you are not a Git user and are shy about adopting new technology, the file can be viewed and downloaded here.

There is not as much in it as there should be. Before becoming a plain text Geek, I kept my bibliography in EndNote. Unfortunately, my EndNote file, a proprietary binary format, became corrupted before I could convert it to BibTeX. Yet another cautionary tale speaking in favor of the Power of Plain Text.

When can we expect TextMate 2 to be released? Here is what Alan Odgaard has to say in the TextMate 2 FAQ:

[…] there is no ETA, and I won’t speak about timing before I am certain I can provide an (alpha/beta) release within the next month – because really, the more I say, the more people ask, and having to answer the same questions over and over again is (for me) mentally exhausting. So put TM 2.0 up there with Duke Nukem Forever and be positively surprised the day it is released :)

The release of footage of Duke Nukem Forever has prompted the following query on irc:

ph^: allan: Now that Duke Nukem forever has released a new gameplay-video … :p

Well, no official word from Allan yet, but Peter Haza (aka ph^) shares some insights into the state of TextMate 2 development in this interesting post.

Mark Liberman at Language Log has written a nice post about the charge that linguistic descriptivism is a manifestation of what Nietzsche calls slave morality. Liberman is right in claiming that this does not make sense, but for the wrong reasons, I think.

It is odd how so many who would cite Nietzsche in support of their ideological views end up espousing an ideology that is criticizable on Nietzschean grounds. And Kevin S is no execption:

At the end of the day, Descriptivism appears merely to be another form of Nietzsche’s concept of slave morality, which is the dominant morality of our day.

Let me confine myself to two sets of remarks, the first concerning Nietzsche’s attitude toward categorical demands, and the second concerning the distinction between the noble and slave moralities.

Prescriptivists are so-called because of the categorical demands they make on linguistic usage. Such demands (“Split not the infinitive”) are unconditional. The fact that splitting an infinitive may be the only way to say what you mean (“I eat sensibly to not get fat”) is deemed insufficient reason to transgress this norm. The fact that these prescriptions are categorical is sufficient to discredit their alleged Nietzschean heritage. Thus Nietzsche, in Beyond Good and Evil §31, describes “the taste for the unconditional” as “the worst of all tastes”. Moreover, the third essay of the Genealogy of Morals is largely devoted to arguing that categorical demands are the expression of ressentiment. If we are to take Nietzsche seriously here, this raises the question: Are prescriptivists resentniks?

A basic understanding of the distinction between noble and moral modes of evaluation in the first essay of the Genealogy of Morals also reveals Kevin’s charge to be senseless.

According to Nietzsche, the noble mode of evaluation grew spontaneously out of a positive sense of self. The basic concept, then is that of the good, the noble. The corresponding negative concept, the bad, is a subsequently invented concept, whose content is parasitic upon the previously established concept of the good. In devising the noble valuation of the good, the aristocrats only looked to themselves and what they perceived as there typical character traits. In devising the noble valuation of the good, the aristocracy was positively affirming what they took themselves to be. The noble, the well born felt themselves to be happy—as such they did not need to affirm themselves with essential reference to those whom they despised, the slaves. Furthermore such happiness was inextricable bound with activity and strength.

The bad, in the noble form of valuation, originally denotes the lowly the plebeian, the slaves. Subsequently the bad was itself associated with certain character traits. If the noble, the good were strong and brave and truthful, the bad were weak and cowardly and untruthful. Despite the evident contempt the higher ranks felt for the lower order, such contempt was tempered by a sense of forbearance and pity. If the noble and well born were happy, the bad were unhappy and pitiable. The forbearance which tempers noble contempt is itself a sign or symptom of the positive sense of self that animates the noble form of valuation. The aristocracy did not affirm itself derivatively by a display of contempt for the slaves, rather it is out of a positive sense of self that the good arises. Nietzsche employs the platonic imagery of a pale image or shadow to describe the bad as it figures in the noble mode of valuation. Just as a shadow depends for its existence and continued stability on that which casts it, so the concept of the bad depends on the prior establishment of the concept of the good for its own content and conceptual stability.

Whereas for the noble mode of evaluation the fundamental distinction is between good and bad, for the slave mode of evaluation the fundamental distinction is between good and evil. There are number of pertinent contrasts:

1. In the noble mode of evaluation “good” is conceptually prior to “bad”. In the moral mode of evaluation, “evil” is conceptually prior to “good”.
2. What the noble mode of evaluation deems good, the moral mode of evaluation deems evil.
3. In the noble mode of evaluation, the basic concept of “good” grew out of a spontaneous sense of self worth. In the moral mode of evaluation, the basic concept of “evil” grew out of a negative reaction of the weak against the strong.

This is sufficient to cast light on its application to the debate between descriptivists and prescriptivists.

1. Where descriptivists see value in novel forms of linguistic usage, prescriptivists are primarily concerned to criticize such usage.
2. What descriptivists celebrate or at least deem legitimate, prescriptivists deem bad usage, indeed ungrammatical.
3. The usage that descriptivists deem legitimate evolved spontaneously as part of the active development of language. The prescriptivists criticism of such usage is a negative reaction to such active development.

Exactly who is propagating slave morality?

Earlier I asked why resentniks seem so attracted to Nietzsche’s work. Let me offer a speculative hypothesis. I believe that this is due, in part, to a tension in Nietzsche’s work. Nietzsche’s lasting contribution to morality is his detailed description of the moral dangers of ressentiment. That his case is as compelling as it is is due, in part, to the fact that he is not himself completely free of ressentiment. Perhaps that is why he never describes himself as the ubermench, but rather casts himself in the role of a prophet foretelling his coming.

From Information Aesthetics, a link to code_swarm:

This visualization, called code_swarm, shows the history of commits in a software project. A commit happens when a developer makes changes to the code or documents and transfers them into the central project repository. Both developers and files are represented as moving elements. When a developer commits a file, it lights up and flies towards that developer. Files are colored according to their purpose, such as whether they are source code or a document. If files or developers have not been active for a while, they will fade away. A histogram at the bottom keeps a reminder of what has come before.

Here is the video representing Python’s development:

code_swarm - Python from Michael Ogawa on Vimeo.

Update: code_swarm has been Slashdotted by CmdrTaco himself.

Stability is a precondition for the possibility of citation.

Consider direct quotation—no easy phenomena. Part of the point of citation, here, is so that the reader can read the quotation in context, to decide for themselves whether the quoted author has been misrepresented. The usual case is to quote from a dead tree source—a printed book or journal. Imagine if books were quite different than from the way they actually are. Suppose that every time a book is closed the text would change, sometimes subtlely, sometimes less so. When your intrepid reader tracks down your citation, the quote may or may not be there. What would be the point? There would be very little, if any, point at all. The requisite stability would be missing from texts that spontaneously morph.

One good thing about dead tree sources is that they don’t change in this way. But now consider delivering text online. It is easy to change HTML or upload a new version of a PDF. The nature of the medium does not guarantee the stability guaranteed by ink on a page. Instead of natural law, we have the moral law. We must rely—God help us—on trust. This is manifest in bloggers’ convention of striking through changed text in a post. Leaving a trace of a misspelled word, a hasty judgment, or mal mot is a sign of good faith, and bloggers who depart from this convention are subject to (verbal) sanction in comments or in pingback posts.

As the delivery of academic journals is moving increasingly online, editors face a corresponding moral challenge. The Aristotelian Society publishes papers online before the print volume hits the stands. Once an author asked to change his article after the online version went live but before the print volume was typeset. What was the problem? Things change online all the time!—he implored. The problem was simple. It would violate a precondition for the possibility of citation.

OK, so you know a meeting is boring when you would rather redo your bash prompt. (And, yes, as a consequence, I have come to appreciate the point of running a headless meeting.) I wanted my bash prompt to tell me a number of things:

1. Who am I?
2. Where am I?
3. Which branch of a Git repository am I on?

I wanted color. I wanted a multiline prompt. I wanted it all!

Actually it was pretty easy. Here it is, explanation to follow:

source ~/.git-completion.sh

export PS1='\[\e[0;32m\]\w\[\e[1;33m\]$(__git_ps1 "(%s)")\[\e[0m\]\n\u $ '

The first line loads .git-completion.sh a script distributed with Git that provides autocompletion for Git. Cool! But it also provides the function at work in:

$(__git_ps1 " (%s)")

This will display the branch currently checked out when you are in a Git repository.

The characters:

\[ \]

wrap nonprinting characters, in this case, the color codes:

\e[0;32m
\e[1;33m
\e[1;33m

Finally:

\w
\n
\u

gives you the name of the current directory, a new line, and your user name, respectively.

Well a picture is worth a thousand words:

Daringfireball reports that a Leopard Security Configurartion book from Apple was produced by Framemaker 6.0 available in Classic only. It is pathetic that Framemaker is not available on OS X since it is available on Windows and UNIX (Isn’t OS X UNIX?). I don’t think that everything typeset with an Apple computer should be done with LaTeX. There should be room for a serious GUI typesetting program (and, no, neither Indesign nor Quark cuts it). And Pages is still miles away. (Pages’ styles used to be a huge improvement over Word, but that is another story.) It is a scandal that Apple cannot typeset their own documentation on their current operating system.

Check it out.

Will try to review it later. But one interesting feature is its integration with Beanstalk that provides one 20MB Subversion repository for free. Smart move for the casual user who might still be intimidated by the command line interface.

Having decided to try out Git, I was excited to learn that Git could interface with Subversion repositories via git-svn. git-svn provides a bidirectional flow of changesets from a branch of a Subversion repository and any number of branches in a Git repository. The problem that I soon encountered should be evident from this description—you inherit the limitations of the Subversion repository. A rewrite of a paper for the European Journal of Philosophy provided the opportunity to start a Git repository and work purely with Git. This was a revealing exercise that allowed me to shed some habits engrained from being a long-time Subversion user.

I am now in the process of transitioning my work over to Git. One salient difference is that, with Subversion, I kept all my mission-critical text files in a single structured directory; Git, however, wants to find relationships among everything in the repository, so it is important to keep unrelated projects in different repositories. (Fortunately setting up Git repositories is a snap.) This is important to bear in mind when migrating from Subversion. If, like me, you maintained a single Subversion repository with separate subdirectories for each of your projects, you need to migrate each of these into separate Git repositories.

Here is how I began my migration.

I decided to start with my remind files:

$ mkdir -p /tmp/remind
$ cd !$
$ git-svn clone http://markelikalderon.com/svn/TheHub/Remind --no-metadata

The command:

git-svn clone

calls init, which creates a new Git repository, and fetch, which fetches the contents and history of the directory. git-svn clone takes the options of both init and fetch. One useful option is –no-metadata which strips out the no longer needed Subversion metadata.

Now I needed to configure my new Git repository. I began by creating a file and opening it in my text editor, TextMate:

$ touch ~/users.txt && mate ~/users.txt

I then added the following to users.txt:

kalderon PhilGeek <eli@markelikalderon.com>

‘kalderon’ being my Subversion user name and ‘PhilGeek’ being my Git user name. There should be one line each with this syntax for each of the users. Now I was ready to configure git:

% git config svn.authorsfile ~/users.txt

The final step is to clone this new Git repository to rid ourselves of any remaining svn cruft. I created a new GitHub project and then within the Git repository:

$ git remote add origin git@github.com:PhilGeek/remind.git
$ git push origin master

Finally, I cloned the remote repository into the directory where my remind files were to live locally and deleted the /tmp/remind directory.

Not too bad. But you might consider automating the process with a shell or ruby script, if this needs doing several times over.

Scott Chacon, author of the very nice Peepcode title Git Internals, Source Code Control and Beyond, has given a Git Tech Talk at RailsConf 2008:

RailsConf 2008 Git Talk by Scot Chacon Video from daniel wanja on Vimeo.

The slides of his talk are also available.

Versions, the GUI Mac subversion client is still vaporware, but there is a review of the prerelease beta at Theocacao. Though I am shifting over to Git, I am still curious how Versions will stack up against svnX.

In a previous post I discussed bash emacs mode—a convenient way to get around the bash command line quicker. Taking the time to learn these commands definitely yields a welcome boost to productivity. (And if you cannot remember them at first there is a bash cheat sheet.)

I recently learned a few things about bash history that’s made me more productive on the command line, so I thought I would share.

Searching Bash History

Almost anyone who has spent any time at all on the command line will know that you can move backwards and forwards through the history of previous commands with the up and down arrow. Suppose, however, you want to rerun a previous command issued several command lines before. You could bang away at the up arrow. But this is tedious and error prone—you can easily overshoot the target command line.

Fortunately there’s a better way. Bash allows you to search backwards through your history with ⌃R. After typing ⌃R begin typing the string that you are searching for and the bash shell will return the most recent matching string. To search further back in your history for other matches hit ⌃R as many times as necessary. Nice.

Old School

The bash history predates the emergence of arrows on keyboards. So there are ways to move through bash history with these. Thus:

!!

takes you to the previous command line. What’s the point, you might wonder? Why bother to use three keystrokes when one (up arrow) will do? Well, you can use !! with other elements of a command line:

$ tree
-bash: tree: command not found
$ ~/bin/!!
~/bin/tree

Nothing similar can be accomplished with the up arrow.

The bash history is a numbered list of command lines issued to the shell. You can select a particular command line using !n where n is the number of the command.

One of the most useful commands for traversing bash history is !$ which gives the last argument of the previous command:

$ mkdir -p myproject/src
$ cd !$
$ PWD
/Users/markelikalderon/myproject/src

Another useful command is !* which gives all of the previous commands. This can be useful for correcting (sadly inevitable) typing errors:

$ sbn commit -m "Initial commit"
bash: sbn: command not found
$ svn !*
svn commit -m "Initial commit"

Another way of dealing with this typo is to use a quick substitution with the caret ^.

$ sbn commit -m "Initial commit"
-bash: sbn: command not found
$ ^sbn^svn
svn commit -m "Initial commit"

There’s more, much more, that can help you traverse the command line efficiently. As ever, RTFM, baby.

Update: There is more on bash history on the TextMate Blog.