ramblinations

Koding with PHPStorm

2014-02-22T10:52:00-07:00

A year or so ago I stumbled over Koding (my referral, if you're feeling benevolent), a social development platform that gives you (and everybody on your team) a disposable Ubuntu virtual machine, a web-based SSH terminal and code editor, and a giant network of fellow devs. It's a nifty place, and I've used it to collaborate with friends, teach myself Django and R and AngularJS and CoffeeScript, work through Coursera algorithms homework, develop new web applications, test documentation, play with Node modules I don't want on my regular machine, and so on, ad infinitum. The Icelandic team behind it wants to make the world a better place. It's unique. Naturally, I wanted to hook it up to PHPStorm.

Koding's walled garden

Koding VMs sit behind a proxy, so SSH-ing in from an external system already requires some finangling. PHPStorm's remote deployment system is entirely finangle-free, so getting it communicating with Koding would be impossible without our secret weapon: SSH tunnels!

Tunnelling through

I already had a PuTTY session saved for Koding, so I copied it to preserve the proxy settings. (I'm going to assume you've already got external SSH access to your VM working. If you don't, check out the official docs--I even helped write them!)

Create the tunnel

In my PuTTY config, I loaded up my copied Koding session and found Connection → SSH → Tunnels.

I checked both boxes at the top.
I set Source port to an unused port on my local system.
I set the Destination to localhost:22 (note that that's localhost relative to my VM, not to my local system), and selected the Local option.

These settings create a "tunnel" that sends any local traffic on port 12345 through an SSH window to my VM. (And remember, the Koding proxy server is saved already, so I don't have to mess with it again.)

Since I'm not going to be interacting with the PuTTY terminal for this session, I disabled the shell entirely in Connection → SSH...

...and renamed the window itself in Window → Behavior:

When I save and open the session, I get a non-interactive terminal that does nothing but authenticate me and set up the tunnel:

Perfect! Whenever I want to use my Koding tunnel, I'll run the new session and let it sit. You can even test it: Open the tunnel, and then fire up a brand new PuTTY session pointed at localhost:12345. You'll get shunted through the tunnel and end up in your Koding VM.

Send PHPStorm to the other side

You can probably guess where this is going: To hook up PHPStorm's remote deployment, we'll send it through the tunnel. Create your new project with the Remote host, files accessible via SFTP option:

When PHPStorm asks you for connection settings on the next screen, direct it to localhost on port 12345. (Make sure the tunnel is running first!) All your other connection information (username, password, etc.) will stay the same, as if you were connecting to your Koding VM normally. (Note that if you're using key authentication, you'll need to export your *.ppk file to OpenSSH format.)

That's it! PHPStorm can now deploy your project directly to your VM--it'll even run your PHPUnit tests for you. You'll need to set up root paths and directory mappings, but the hard part's over.

couples counseling for PHPStorm and MySQL

2014-02-16T12:18:00-07:00

I have drunk the koolaid, and it is purple and orange. Swirled. Without mixing. Because magic.

I thought JetBrains just made Eclipse knockoffs until I started watching the short AngularJS tutorials at egghead.io. Resident guru John Lindquist wields WebStorm like a syntax-highlighted scalpel, flying through line after line of auto-generated code as easily as most of us breathe. I got excited just watching. The AngularJS tutorial content is great too, but that editor. I'm fast in vim, but not that fast.

On the other hand, WebStorm doesn't really touch my mostly-PHP day job. Enter Mathias Verraes and his refactoring tutorial in PHPStorm. Same blazing speed and mobility as WebStorm, but now with PHPUnit integration and coverage reports! Insanity. I caved. Down the rabbit hole I went.

Feet get wet

My base OS is Windows, so I do a lot of work in local Linux virtual machines. Fortunately, PHPStorm has lots of options for talking to remote servers. I mounted the VM project directory on my host with win-sshfs and chose PHPStorm's Remote server, mounted drive option when I created the project. Pretty progress bar, couple spinny cursors, and I was in. The very first tip-of-the-day (don't turn them off!) told me to check out the tool shortcuts in the bottom left corner:

Project, TODO, Favorites, blah blah, Database--wait, what?

Choose that Database option, and you'll get a full data source manager, supporting about a dozen engines. I plugged in the settings for my VM's MySQL database, hit Connect, and...it didn't work!

Why is it ignoring my database?!

This particular VM was running Debian Wheezy. MySQL configuration defaults may be different for other distributions, but here's what I had to do to get PHPStorm and MySQL talking:

Don't use `bind_address`

By default, MySQL binds to (i.e. only accepts connections from) 127.0.0.1. You want to connect from your VM host, so comment out the bind_address line in your MySQL configuration (/etc/mysql/my.cnf):

(Note that you should not do this on any machine that's accessible from outside your local network. It's bad. It's so bad.But we're working with a local VM right now, so we don't care!)

Create a user with privileges to connect from anywhere.

Again by default, MySQL's root user only has local connection privileges--it can't connect from outside the VM. If you don't have one already, you'll need a MySQL user that can connect from your VM host:

create user 'gemma'@'%' identified by 'yourpassword';
grant all privileges on *.* to 'gemma'@'%' with grant option;

Restart MySQL

Restart the MySQL server to apply the configuration changes:

sudo service mysql restart

Bringing back the romance

Now that MySQL is behaving itself, we can work on PHPStorm. Pull up that Database tool window from before and create a new MySQL data source: Green plus sign (or Alt + Insert) → Data Source → MySQL

In the window that appears, plug in your connection settings.

If you haven't already, click the link to download the driver files. It's painless; PHPStorm does it all in the background.
Host and Port should match the connection information for your VM. I have a hostname set up (myvm.local), but you could just as easily use a raw IP address.
Database should be the name of the MySQL database you'll be using for this project.
The user credentials should match the new user you created above.

Wedded bliss

That's it! That empty Database manager should now be populated with all the content from the database you specified. You can view tables, run queries, create diagrams--really everything I normally do in an external client. Pretty slick.

(If you want to keep going, check out the PHPStorm Data Source documentation!)

on algorithms and boundaries

2013-08-25T14:04:00-06:00

I'm taking the Algorithms I class from Coursera that just started up again. (I'm going to finish it this time.) (No really!) The first programming assignment has students building a Monte Carlo simulation for the percolation problem, using a weighted quick-union algorithm. We'd already covered union finds and the internals of a WQU during the lectures and exercises, so the assignment focused on applying it efficiently.

I built a slow prototype that mostly worked, then made it a decent amount faster, then fixed an edge case that I'd broken while making it faster, then got stuck. My solution still mostly worked--the gist was there--but it was partially wrong, and I couldn't even conceptualize a fix without at least doubling the memory or runtime. Which, obviously, would be wrong. Right? I mean, I spent six years in C. Performance is everything.

I even slept on it. Nothing.

Feeling fairly stupid, I started procrastinating on the class forums and stumbled over a thread that directly addressed the problem I was trying to solve. Most of the comments went something like this:

Yeah, I couldn't even get close to 100% [grade] until I doubled the memory used.

Wait, what? They doubled the memory..and it was ok? WAIT A SECOND.

I went back to the automated feedback from my best attempt (a mere 87%) and checked the details of the memory usage tests. Sure enough, I was using less than half what the assignment allowed. I re-submitted my solution with the doubling-memory, solving-the-whole-problem tweak: 100%.

Lesson learned: Don't start rejecting solutions until they overflow the actual boundaries of the problem. Speed for speed's sake, or memory for memory's sake, or LOC for LOC's sake, or whatever imaginary boundary you've constructed for yourself ends up being just a waste of time if you can't get the rest of it done.

more fun with btsync

2013-08-23T00:04:00-06:00

I've already gushed over the amazingness that is btsync, but it just solved another problem for me, so here I am again.

My new VPS provider (yes, that is an affiliate link; sue me) recently announced that their backup interval would be increasing from weekly to monthly. I'm coming from a daily backup environment, so weekly was already uncomfortable; it was time to set up my own backup system. But my primary machine (and therefore backup host) is Windows--am I supposed to set up some kind of rsync service? Muck about with Scheduled Tasks? Ugh. Headaches all around.

But wait! btsync to the rescue!

I set up a little cron.weekly job to drop the content I want saved into a bz2 tarball

/bin/tar -cjpf /path/to/vps-backup-folder/backup.tar.bz2 \
    --exclude='skip-this-folder' --exclude='vps-backup-folder' \
    --exclude='.SyncArchive' /home/me /etc /path/to/webroot /var/log
/bin/chown me:me /path/to/vps-backup-folder/backup.tar.bz2

and (wait wait, I bet you can guess) registered /path/to/vps-backup-folder as a btsync source. Now my VPS backups will sync (encrypted!) to any client with the key, whenever they happen to come online. And as a bonus, btsync's own backup system (in .SyncArchive) will hang on to old versions of the backup tarball for as long as I specify.

Really, this stuff is magic.

(I did briefly investigate tar-based incremental backups, but I don't want to store every increment ever from the beginning of backed-up time. It'd be a particularly ridiculous degree of overkill.)

who left the burner on?

2013-08-12T13:37:00-06:00

Researchers in Uppsala, Sweden, accidentally left a reaction running over the weekend and ended up solving a century-old chemistry problem. Their work has led to the development of new material, dubbed Upsalite, with remarkable water-binding properties. Upsalite promises to find applications in everything from humidity control at home to chemical manufacturing in industry....

When one mixture was accidentally allowed to react over a long weekend, researchers came back to find a gel. It turns out the gel was formed because methanol molecules had been trapped within the material. When heated to 70°C, which is above the boiling point of methanol, the gel “solidifies and collapses into a white and coarse powder.”

(source)

Jane, entering the lab and flipping the lights, glances around the room: Erm.
John, following behind, yawning: What?
Jane, inching toward a table covered in a blue gelatinous substance: Did you leave the burner on Thursday night?
John, yawning: Me? No way, I left early.
Jane: We all went for drinks. I don't remember who was the last out.
John: Why, what happened?

Jane points at the blue goo.

John, eyes widening: What the hell is that?
Jane: Not what it's supposed to be, I can say that much.
John approaches the table warily: How'd that happen? Which reaction was this?
Jane: I think it was Fred's magnesium oxide mix.

Jane and John ponder the accident in silence.

Jane, pulling on rubber gloves and a set of safety goggles: Say, whaddya think'll happen if we heat it up some more?

Whoops, science!

btsync, where have you been all my life

2013-08-10T01:55:00-06:00

Well, that was easy.

I've been using KeePass for password management for roughly five years, ish. I like that it's free, that it runs on all my devices and that it integrates with any password-protected application (not just my browser). Syncing the database to all said devices, on the other hand, has always been a minor headache. I don't want to rely on free cloud storage providers, so I substitute various incarnations of personal servers, and I sacrifice the nifty auto-syncing clients. I could run something like SparkleShare, but that seems like overkill for one lousy file. I also disable password authentication over SSH, so the native KeePass syncing capability is out--which isn't that big of a deal, because it doesn't work in the Android port anyway. Long story slightly less long, I've been mixing KeePass database triggers with a remote cron job and an Android port of rsync for a couple years.

So today I found BitTorrent Sync.

mind|blown

Oh my word, people. I can't even tell you. It's amazing.

You hand it a folder to sync, it hands you a 21-character key (password). The key uniquely identifies your sync folder. Any other btsync peer (computer running the syncing client) with the key can sync from the folder, and no peer without the key can even see it. The actual content transmission is just like regular BitTorrent, except with 256-bit AES encryption (based, again, on the folder key).

If you're running behind a LAN, that's all you need. Just btsync peers and a shared key, no external servers necessary.

If you're outside a LAN, you can enable MAGICAL THINGS: btsync can send a one-way hash (SHA-2) of your key up to a BitTorrent tracker, and match up peers by matching up hashes. It's brilliant. The hashes can't be forged (at least until somebody breaks SHA-2), and the original keys are needed for decryption. There are millions of hashed keys hanging out on the trackers right now, looking for matching peers, completely secure. Once the tracker matches up some peers, it's done; it never sees the synced data, encrypted or otherwise, because the peers talk to each other directly.

As a bonus, the btsync client does local backups by default. It'll automatically keep 30 days worth of version history. I just replaced my KeePass triggers, my cron job and my Android rsync with one tool, without handing any of my data to a third party.

Install

Per usual, setting up the Windows and Android clients is a fairly brainless process; setting up a Linux client is a little more exciting. Here's what I did on my Ubuntu 13.04 server:

We don't set things up manually in Ubuntu, son!

Use the PPA:

$ sudo add-apt-repository ppa:tuxpoldo/btsync
$ sudo aptitude update
$ sudo aptitude install btsync

(If you're on a version of Ubuntu that didn't come with add-apt-repository, you can grab it from the software-properties-common package. I mention this only because when I was on 12.04, it took way too long to find.)

Configure

apt will throw some preliminary config options at you and start the btsync client in daemon mode; you can configure more things after the install is complete (check the main Debian/Ubuntu instructions and the user guide for details):

$ sudo dpkg-reconfigure btsync

dpkg-reconfigure saves your settings to a read-only configuration file at /etc/btsync/debconf-default.conf. You can create as many syncing profiles as you want; just stick them all in /etc/btsync. I ended up copying the defaults to a new profile specific to my user (/etc/btsync/gemma.conf), borrowing more settings from the /etc/btsync/user-new.conf sample:

//!/usr/lib/btsync/btsync-daemon --config
//
// in this profile, btsync will run as my user ID
// DAEMON_UID=gemma
//
{
        "device_name": "my server",
        "storage_path" : "/home/gemma/.btsync",
        "listening_port" : 12345,
        "check_for_updates" : false,
        "use_upnp" : false,
        "download_limit" : 0,
        "upload_limit" : 0,
        "disk_low_priority" : true,
        "lan_encrypt_data" : true,
        "lan_use_tcp" : false,
        "rate_limit_local_peers" : false,
        "folder_rescan_interval" : 600,
        "webui" :
        {
        },
    "shared_folders" :
    [
        {
            "secret" : "my folder key",
            "dir" : "/path/to/my/synced/folder",
            "use_relay_server" : true,
            "use_dht" : false,
            "search_lan" : false,
            "use_sync_trash" : true
        }
    ]
}

Most of that's pretty boring, except:

I disable upnp and set a specific listening port so I can easily control access with my firewall (ufw).
I disable the built-in web UI, because no.
This client is running on my remote server, so I enable LAN encryption and the relay server, and disable LAN searching.

Once you've got your profile(s) set, you can control which one(s) btsync loads with the /etc/default/btsync config file. By default it loads all the profiles in /etc/btsync, but I want it to only load profiles I specifically request:

# just load gemma.conf, nothing else
AUTOSTART="gemma"

Wait wait wait

Make sure your profiles are readable by the user in DAEMON_UID! The btsync client is still pretty young, there's not much (read: any) logging, and if it can't read the configuration file, it'll just fail silently.

$ sudo chown gemma:gemma /etc/btsync/gemma.conf

At the same time, the profile has your folder key in it, so protect it:

$ chmod 600 /etc/btsync/gemma.conf

Let 'er rip

The btsync package is automatically hooked into upstart, so this part's easy:

$ sudo service btsync start
 * Starting P2P file synchronisation daemon(s)...
 * Autostarting btsync instance 'gemma'
$ service btsync status
 * BTSYNC 'gemma' is running

That's it. The sync folder(s) listed in the gemma.conf profile will now sync with any and every matching peer (in my case, a desktop, a laptop and a smartphone).

Happy syncing!

casedCamels and underscores

2013-03-09T23:35:00-07:00

Ah, coding styles. A favorite holy war. Are your braces one true or K&R? Is your indenting tabbed or spaced? Are your variables underscored or camelCased? In my case, respectively K&R, spaced and camelCased — but that's just my preference. It's not like any one style is objectively better than any other. Let's all just get along, people.

Unless you're CompSci researchers in Maryland, in which case you should do a study:

A family of studies investigating the impact of program identifier style on human comprehension is presented. Two popular identifier styles are examined, namely camel case and underscore. The underlying hypothesis is that identifier style affects the speed and accuracy of comprehending source code.

Essentially, they're asking if getValue() is easier to read than get_value(), which somehow, despite decades of flame wars, has never been formally asked. Here's the really interesting part:

If reading source code and reading natural language are substantially the same undertakings, then a significant body of foundational research on natural language can be used as a basis for program com-prehension studies.

Whether myValue is better than my_value is interesting enough on its own, but the real value of the study is in tying the comparison to existing principles for reading in general. If reading code is like reading prose, programmers could theoretically adapt and use the same techniques to improve code comprehension that teachers use to improve prose comprehension. Maybe you're awesome and reading others' code comes naturally to you; I'm not, and it doesn't, so I'll take all the help I can get.

The researchers expected that existing natural language comprehension principles would apply to code comprehension; specifically, that text with some kind of spacing between words (like_this) is easier to read than un-spaced text (likeThis). They ran an interdependent series of experiments on about 170 college-age programmers (mostly male, roughly even mix of style preferences), gauging response time and correctness. All the experiments were modeled after natural language predecessors, which fits with the overall attempt to correlate prose and code comprehension:

Find an identifier in a cloud of similar identifiers
Find all the occurrences of an identifier in a code fragment
Answer SAT-style questions about a prose snippet displayed with underscores or camelCasing.
Same concept as #3, but with code instead of prose.
Track eye movements while reading and verbally summarizing code fragments.

In general, the results were unexpected. Naming style didn't really affect comprehension for experienced programmers, while beginners seemed to do better with camel case than underscores (the opposite of prose comprehension):

In particular, the visual effort for short identifier names (e.g., rowSum) appears to be greater when using underscores. One possible explanation is that programmers chunk such short phrases into one concept because they are common concepts in the problem or solution domain (e.g., rowSum, xAxis). Thus, the use of underscore gets in the way of understanding these identifiers....the result of comprehension is a program plan with the specifics of the syntactic features filtered out rather than a rote memorization of the exact program text.

The theory is that since code already has a fairly structured form, comprehension is less about reading the words and more about recognizing the conceptual units. (Those of us who use i, j and k for array indices probably have no trouble swallowing that idea.) The studies demonstrate handily that reading code is not a parallel for reading prose — which, though it means we don't get to automatically apply all the cool natural language research to what we do, opens up massive potential for future research.

monobar gets a monomenu

2013-02-10T09:27:00-07:00

Way back in the dark ages of less than a year ago, I read what was to become a classic Linus Torvalds rant on the inadequacy of Github pull requests. Afterwards, I started seeing it everywhere: text boxes that tell me nothing about the text! I mean really, the nerve. How am I supposed to write pretty text for ancient, barely-used applications like Lynx and mutt if I have no idea what the text is doing?! SOMETHING MUST BE DONE.¹

Doing something!

So I made a Chrome extension. When you're in a text field (specifically a <textarea> field, so things like search boxes don't count), it pops up a little bar with information about whatever you're writing.

Nobody uses it besides me, as far as I know, so clearly it needed more bells and whistles.

Doing more

Yesterday I added a bell (or possibly a whistle). Does it drive anyone else bonkers that Gmail has you typing supposedly plain-text emails in a proportional font? No? Nobody? Really? Well, fine, I hope you all enjoy your irritation-free lives; I'll be over here growling about the latest Facebook redesign AND enjoying my new context menu item that toggles whatever I'm typing between monospace and proportional fonts.

It works on anything editable, not just Gmail composition windows. (Technically it doesn't toggle monospace off, exactly. It just flips between monospace and whatever the parent element's font is.)

The guts

Setting up the context menu item ended up slightly more complicated than I was expecting, mostly because Chrome context menus don't actually know anything about where they were clicked from. They can tell you the tab, and the page URL, and information about the menu itself, but they have no clue which piece of the website you clicked.

To get around that, I had to both create the context menu item and check for global contextmenu events, which are fired whenever the user gets a context menu. Javascript events know where they were triggered, so combining the global event with the click on the menu item itself let me grab the element:

/* When any context menu pops up */
var editable = null;
document.addEventListener("contextmenu", function(e) {
    editable = e.target;
}, true);

/* When the 'Toggle monospace font' item is clicked */
function changefont(info, tab) {
    var element;
    chrome.tabs.sendMessage(tab.id, 'monobar-changefont', null);
}

That sendMessage call is really where the magic happens. Now that I've got both events, they have to talk to each other. Clicking the menu item sends a monobar-changefont message, so I listen globally for monobar-changefont messages:

/* Do things when the monobar-changefont message comes in! */
chrome.extension.onMessage.addListener(function(message, sender, response) {
    if (message == 'monobar-changefont') {
        /* This message only comes in if a context menu is up, so
         * get 'editable' from above and muck about with it
         */
    }
});

The whole sendMessage rigamarole is only necessary because content scripts are distinct from background scripts, and getting them talk to each other is slightly less straightforward than "Hey, gimme the element!" Regardless, it was massively fun to learn, so go grab the final product and MONOSPACE ALL THE THINGS.

Drama added for emphasis. ↩

solving problems with threads

2013-02-08T00:00:00-07:00

A programmer had a problem. He thought “I know, I’ll solve it with threads!”. has Now problems. two he

leonsbuddydave

Still giggling, fifteen minutes later.

pernicious kingdoms

2013-02-03T11:25:00-07:00

From Seven Pernicious Kingdoms: A Taxonomy of Software Security Errors

One of the first studies of computer security and privacy was the RISOS (Research Into Secure Operating Systems) project [in 1976]. RISOS proposed and described seven categories of operating system security defects...:

Incomplete Parameter Validation

Inconsistent Parameter Validation

Implicit Sharing of Privileges / Confidential Data

Asynchronous Validation / Inadequate Serialization

Inadequate Identification / Authentication / Authorization

Violable Prohibition / Limit

Exploitable Logic Error

The study shows that there are a small number of fundamental defects that recur in different contexts.

Heh. You could say that, yes. Here we are, 40 years later, dealing (or more often, failing to deal) with exactly the same problems. How long were people starting cars with hand cranks, ten years? Fifteen?

a todo list for pelican

2013-02-01T20:01:00-07:00

I'm loving Pelican. Naturally I want to change it all.

Favicons

Not that modifying the theme base.html is hard, but the process could be easily automated, so it's a good candidate for built-in functionality. Everybody uses favicons. Give Pelican a FAVICON_PATH variable in the configuration, and the engine copies the file to some constant location for themes to pick up and <link>. Easy. (Also, seriously, how awesome is my little boat? I'll tell you: pretty awesome.)

Minification

Pelican is a static site generator, so automatically minifying CSS and JS source files seems like a no-brainer. Of course, that's because it is a no-brainer, and has already been done. Hurrah for the internet.

Git integration

Technically this isn't a Pelican item so much as a "make my git hook cooler" item: I want to pull post entry dates from the git commit author date, and tags from the commit message. Seems simple enough, but it gets complicated when you consider the entire change history of an entry. Wheat, a git-based blog engine I tried briefly, handles entry changes by giving the reader literally every change ever made in a clickable list. (With a commit hash and everything, it's pretty wild.) The design makes sense for a wiki-style site, heavy with community content and editorial oversight, but gets a little cumbersome for a personal blog. (I'm ok with readers not seeing every typo I'll ever make, thanks.)

