Single file scripts are fairly easy to manage.  If you notice a new version of your script is released, then simply replace your file with the new version.  Likewise, it’s very easy to remove the script if you want to just try it out.  However, scripts spanning multiple files are much harder to manage.  For one, the script’s files get merged in with all of your other script files.

To help know what files are apart of what plugin, I manage my vim scripts in git.  Another way to keep track of things is to use a vimball.

What Are Vimballs?

Vimballs are essential vim script installers.  Each vimball contains all of the files that are needed for the script to work.  Not only that, but it also has a hook for you to easily uninstall the script as well.

Tail Bundle is a script that mimics tail -f for vim.  The downloadable artifact is a vba file.  That file is the vimball.  To actually install the file:

1. vim tail-03.vba
2. :so %
3. :q

So what that all means is that you’re opening the vimball in vim.  From there, you’re executing the instructions that are in the file.  Lastly, you’re just quitting.  You see, a vimball is a vim script in of itself.  So executing it writes everything out to where it’s supposed to go.

While the tail bundle makes use of the vimball, not every script does.  Luckily, it’s easy to make vimballs out of most script downloads.

Converting Scripts to a Vimball

In order to make a vimball, it’s quite easy. List out all of the files you want to include in your bundle, relative to where your current directory is.  For instance:

doc/myawesomeplugin.txt
plugin/myawesomeplugin.vim
syntax/myawesomeplugin.vim

Next thing, while in visual mode, type ggVG:MkVimball myawesomeplugin. The ggVG is a akin to doing a “select all”.

This will create your install file named myawesomeplugin.vba.  Now just install it like any other vimball.

You don’t have to just make vimballs for your own scripts.  I love xpt, but there are so many files to manage.  Well, you can make the vimball script even when the author does not.

Open a new buffer and use the command :r! find . -type f.  This will find all of the files and print them out into the buffer.  If you want to do any cleanup, like remove blank lines and removing the extra ./ before each entry, feel free to do so.  Now that you easily got a list of all the files, create the vimball from that.

Now you have records of what went in with the script and you have a super easy way of uninstalling the script too.  Speaking of which…

Removing Scripts

To remove a vimball script, simply execute :RmVimball myawesomeplugin.  That will go through and delete all files created by the plugin.

After figuring this out, I now know that when I want to use and install vim scripts, I’m going to do so via vimballs.  It’s too easy not to, and the benefit of having a way to back-out scripts is just too tempting.

Say I want a playlist of cover songs.  What I will do is add a comment of “&cover” directly in the track info.

The reason I chose to use an & in front of the tag is so two fold.  One, so if you have a comment talking about the album cover, it wouldn’t get added to the list.  If you don’t like the &, leave it our or use your own.

Once I have done that to all of my songs, I create a new playlist with the following settings:

And now I have my playlist.  The benefit to this is that if I move this song to another computer, say my work desktop, I can easily re-create the playlist.

One last thing.  If you find yourself using this, or wanting to use this, a lot, check out Quick Tag

So what?

Well, you can use the global variable DATA to get the contents of what you wrote after the __END__ block. DATA is actually a File object to just that piece of text in your script.

How about a little sample to make things a little clearer?

#!/usr/bin/env ruby
%w(yaml pp).each { |dep| require dep }

obj = YAML::load(DATA)

pp obj

__END__
---
-
  name: Adam
  age: 28
  admin: true
-
  name: Maggie
  age: 28
  admin: false

So with this, I was able to embed a little bit of YAML directly into my script. I added the YAML after __END__. YAML::load will accept a File object, so I just passed it DATA and now I have a reconstituted array.

Maybe that’s not the most practical use of this information; however, Sinatra provides a really awesome use of this.  With Sinatra, you can create a whole web application that lives in one single, solitary ruby file.  Sinatra can use in-file templates.  In-file templates are added into the space after __END__ where each view file is annotated with @@view_name.

require 'rubygems'
require 'sinatra'

get '/' do
  haml :index
end

__END__

@@ layout
%html
  = yield

@@ index
%div.title Hello world!!!!!

Not bad for a useless trick!

Haml comes with a script, html2haml, which can take HTML with ERB and convert it nicely to haml. Seeing as I would have to run that command more than once, I have a little command snippet that I like to use to aid with the conversion.

