Leap Empty-Handed into the Void @jondbaker-blog - Tumblr Blog

Bash CDPATH customization

I love The Bourne Again Shell; so much so, that I feel a little dirty when I grab my mouse outside of Photoshop. Admittedly and somewhat understandly, I was slow as shit at first with the terminal. The slow-lived frustration and swearing against all things Linux was worth it though, and now I can't imagine my workflow not including a terminal.

Just as the PATH variable allows you to specify paths to exectuables, CDPATH allows you to specify paths to directories. This is great if you're not a fan of manipulating the Bash directory stack and have a few directories that you want to be able to easily jump between. To make this happen, add a simple export directive to your .bash_profile...

~/.bash_profile

export CDPATH=$HOME:$HOME/python

... and then tell Bash about the update (without having to restart it)

$ . ~/.bash_profile

This is great because it allows me to quickly navigate to ~/python/django, ~/python/tkinter, etc. without needing to mess with periods, forward slashes or simply remembering where the hell I am. I simply need to type

$ django

... and after Bash realizes that 'django' isn't a child of my working directory, it will find the .bash_profile directive and voila. Laziness is good.

#bash

Resurrection

...but not the creepy kind that involves a bearded zombie and rabbits. Last summer I purchased a gorgous british racing green Surly Pacer from Salvagettis in Denver and I loved every minute of riding the shit out of that bike. It was sexy, steel and damn fast cruising along downtown streets or Cap Hill. Then, a few weeks ago someone decided to turn through an intersection while I had a green light and they totaled the Surly frame and some other parts. Salvagettis reused what they could to rebuild a new Pacer, this time in Sparkleboogie Blue. I'm a fan:

#surly #salvagettis #not jesus

Mountains

I absolutely love living in Denver, largely because I have access to the following types of views less than an hour from the city. This makes much-needed escapes from work quite easy and effective.

Approaching the south ridge of Mt. Bierstadt.

A meadow southwest of Mt. Bierstadt.

Varietal Updates

I finally wrapped up (more or less) the Django project that's been hogging my time for the last sick weeks, so I'm anxious to get back to posting regularly. Working with Python and Django has been a blast, and to say I learned a lot on the project would be a drastic understatement. I'll post more details once the project goes live.

SafeHouse Denver

I've been doing minor updates to the current http://www.safehouse-denver.org/ site for a little over a month now, and so far it's been a good experience. The organization does great work, and next on my volunteer agenda is a mobile site that we'll launch within the next few months.

Structure and Interpreation of Computer Programs

This book has been on my list for a while and I'm excited to finally have time to start it. The MIT press hosts an HTML version of the entire book available here: https://mitpress.mit.edu/sicp/full-text/book/book.html. Functional programming is quite different from the imperative languages I've been exposed to thus far, so I'm excited to get my hands dirty. I'm almost done with the first chapter, and it's ridiculous how much I've learned so far.

Core Python Application Programming

As with SICP I'm still on the first chapter of this one which dove straight in to regular expressions. I find strange enjoyment in writing regexs, but I'm anxious to start chapter two which introduces network prorgramming with Python. Mmm summer reading.

Pique

I desperately need to update the site with completed projects from the last few months. I'm tempted to put together a new template though and also integrate a responsive framework for mobile devices. Overall, business is good and I'm currently in the middle of porting bullandbush.com to Drupal from it's proprietary Rails CMS. It's always great to team up with local companies, and when the local company is a brewery the deal is that much sweeter.

Setup the Tor browser bundle on Ubuntu

With no signs of the US government relenting it's onslaught of terrible ideas likes SOPA, PIPA, CISPA, etc., it would serve internet users well to educate themselves on some of the tools at their disposal that facilitate anonymity. This includes me, so I intend on taking a few posts to research and discuss Tor, VPNs and encryption. I'm by no means an expert on any of these topics, but that's the point. The people who ARE experts are already using them, so I (like many others) am learning on the fly.

I've known about the Tor project for a while now and have always thought it to be a noble cause. Having the skills to one day work on software like Tor is one of the driving forces in my self-education. Anywho, following are some basic steps to get the Tor browser bundle up and running on Ubuntu Linux via shell.