My version would be more boring: Find the commit that added the entry, and use that GIT_AUTHOR_DATE as the initial entry date. It could even find the commit that most recently changed the entry, and add some kind of Updated on foobity bar date footer.

Pulling tags from commit messages could be similarly straightforward: Parse the messages in every commit that changed the entry for whatever the tag pattern is, and add all the tags found. Throw in some kind of lexical mechanism for identifying tags removed (maybe -tag instead of just tag?), and turn the result into a tag list.

Speaking of which

My post-receive now handles multiple branches. Since the Pelican Makefile is part of each branch, publishing a draft is as simple as git checkout draft && make html (or rather, just pushing draft, since the hook takes care of the rest). Along the same lines, incorporating draft changes in the live site is as simple as merging draft to master.

function publish {
    branch=$1

    cd $pelicanweb
    git checkout -fq $branch && git fetch && git reset --hard origin/$branch
    if [ $? -ne 0 ]; then
        echo 'git broke, go check the configs or something'
        exit 1
    fi

    make html && echo "$branch changes live"
}

unset $(git rev-parse --local-env-vars)

while read oldrev newrev ref
do
    branch=`echo $ref |cut -d/ -f3`
    publish $branch
done

IT'S ALIVE

2013-02-01T13:10:00-07:00

Finally. At long last. The domain is pointing where it's supposed to be pointing, the design looks the way it's supposed to look (more or less), and nginx is even rewriting what it's supposed to be rewriting. Maybe. I think. Not all the DNS is propogated yet, so we'll see. But the uncertainty won't keep me from DANCING!

