md2pdf: Markdown to PDF

You can download md2pdf on Github. Installation instructions can be found in the README. Usage is extremely simple:

$ md2pdf my-markdown-document.md

How it was made

This utility is actually pretty silly. It simply serves as a glue between
markdown2, which takes Markdown and produces HTML, and xhtml2pdf, which takes HTML and produces PDFs. The script uses a system call because the xhtml2pdf interface is non-trivial. Consequently, you’re probably better off not using this on a production server.

Related Posts:

• PyQuery Tutorial: Basic HTML Parsing with PyQuery
• Daily Contact Form Tests with Python and Cron
• Install PyQuery under Cygwin

Enter Kazam!

Thanks to some more strict queries on Google, I found Kazam on AskUbuntu.com.

It has an extremely simple interface, as seen below.

The quality is just fine for simple screencasts, and it allows you to record audio that actually syncs with the video!

Installation

First, we need some Python modules to be installed.

$ sudo apt-get install --reinstall gir1.2-gtk-2.0 python-software-properties software-properties-gtk

Now we actually grab Kazam as instructed by their site.

$ sudo add-apt-repository ppa:kazam-team/stable-series
$ sudo apt-get update
$ sudo apt-get install kazam

And you’re done! You can run kazam via the command line or your distro’s menu.

Extras

If you happen to have FFMpeg installed, here’s a nice 2-pass video/audio encoder script that encodes with H.264.

Related Posts:

• Dual Monitors on Kubuntu 11.10 (In Under 10 Minutes)

Activating VI Keybindings

To get VI keybindings working in your shell, simply execute

$ set -o vi

(If you decide you like vi keybindings in the shell and you want this mode enabled upon shell startup, append the command to your ~/.bash_profile for OS X and ~/.bashrc for linux ((Why the difference?))

Using the VI Keybindings

The shell will have normal/insert mode as expected. Here are the commands I use frequently:

i - enter insert mode
esc - back to normal mode

* IN NORMAL MODE *
cc - clear the current line and enter insert mode
 C - clear from cursor until the end of the line and enter insert mode
dd - delete the current line
 D - delete from the cursor until the end of the line
 w - next word
 W - next white-space delimited word
 b - previous word
 B - previous white-space delimited word
dw - delete word
cw - change word
fx - find the next occurrence of the character 'x'
Fx - find the previous occurrence of the character 'x'
 $ - move the cursor to the end of the line
 0 - move the cursor to the beginning of the line
 ; - repeat last find command (preserves direction)
 l - move cursor right
 h - move cursor left
 k - scroll up through command history
 j - scroll down through command history
 A - move the cursor to the end of the line and enter insert mode
 I - move the cursor to the beginning of the line and enter insert mode

* Numeric modifier keys work as well! *
5W - move forward five white-space delimited words. 

Related Posts:

• Git Workflow: Crap, I committed to master!
• Productivity Tip: Your Hosts file is Just Barely Annoying Enough
• Start VIM in File Navigation Mode
• Overcome Programming Apathy

http://www.youtube.com/watch?v=CboUF7gtVSo

Related Posts:

• Introduction to Recursion – Part 1
• Nginx, PHP-FPM Installation Guide on Ubuntu 10.04

The Stupid Table Sort!

Consequently, I embarked on a journey to create a stupidly simple jQuery table sort plugin. Remaining true to that, I’ve named the plugin the Stupid jQuery Table Sort. Flattering name, I know…this is why I’m not a marketer.

Check out the demo!

View the demo, and let me know what you think!

Related Posts:

• A Break from jQuery
• A jQuery Development Pattern
• jQuery Sticky Scroller / Position:Fixed Plugin
• .arrayShift() jQuery Plugin
• jQuery .swap() Plugin

Sometimes, however, I get in the zone and forget to checkout a branch because I want to get this feature DONE! In my haste, I commit to master directly. I don’t want my pull request to be rejected just because I hacked on master.

What do we do now?

Luckily, recovery is extremely simple. We can fix the repo up to get back in line with branching best practices.

So say we’ve just committed to master and we’re currently on the master branch.

$ git log
commit 9huuh23tnhubazhuxbeeashebcdjis3hl2iidu
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 22:15:10 2012 -0500

        Refactor new feature X to be more awesome

commit xotnhnt234ub23st2b323hb23tu2bh32bu23uu
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 22:05:10 2012 -0500

        New feature X

commit b232udh24xub2394d249ud394ub34bu9348ub9
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 12:05:10 2012 -0500

        Some upstream master commit

The last two commits needed to be on their own branch, say new_feature. Your local master branch needs to be at “Some upstream master commit”. Here’s how we can accomplish this.

Step 1) Create the new_feature branch