// download the tarball $ wget https://www.torproject.org/dist/torbrowser/linux/tor-browser-gnu-linux-i686-2.2.35-11-dev-en-US.tar.gz // untar into a location of your choice $ sudo tar xvfz ~/Downloads/tor-browser-gnu-linux-i686-2.2.35-11-dev-en-US.tar.gz -C ~/tor // navigate to the tor folder that you unpacked (tor-browser_en-US) and test it out $ ./start-tor-browser // stop the foreground job $ ctrl+c // create a bash alias for the Tor browser by appending the following string to your .bashrc $ echo "alias tor='~/software/tor-browser_en-US/start-tor-browser'" >> ~/.bashrc // restart bash so the changes take effect $ source ~/.bashrc // run tor in the background via the new alias $ tor & // browse anonymously, decide to stop the Tor browser, so run process status to identify the job id $ ps // kill the Tor job $ kill 1234

#tor #linux #ubuntu

Basic Vim Find

When I first set out to replace NetBeans with Vim, I was hesitant about a range of things, beginning (quite predictably) with my ability to learn the Vim keystrokes and on to a supposed lack of IDE functionality that I'd become accustomed to. Now I know that this was naive of me, but it's natural to feel hesitation when changing up a routine that has a few years under its belt.

Whenever I see what appears to be an intimidating problem (in this case, a cheat sheet of Vim commands), I find it comforting to break the problem up into more digestible chunks and then remind myself that it's a system designed by humans, so it can't be that hard to grasp with a little time and effort.

Searching for strings with code is a common task for any developer, so replacing the NetBeans ctrl+f was one of the first things on my list of things to learn with Vim. To state the obvious, you need to be in the 'command' mode in Vim, and not 'insert' for this to work.

Search for string 'TestCase' after cursor:

/TestCase

Search for string 'TestCase' before cursor:

?TestCase

In both situations, you can hit return after typing in your string to highlight all results. Then, you can use 'n' to navigate in your original search direction (down from the cursor, or up) through the matching results. In accordance with many other Vim commands, you can use 'N' to move through matching results in the reverse direction.

#vim

A pull-down resistor configuration from tonight's Arduino session.

I've always been interested in art as well as the craft of making art. Truth be told, I'm much better at the craft part. As a photo student, I got more joy out of making photo paper developer out of coffee grounds than I did actually taking photos. I paid a lot of money for an art degree, but looking back now I was never really trying to be an artist.

I started developing for the web while still an art student and never really looked back. It's now my full-time job, and I absolutely love what I do. I'm even considering going back to school for a comp sci/engineering degree. Masochistic, yes, but I love it.

Something that development will never quite fulfill for me though is the joy of working with my hands. I love the feel of centering freshly kneaded clay on a wheel, or striking flint at the tip of an oxy acetylene torch. Enter Arduino, which is quickly becoming the best of both worlds for me. I get to learn about and use new physical tools (resistors, breadboards, etc.), new software tools (the C language) all the while slowly wrapping my brain around the physics and chemistry involved in basic electronics. I'm fucking hooked. My buddy Ryan and I have been working through the Ladyada tutorials for a few weeks now, and it's a blast. For about $160 I purchased the starter kit that the tutorials are based upon, and I'd make the purchase again in a heartbeat.

#arduino

Git Global Exclude

I like Git, a lot. Ask the dev team at Elevated Third and they'll confirm this. Using Git encourages me to think carefully about what I'm developing instead of just jumping in. Because each commit has my signature on it, I don't want to sign work that is sloppy. It's an art school pride thing.

Anyway, I started a new Django project yesterday, and decided that I didn't want to include any .pyc files in the repo. It seemed to me that they would unnecessarily occupy space in the repo, and I'd rather collaborators just generate their own (and hopefully not contribute them back). A quick Google search lead me to a global Git configuration setting that will prevent Git from paying attention to patterns specified in a file and never suggest files that match those patterns for staging:

Within your shell:

// Create your global excludes file $ echo '*.pyc' > ~/global_excludes.txt // Configure git to block patterns from your global excludes file $ git config --global core.excludesfile ~/global_excludes.txt

#Git

BASH aliases (from the land of allergies)