$ find . -name '*erb' | \
xargs ruby -e 'ARGV.each { |i| puts "html2haml -r #{i} #{i.sub(/erb$/,"haml")}"}'

That will print out what the html2haml commands would be, it does *not* run the command. I do that step such that I can review what will be converted. If I like what’s going to be done, then I just run that command and pipe it into bash…like so

$ find . -name '*erb' | \
xargs ruby -e 'ARGV.each { |i| puts "html2haml -r #{i} #{i.sub(/erb$/,"haml")}"}' | \
bash

If you like it, it probably wouldn’t hurt storing that as a shell script somewhere :)

With multiple programmers, you can probably expect a versioning system, perhaps a centralized versioning system like SVN or Perforce. With that system, each programmer would make his/her changes and then would check in his/her changes into the repository. From there, the programmer’s peers would review the code.

What’s the problem with this system? The code is already checked in. The pressure is on the peers to ensure that the code is good, and it’s likely that this could slip through the cracks. I mean, those peers are working on getting 10 features complete themselves.

Enter Git

Well, I would argue that Git has a strong code review process built right in. This is due to the process of how distributed version control works.

Programmer A creates a fork of the master project. A makes his changes and commit his code; however, the code is committed to his local repository and not the master origin. This is because A does not have write access to that repository.

A has to contact programmer B, who has write access. A tells B that he should pull his code. Since B has to pull the code, this means that B has to review the code coming in.

It’s this workflow that promotes code review. Now that’s not to say that you can’t do code reviews in a centralized model, it just fits a little better in a distributed model

Ticgit takes a simplistic approach to issue tracking as Lighthouse has done. You can comment, add tags, manage the state of an issue, save views, and change to whom an issue is assigned. There is still more planned, like keeping track of milestones and syncing the tickets to Lighthouse.

As mentioned, there is a web interface to ticgit; however, it wasn’t my cup of tea. So I have started my own web interface, tiwatchtower It’s still a little rough around the edges, but I would love to hear any thoughts.

Conclusion

So far, I like it and it’s exciting to see how git can be pushed. It’s great for keeping track of things that are on my mind without worrying about having to setup trac or having to use up a Lighthouse project. It’s simple, effective, and worth a look at.

I bought a Flex book to, well, teach myself Flex. The book right now is taking me though one application and is building it out piece by piece. So I began to think: “What if I just keep track of all my changes through git?”

For one, Flex is nice because it’s all XML, so that makes revision tracking fairly easy. Also, git is very easy to get started because you don’t have to do any server setup. Just issue a git init command and get going. Then after each chapter, I can tag the repository for posterity’s sake. And I have to say, it’s been great to see how the code has changes, especially since Flex Builder generates code.

That’s one thing I love about git, and mercurial, it’s so easy to start using version control for even the littlest of tasks.

Essentially, if your column is an enum, then indexing it could actually cause MySQL to do more work. Why? Because the data set is so large, the MySQL ends up doing a full scan. So things like keeping track if something is active (1 or 0) then you can expect indexing to hurt.

So how does this effect ActiveRecord? Well, if you’re keeping track of whether a user is active or not you would not want to index that column alone. Nor would you want to index a type column if you were using single table inheritance, again, because there isn’t a lot of variance in the type.

So make sure that you index the right things, like IDs and leave the enum-like columns alone.

So what does “This software cannot be installed because the file system of the OS volume is not supported” even mean???!?! I tell you what it means, it means that Photoshop will not run if you happened to have formatted your file system to be case sensitive Thanks for the clear error!

I don’t even want to begin on how insane that sounds to me? So what’s a person to do?

Well, my friend James Gibson suggested that I install Photoshop in Windows and use Photoshop through WMware Another possibility is to rename directories to make CS3 work

I think I’m leaning towards the first option as some people are having some issues with the renaming method. Either way, it’s kinda lame.

Actually, you hurt the initiative to get an issue addressed when you make those comments. You see, when you star an issue, you receive emails when that issue gets updated or commented upon. So if an issue has 100 or so “+1″ comments, then whoever put a star on that defect is going to get 100 or so emails. After getting 20 inane emails, one might decide to remove the star from the issue, thus lowering it’s rating and hurting the campaign.

So please, if you want to help, just star the issue.