deploying pelican with git

2013-01-06T15:06:00-07:00

One of the things I love about git is how easy it makes website deployment. Stick all your versions (production, development, test, yadda yadda) in different branches, push to a bare repo on the server, and set up your post-receive hook to put the right versions in the right places by checking out individual branches to different working directories. Bam, done.

I would have set up pelican the same way, except I want to be able to make changes directly on the server. Technically, what I should have done is create the bare master repo, point the detached checkout to wherever I want the live site, and make a separate local clone as my on-server work area. (Really pelican content isn't live, per se, but it generates the static files that are, so close enough.):

Master repo: /path/to/pelican-master.git
Work area: /path/to/pelican-work
Live area for detached checkout: /path/to/pelican-live

What I did instead was create the on-server work area (the local clone) where the detached checkout would normally be:

Master repo: /path/to/pelican-master.git
Work area: /path/to/pelican-live
Live area for detached checkout: same as the work area!

Seemed like a good idea at the time, because it cut down on random arbitrary directories of zillions of copies of the same files all over the place, but I broke the whole detached checkout idea. If pelican-live is already a repo, I can't really use it as the detached working directory for the master repo. My clean and clear post-receive hook is now an unholy hash of checkout -f/fetch/reset nonsense:

if [ "master" == "$branch" ]; then
    cd $pelicanweb
    git checkout -fq $branch && git fetch && git reset --hard origin/$branch
    if [ $? -ne 0 ]; then
        echo 'git broke, go check the configs or something'
        exit 1
    fi

    make html && echo 'Changes live'
fi

On the other hand, it's working, and I want to go play with CSS.

how to walk through a door

2013-01-06T08:30:00-07:00

Let's say I am giving directions for how to leave this room. In Python, I would just say something like 'Get up and go through the door. In other languages, I might have to say something like, 'Stand up, but not with so much force that you fall over, take three steps to the north, take one step to the east, approach the door, check that it is not open, if it is not open, open it, then step through it with this amount of speed...'.

Guido van Rossum

hello, world

2013-01-05T21:30:00-07:00

I started Early -- Took my Dog --
And visited the Sea --
The Mermaids in the basement
Came out to look at me --

And Frigates -- in the Upper Floor
Extended Hempen Hands --
Presuming Me to be a Mouse --
Aground -- opon the Sands --

But no Man moved Me -- till the Tide
Went past my simple Shoe --
And past my Apron -- and my Belt
And past my Boddice -- too --

And made as He would eat me up --
As wholly as a Dew
Opon a Dandelion's Sleeve --
And then -- I started -- too --

And He -- He followed -- close behind --
I felt His Silver Heel
Opon my Ancle -- Then My Shoes
Would overflow with Pearl --

Until We met the Solid Town --
No One He seemed to know --
And bowing -- with a Mighty look --
At me -- The Sea withdrew --