I can't breath or think very well right now, but part of the deal that I made with myself when I decided to take the freelance route was that I'd make an effort to keep up with my blog. With that in mind, today I'm just going to provide a quick snippet that demonstrates how to declare a bash alias that will ssh into a server. It's pretty common use-case for me, which inherently makes it a good candidate for being set as an alias.

in ~/.bashrc add

alias [your alias]='ssh [username]@[ip]'

Naturally, you'll need to replace [your alias] with whatever you want your alias to be named. For my alias to ssh in to the Pique Interactive server, I just use 'pique'. Then insert your username and the ip, and voila. Save your .bashrc, reestart bash, and your new alias should be ready to go.

#bash

Terminal Echo

Sounds like a great name for a 90s Filter-esque band. Anyhow, the 'echo' command is a great way to quickly write text to a file via command line. For a quick test file or files that only need a sentence or two, it can be inefficient to open a text editor like vim to accomplish such a menial task

The 'echo' command can easily redirect standard output to a file:

$ echo 'Howdy from Denver.' > ./greeting.txt

If greeting.txt doesn't already exist in the Current Working Directory (CWD), then echo will create it. Beware though, if the file does exist, echo will overwrite its contents. That is, unless you use two greater than signs, with performs an append:

$ echo 'I would just like to say' > ./greeting.txt $ echo 'howdy from denver.' >> ./greeting.txt

Note that appending with echo will automatically insert a line break between the existing data and the newly appended string.

#linux #vim

Data Data Data

Databases and SQL are not my strong points. There, I said it, and you can talk to @keubs if you don't believe me.

A lot of my back-end dev life has been spent working with Drupal, so I've become accustomed to opening up phpmyadmin and finding lots of references to other tables within entity definitions (such as a field, for instance). This seemed normal to me. As I spent more time with Django and worked through various tutorials, I kept coming across references to 'lookup tables'. Now, I'm the type of person that can't leave an unfamiliar term undefined. This characteristic of myself is both a blessing and a curse, but that's a discussion for another day.

Today I found myself venturing down the proverbial rabbit hole trying to figure out what all this 'lookup table' business was and why I'd never heard of it before. After the expected sifting through of various Google links and related posts, I ended up at this great article by Joe Celko. The first sentence in the 'History' section was something of an epiphany for me:

"Tables, in a properly designed schema, model either an entity or a relationship, but not both."

BAM! There it is, and I'm sticking to it. I'm a huge fan of the concept 'Separation of Concerns', and Joe's quote plays quite nicely with it. There's no reason for a model that represents an entity to be concerned about what other entities reference it, and Django handles models in this way out-of-the-box :D

#django #sql #baby steps

Python List Comprehensions

List Comprehensions are commonly referred to as one of Python's "killer features", and that's damn accurate. I'm consistently blown away by what can be accomplished with small amounts of Python code. For the duration of the post, I'll be using the following list for manipulation:

message = [104, 101, 108, 108, 111, 46]

Say that I was tasked with quickly decoding the list items (ASCII characters) to strings. An inelegant yet acceptable way to do this would be:

result = [] for i in message: result.append(chr(i)) print ''.join(result)

Psh. Sure, it works, but it isn't pretty. List comprehensions allow me to be much more elegant:

print ''.join([chr(i) for i in message])

Sexy. Pythonic. I can even take it a step further, and introduce a little logic in to the list comprehension:

print ''.join([chr(i) for i in message if i != 46])

To introduce the same logic to the inelegant solution above, I'd have to do something like:

result = [] for i in message: if i != 46: result.append(chr(i)) print ''.join(result)

#python

Living in Colorado can be rough at times. We had to drive about an hour today to get fresh air and scenery like this, which is entirely unacceptable. Below is some Instagram love from the day hike up to Lost Lake outside Nederland, CO. It was about 60' up there, so I completed my first snow-ish hike in shorts! After four hours of hiking in the snow, we gorged on stouts, belgiums, brisket, chicken, cornbread and a root beer float at the Wild Mountain Smokehouse & Brewery.

#hiking #rocky mountains #nederland

Linux File Permissions with Symbolic Arguments

I learned to control permissions within Linux using numeric arguments (absolute), so symbolic arguments(relative) are a bit foreign to me. In this sense, numeric arguments will declare permissions... well, absolutely, and symbolic arguments will declare them relative to the permissions that are already in place. Easy enough.