Since master is currently in the state we want the new_feature branch to be in (since we’ve just added our new feature commit), we can just branch off of master.

$ git branch new_feature

So new_feature is just a direct copy of master at this point.

Right now, we’re still on the master branch. As stated above, we want the master branch to be at “Some upstream master commit”. We can accomplish this via git reset –hard.

Step 2) Resetting the master branch

A side note regarding git reset –hard:

It’s important to note that git reset –hard is NOT a safe operation. You CAN lose work if you don’t use it carefully. Luckily, in this context, there’s nothing to worry about since I’m guiding you through the process…but just for your toolbelt, visit this StackOverflow answer thread if you ever accidentally lose work to git reset –hard.

Anyway, to get the master branch back to “Some upstream master commit”, we can copy the SHA of the commit from git log to our clipboard and execute

$ git checkout master
$ git reset --hard b232udh24xub2394d249ud394ub34bu9348ub9
HEAD is now at ... Some upstream master commit

Also, for convenience, we can use the HEAD alias. In this example, we wanted to reference the commit that was 2 commits behind the latest commit. We could have equally executed

$ git checkout master
$ git reset --hard HEAD~2

The git log should now look like the following:

$ git log
commit b232udh24xub2394d249ud394ub34bu9348ub9
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 12:05:10 2012 -0500

        Some upstream master commit

Step 3) Verification

We’ve verified the master branch is where it should be, so now we should checkout the new_feature branch and run a git log.

$ git checkout new_feature
Switched to branch 'new_feature'
$ git log
commit 9huuh23tnhubazhuxbeeashebcdjis3hl2iidu
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 22:15:10 2012 -0500

        Refactor new feature X to be more awesome

commit xotnhnt234ub23st2b323hb23tu2bh32bu23uu
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 22:05:10 2012 -0500

        New feature X

commit b232udh24xub2394d249ud394ub34bu9348ub9
Author: Joseph McCullough <joseph@vertstudios.com>
Date:   Wed Apr 11 12:05:10 2012 -0500

        Some upstream master commit

So we still have our work, but it’s on a feature branch, as it should be! We’re now free to send a pull request without any bickering from the project owner, or we can merge the new_feature branch later once it’s ready for production.

Related Posts:

• VI Keybindings in your Shell
• Stop Annoying your Git Collaborators
• Start VIM in File Navigation Mode
• GitHub API – Get Latest Commit Details (PHP)
• Overcome Programming Apathy

The Problem!

Consider a very simple example.

// Example demonstrating C pointer ambiguity
#include<stdio.h>

typedef struct{
	char* job;
	int age;
} Person;

void give_bob_a_job(Person*);

int main(){
	Person bob;
	give_bob_a_job(&bob);
	printf("The job of bob is %s\n", bob.job);
        return 0;
}

void give_bob_a_job(Person *bob){
	*bob.job = "Sysadmin";
}

We compile the file

~$ gcc bob.c -o bob.o
bob.c: In function ‘give_bob_a_job’:
bob.c:18:6: error: request for member ‘job’ in something not a structure or union

So we receive the error error: request for member ‘job’ in something not a structure or union.

We run through a mental checklist:

• Did I pass a pointer to the right structure?
• Does that structure really have a ‘job’ member?
• Did I make any typos in declaring the member or calling the member?

If all these check out, then we move on.

Let’s look closer at the statement on line 18.

*bob.job = "Sysadmin";

This actually reads

‘Assign the string “Sysadmin” to the pointer variable of bob.job’

In other words, the deference operator (*) is dereferencing all of bob.job instead of dereferencing bob and accessing its job member. In this context, bob is just a pointer to Person, so it’s a memory address. Thus the compiler error makes sense!

Luckily, the solution is super simple.

The Solution!

We can be explicit about our dereferencing by using parenthesis.

(*bob).job = "Sysadmin";

This reads

‘Assign the string “Sysadmin” to the pointer variable of bob’s job member’

Replace line 18 with the correction, and the code should compile with the following output upon execution:

The job of bob is Sysadmin

Syntax cleanup

Dereferencing a pointer to a structure is so common, we have a shorthand for doing so.

(*foo).bar

is equal to

foo->bar

so

bob->job = "Sysadmin";

would work as well.

Related Posts:

• K&R: Error: conflicting types for ‘getline’
• Introduction to Pointers in C++ Tutorial
• C++ Sentence Case (Capitalize First Word)
• Removing punctuation and spaces from a String in C++
• C++ Capitalize Each Word (Proper Case)

http://www.youtube.com/watch?v=TA_qrRZ1cpI

Related Posts:

• Nginx, PHP-FPM Installation Guide on Ubuntu 10.04

The beginning of the sample program is as follows:

#include <stdio.h>
#define MAXLINE 1000   /* maximum input line size */

int getline(char line[], int maxline);
void copy(char to[], char from[]);

/* print longest input line */
main()
...

And, to your confusion, you receive the following error: Error: conflicting types for ‘getline’

The Solution!

It turns out getline is included in stdio.h, similar to printf! You can complete the exercise by renaming the getline function to something different like “readline” or “get_the_line”.

Related Posts:

• C: request for member in something not a structure or union
• Introduction to Pointers in C++ Tutorial
• C++ Sentence Case (Capitalize First Word)
• Removing punctuation and spaces from a String in C++
• C++ Capitalize Each Word (Proper Case)

Installing Dual Monitors on Kubuntu 11.10

Make sure you have the latest Nvidia drivers. To do this, Navigate to “Additional Drivers” via Applications => System => Additional Drivers.

Now execute the following commands in your terminal in order to get disper, a nice utility that saves us from the headache of configuring via Nvidia-Settings.

$ sudo add-apt-repository ppa:disper-dev/ppa
$ sudo add-apt-repository ppa:nmellegard/disper-indicator-ppa
$ sudo apt-get update
$ sudo apt-get install disper disper-indicator

(Credit to Joey Conway)

Verify that disper works by executing the following in your terminal:

$ disper -e

This should extend your monitors, giving you the desired functionality. This is great, except for currently we’d have to do this every single time we boot up Kubuntu.

Activate Disper on Startup

My first instinct, being slightly familiar with Ubuntu, was to create a startup script in /etc/init.d. This, however, didn’t seem to work. Instead of creating a script in the init.d directory, we’ll create the script in a Kubuntu-specific directory called Autostart.

First, navigate to the Autostart directory:

$ cd ~/.kde/Autostart

Now using your favorite text editor, create a script called dual-monitors

$ vim dual-monitors

Paste in the following:

#!/bin/bash
/usr/bin/disper -e

Save the file and quit the text editor. We now need to make the file executable or it will just be ignored by Kubuntu on startup.

$ chmod +x dual-monitors

To verify the script works, we first need to get out of our current dual screen mode to make sure the script correctly puts us back in. Thus, we use disper to force only the primary display to appear.

$ disper -s

Your 2nd monitor should deactivate. Now, while we’re still in the ~/.kde/Autotest directory, execute the following:

$ ./dual-monitors

If this causes the monitors to go back to dual-screen mode, then the script works! T

Now you have Dual Monitor Suuport!

Go ahead and restart your computer, and you should find that Kubuntu starts with your dual monitors functioning correctly.

Related Posts:

• Ubuntu Screencast Software for 11.04+
• Nginx, PHP-FPM Installation Guide on Ubuntu 10.04
• Multiple .screenrc Configurations | GNU Screen Tutorial
• Snippet: What Linux Distro is Running?
• Remove All Ruby Gems (Ubuntu)