Both types of arguments are just means to an end, but as I often come across tutorials that use symbolic arguments I thought I'd outline some of the basics of it for reference.

The first component to specifying permissions with symbolic arguments is understanding the different types of user classifications:

u - user (owner of the file)

g - group

o - other (or, everyone else)

a - all (or, o+g+u)

The next step is understanding the three different types of file access permissions:

r - read

w - write

x - execute

Following are a few common examples to demonstrate what I just outlined above. For the examples, let's assume that you are the owner of a file named script.py in your home(~, or /home/

Grant the user (owner) read and write permissions

$ chmod u+rw script.py

* note that since this is a file in the traditional sense and not a file in the memory sense (which could point to either a file OR a directory) there's no sense in granting the x (execute) permission on the file. Execute grants a user permissions to execute files in a directory, which is necessary for many operations like:

$ ls -a

Grant everyone read permission

$ chmod ugo+rw script.py

Or you can use the shorthand and more efficient version:

$ chmod a+rw script.py

Remove read permission for 'other'

$ chmod o-r script.py

#linux

PyFlakes + Vim

I started using Vim last fall and haven't looked back. It's been installed on every box I've ever SSHed in to, so changing code on a production server (Gasp!) is a breeze. I know that I've barely scraped the surface of Vim's possibilities, but I already feel like I'm pretty efficient with it and I long for it's toolset on the rare occasion that I work in NetBeans. For anyone interested, my Editor/IDE progression has been: NotePad > Komodo Edit > NetBeans > Vim. NetBeans is great but massive and I got sick and tired of it changing for updates and bogging down my aging laptop, so I learned Vim.

PyFlakes is defined at the Python Package Index as such: Pyflakes is program to analyze Python programs and detect various errors. It works by parsing the source file, not importing it, so it is safe to use on modules with side effects. It's also much faster. It's a great tool to keep Python code tidy, but running it manually gets old:

$ pyflakes my_script.py

The more time I spend developing the more I realize that I'm late to a bunch of parties, and Vim plugins are no exception. Anywho, here is a great PyFlakes for Vim plugin from @KevinWatters

#vim #python #pyflakes

Ask More and Better Questions.

The title is one of the best pieces of advice I can offer after spending four years as a self-taught developer. I believe that becoming a good software developer requires a child-like sense of curiosity and a desire to never stop learning. At the heart of a curious nature is a relentless desire to ask questions, and this is a good and necessary thing in any science. It drives innovation as well as a continuous pursuit of knowledge.

First, if you're not asking questions, you're not trying and probably not learning as much as you could be. Software development is a vast and often daunting field, so you should never run out of new questions to ask. If you do, you're in the wrong field. The simple knowledge that I'll never run out of things to learn in this field is one of the reasons that I decided upon it as my career.

Second is the the difference between asking questions and asking better questions. The ability to ask better questions develops accordingly as you progress as a developer and spend more time in the field. You become more familiar with terminology and jargon which results in an ability to phrase questions more appropriately, whether they be for a colleague or Google search. This also includes doing more research/testing before asking questions. Think of the potential time saved if you're able to post a question on a mailing list and ALSO list out everything you've done to arrive at the problem, as well as the tests you've run. You're question is then inherently better than if it provided none of the auxiliary information, which probably increases the probably that someone else will take time out of their day to help you. It shows that you're committed to the problem, and not just turning to others the second something doesn't work like the tutorial said it would.

#education #advice

010 - On tar.gz

Many assets on Unix-like OSs are served up as what are commonly referred to as tarballs. For Window$ users, they're similar to .zip archives. It's rare that a day doesn't go by where I don't have to untar a download, so here's a quick explanation of my approach:

To extract(untar) a tarball in to the current working directory:

$ sudo tar xvfz name_of_file.tar.gz

Here is a breakdown of the flags:

x - extract files from archive

v – verbosely list processed files

f - the archive name will follow the flag set

z - filter the archive through gzip

Bonus: extract a tarball from your downloads directory into a directory named python:

$ sudo tar xvfz ~/Downloads/name_of_file.tar.gz -C ~/python

Rad... I love being lazy. Err... I mean, efficient.

#linux #unix #sysadmin

Trending Blogs

Recently Viewed Blogs

Leap Empty-Handed into the Void