Amir Rachum

Using 'screen' - The Absolute Essentials

Fri, 10 May 2013 10:33:07 +0300

You’re probably here because you heard screen is a more “safe” way to ssh, so that a broken connection won’t terminate your processes. Here’s how to do it:

Installation

sudo apt-get install screen

Initial connection

$ ssh rachum@server
$ screen

Reconnection

$ ssh rachum@server
$ screen -ls
There is a screen on:
    6786.pts-0.ubuntu	(05/10/2013 09:42:11 AM)	(Detached)
1 Socket in /var/run/screen/S-rachum.
$ screen -r 6786.pts-0.ubuntu

… And that’s all you need to know to get something out of screen.

So what is this about? If you take a look at screen’s man pages you’ll read that:

Screen is a full-screen window manager that multiplexes a physical terminal between several processes (typically interactive shells).

Which is true, but not very helpful. While you may use screen’s multiplexing-window-managing features, you most likely came across it while looking for a way to ssh to some machine and run something that won’t die when you disconnect. Multiplexing comes later. If you’re interested in screen’s more advanced features, check out some of these guides.

My Licensing Wake-Up Call

Thu, 09 May 2013 22:08:06 +0300

The other day I got an email that really hit me on the head. It was titled “JOOLS, Y U NO SPECIFY A LICENSE?” and here’s how it read:

FYI, your Jools project on GitHub specifies no license. It looks like you intend it to be Open Source or Public Domain, but without specifying a license explicitly, the license is “all rights reserved, no reuse or redistribution allowed”.

Though I don’t mention the project or you by name, the lack of a license inspired this post:

http://goo.gl/GeVje ;-)

HTH,

Jens Knutson

Harsh, but I know I had it coming. From time to time I hear about license X or license Y, or see a post on HN about which license to use, but I never paid much attention. Licensing is a problem for people with successful projects, I thought. Who has time? My job is to build stuff!

Well, as it seems, not specifying a license can mean failure for your project. I thanked Jens for his email - all the while thinking how many people were in the same situation and didn’t send me an email? Oh man, This is bad.

I went ahead and put up a LICENSE file in my repository right away (I chose the MIT license, for those interested).

Don’t let this happen to you. Got an open source project? License it today.

Python: Number Conversion Chart

Sat, 20 Apr 2013 13:38:00 +0300

Ever forget how to take a hex string like “2D” and convert it into binary data? Or how to parse an ascii-binary string like “101101” into a plain integer? Me too.

That’s why I crafted this table. It doens’t include all conversion, but it includes every conversion type I know, and you can chain them to get from any source type to any destination.

Every from/to cell assumes that the “original” integer is 45. Enjoy!

Number Conversion Chart

More Python Posts

Making History with Bash

Tue, 15 Jan 2013 23:48:25 +0200

This is a nifty little trick for making Bash a little more intuitive (for my taste). Usually, when you press the up key, Bash will bring back the last command you typed. This is cool, but what bothers me is that sometimes I start typing a command and then remember I executed it before. So I press the up key and… Bash shows me the last command, disregarding what I typed. What I want it to do is search history for things with the prefix I entered.

Here’s what you do to achieve this. In your inputrc file (~/.inputrc for personal configuration, /etc/inputrc file for global configuration), add the following lines:

"\C-[OA": history-search-backward
"\C-[[A": history-search-backward

"\C-[OB": history-search-forward
"\C-[[B": history-search-forward

The weird symbols at the start of each line represent up/down arrow keys in keypad/ANSI modes. I wish Unix configurations would use proper readable symbols, but a man can only dream.

Moving Around with Bash

Sat, 05 Jan 2013 14:10:00 +0200

Little things matter. I’m often amazed of how I can feel I mastered a certain tool or technology, only to discover I’ve missed some basic way of using it. It happened to me on Windows a couple of weeks ago when I discovered cool keyboard shortcuts, like Win+E (which opens My Computer), or on Eclipse when I found out there is a menu that finds everything. On Linux, I’ve found that this happens all the time. Now, finding out how to use awk or sed is one thing, and it requires learning a complicated tool. But there are a lot of little things that are so easy to pick up, that it’s a shame that people miss them. Playing around with directories is so common in a Unix shell, and there are so many tricks you can use.

The basic way of moving around is, of course, cd path/to/dir. So far, so good. What more can you do?

You can go back to the last directory you were in by simply executing cd -.

$ cd /usr/local/bin/
$ pwd
/usr/local/bin
$ cd ~/projects/python_toolbox/
$ cd -
/usr/local/bin
$ cd -
/home/rachum/projects/python_toolbox

The previous point is mostly useful when you’re jumping back and forth between two directories. Sometimes you’re jumping between directory A and directory B, and while you’re in B, you cd into some subdirectory, and poof, there goes your way to go back to A. What you’d really like is to tell Bash “Remember this directory. I’m going to go on a trip to B, where I may travel in and out of subdirectories as I please, but eventually I want you to take me back here, to A”. Well wouldn’t you know, there’s a way to do that. But it gets better. You can do that to an unlimited amount of directories, each time remembering or going back to where you were.
If this sounds like a stack of directories to you, you’re right. The commands to do this are called pushd and popd. pushd acts like cd, in the way that it takes a directory name and changes your current directory to it, but it also remembers where you came from. The next time you use popd it will take you back there. You can pushd several times in a row, and each time, popd will take you back one step. If you want to go back without taking the current directory out of the stack, you can do pushd without parameters.
```
$ pwd
/home/rachum/projects
$ pushd ~/private_files/
~/private_files ~/projects
$ cd forbidden_dir/
$ mkdir do_not_enter
$ cd do_not_enter/
$ echo "do some work" > work.txt
$ popd
~/projects
```

If you’re like me, this happens to you ALL. THE. TIME.
```
 $ cd..
 cd..: command not found
```
Well, instead of beating yourself up about it, just fix it!
```
$ alias cd..="cd .."
$ pwd
/home/rachum/projects
$ cd..
$ pwd
/home/rachum
```
Or, even better, just do alias ..="cd ..", so you can just type .. to go to the parent directory.
This one isn’t necessarily related to directories per-se, but it seems like it belongs here. There’s a really useful syntax in Unix shells which utilizes curly braces. It’s a little bit difficult to put into words, so let’s look at an example:
```
$ echo {j,h}ello!
jello! hello!
```
Bash understands this line as two words, one with ‘j’ and the other with ‘h’. The cool thing about this is that it also works with several braces in a single expression:
```
$ echo {j,h}el{l,}o
jello jelo hello helo
```
Bash knows how to create every possible permutation of the word! Notice that it’s possible to put in an “empty” option, and any number of options in the same braces:
```
$ echo {j,h,m,}ello!
jello! hello! mello! ello!
```
You can think of all kinds of use cases where this is useful, but the one I use most often is when I want to rename a file. Usually it happens when I want to back up a file. I usually add a suffix to the file like so:
```
$ cp my_precious_data.dat my_precious_data.dat.backup
```
With curly braces, you can do it like this:
```
$ cp my_precious_data.dat{,.backup}
```
Of course, this works with any shell command:
```
$ touch test_data{1,2,3}.csv
```

Related Posts

Python: The Dictionary Playbook

Wed, 02 Jan 2013 23:32:00 +0200

I so often come across various kinds of boilerplate code regarding dictionaries in Python, that I decided to show some of it here and share the more concise way of performing the same operations.
Presenting: The Dictionary Playbook.

1. The “Are You There?”

This one is pretty simple, but I’m amazed as to how it’s missed - finding out if a key exists in the dictionary.

The Lame Version

dct.has_key(key)

The Python Way

key in dct

2. The “Yoda Test”

For those programmers who master the “Are You There” play, there’s usually another simple, yet annoying behavior. It doesn’t only apply to dicts, but it’s very common.

Do This You Must Not

not key in dct

English, Do You Speak It?

key not in dct

3. The “Get the Value Anyway”

This one is really popular. You have a dictionary and a key, and you want to modify the key’s value. For example, adding 1 to it (let’s say you’re counting something).

The Boilerplate

if key not in dct:
    dct[key] = 0
dct[key] = dct[key] + 1

The Awesome Way

dct[key] = dct.get(key, 0) + 1

dct.get(key[, default]) returns dct[key] if it exists, and default if not.

The Even More Awesome

If you’re using Python 2.7 and you want to count up amounts of stuff, you can use Counter.

>>> from collections import Counter
>>> d = [1, 1, 1, 2, 2, 3, 1, 1]
>>> Counter(d)
Counter({1: 5, 2: 2, 3: 1})

And here’s a more complete example:

>>> counter = Counter()
... for _ in range(10):
...     num = int(raw_input("Enter a number: "))
...     counter.update([num]) 
...
... for key, value in counter.iteritems():
...     print "You have entered {}, {} times!".format(key, value) 
Enter a number: 1
Enter a number: 1
Enter a number: 2
Enter a number: 3
Enter a number: 51
Enter a number: 1
Enter a number: 1
Enter a number: 1
Enter a number: 2
Enter a number: 3
You have entered 1, 5 times!
You have entered 2, 2 times!
You have entered 3, 2 times!
You have entered 51, 1 times!

4. The “Make It Happen”

Sometimes your dictionary contains mutable objects, and you want to initialize and modify them. Let’s say you’re sorting out some data into a dictionary where the values are lists (examples courtesy of this answer in Stack Overflow)

Spelling It Out

dct = {} 
for (key, value) in data: 
    if key in dct: 
        dct[key].append(value) 
    else: 
        dct[key] = [value]

Getting Down with the Python

dct = {} 
for (key, value) in data:
    group = dct.setdefault(key, []) # key might exist already 
    group.append(value)

What setdefault(key, default) does is returns dct[key] if it exists, and if it doesn’t - sets it to default and returns it. Compared to get, it’s useful when the default value is an object you can modify, so you don’t have to manually reinsert its modified version to the dictionary.

Rocking it Out

dct = defaultdict(list) 
for (key, value) in data: 
    dct[key].append(value) # all keys have a default already

defaultdict is pretty awesome. It’s pretty self-explanatory - it’s a dict with default values. This means that every access to a key in dct that doesn’t exist in the dictionary (that would usually raise a KeyError) creates it with the default value. It’s as if every access to dct is done with setdefault.

One interesting use I’ve found for defaultdict is when implementing sparse data structures. You set defaultdict to the default value and use coordinates (or whatever is applicable) as the key. I’ve used this to represents multi-dimensional grids and it’s definitely easier than using intricately wrapped lists.

An even more interesting example of its use is the one-line tree definition.

Related Posts

Moving Changes to Feature Branches After-the-Fact in Mercurial

Sat, 29 Dec 2012 20:18:00 +0200

At my workplace we use Mercurial. We don’t usually work in feature-branches, but in the default branch instead. This is usually not problematic, but I keep running into the following situation: I started working on feature A (on the default branch), when suddenly I am forced to work on (and ship) feature B instead, for whatever reason. When that happens, I usually say to myself “God damn it! I wish I worked on A in a branch to begin with!”.

Enter hg rebase. Here’s what you do.

First, let’s create a small repo and work on some task:

$ hg init repo 
$ cd repo/ 
$ touch readme 
$ hg add 
adding readme 
$ hg commit -m "add readme" 
$ echo "task 1" > task.txt 
$ hg add adding task.txt 
$ hg commit -m "work on task 1" 
$ echo "task 1" >> task.txt 
$ hg commit -m "work some more on task 1"

Here’s how our log looks like now:

$ hg log
changeset: 2:729895012a70
tag: tip
user: nurdok
date: Sun Dec 23 13:20:38 2012 -0800
summary: work some more on task 1

changeset: 1:f71e084223c8
user: nurdok
date: Sun Dec 23 13:20:15 2012 -0800
summary: work on task 1

changeset: 0:ac29a6da9b78
user: nurdok
date: Sun Dec 23 13:18:12 2012 -0800
summary: add readme

Now let’s say we didn’t finish working on task 1 and for some reason we need to put it aside and start working on a different task. We want to move changesets 1 and 2 to a branch for a while. Here’s how to do it:

First, we need to create the branch we want to transfer them to, at the correct point (which is revision 0):

$ hg update -r0
0 files updated, 0 files merged, 1 files removed, 0 files unresolved
$ hg branch task-1
marked working directory as branch task-1
(branches are permanent and global, did you want a bookmark?)

Now we need to create an “empty” commit for the branch. This is needed because as of now the branch doesn’t really exist and it needs to, for the rebase command to work. If you want to transfer the commits to an existing branch (that has some commits already), you don’t need this step.

$ hg commit -m "created task-1 branch"

Now, all there’s left is to perform the rebase command:

$ hg rebase --base 1 --dest 3
saved backup bundle to /home/rachum/repo/.hg/strip-backup/f71e084223c8-backup.hg

The --dest option is where to “stick” the changesets and the --base option defines the changesets that will be moved (it selects the first common ancestor with the revision specified in --destand downwards). Here’s how our log looks like now:

$ hg log
changeset: 3:79318074f4a9
branch: task-1
tag: tip
user: nurdok
date: Sun Dec 23 13:20:38 2012 -0800
summary: work some more on task 1

changeset: 2:a9d9c50a1bdb
branch: task-1
user: nurdok
date: Sun Dec 23 13:20:15 2012 -0800
summary: work on task 1

changeset: 1:25e0d60da309
branch: task-1
user: nurdok
date: Sun Dec 23 13:23:07 2012 -0800
summary: created task-1 branch

changeset: 0:ac29a6da9b78
user: nurdok
date: Sun Dec 23 13:18:12 2012 -0800
summary: add readme

We stored task-1 away and we can start working on other stuff in the default branch.

Eclipse Quick Access - How Did I Miss this?

Fri, 02 Nov 2012 18:32:00 +0200

I can’t believe I’ve been using Eclipse for - what? - 4 or 5 years now without using Quick Access.

Sidebar - I’ve long been promoting Eclipse’s excellent menu search. It lets you search menu windows for each and every preference and value. For example, consider looking for how to enable print margin display (for keeping your code from exceeding 80 character rows; you do that, right?). Imagine sifting through this intricate hierarchy of menus:

However, notice the search box on the upper left side. It allows you to search like so:

Being such a promoter for this feature, I can’t believe I missed Quick Access. Let me explain. You’re working on some code, hacking away, and suddenly you need the PyUnit window thingy. Y’know, this one:

You know what you want, but how do you open it? Window? Perspective? Views? If you aren’t an Eclipse veteran you will probably be confused by the terminology, and all you want is to run some tests. Enter Quick Access. Quick Access is normally mapped to Ctrl+3. Press it and be amazed. You get a window with a search bar. Type something and get search results for practically everything in Eclipse. Let’s try it with PyUnit:

You get search results for preferences, views, commands, open files, etc. It’s the greatest thing since sliced bread. Thanks to @hannanaha for pointing this one out.

Is it possible to be productive with only a smartphone?

Tue, 11 Sep 2012 10:35:24 +0300

In the last month, I was in several situations where I was bored to death and had only my Android phone for amusement (Samsung Galaxy S2, for those wondering). I have the itch to program or do something productive in these situations, but for the life of me, I can’t think of any such option and I usually end up playing a brain-numbing game instead.

I am catching up on some reading in Hacker News, but when I have several hours to pass, it’s just not enough. There’s a new Github app out there, but my repositories don’t have enough activity for me to do anything with it. I also didn’t find any free Git client for the Android, so just getting my code is kind of a hassle. Same goes for a Python shell of some sort.

So, the title of this post is an actual question on my part, not rhetorical: how do you stay productive on your phone?

Programming in The Zone

Sat, 08 Sep 2012 18:55:00 +0300

A lot has been written about the concept of flow, and I was well aware of this particular psychological mode way before I had a name for it. I like saying that I’m in the zone. In The Social Network, they refer to this state as being wired in. The most interesting thing about the zone is, of course, how to get there. I can’t really pinpoint the variables that help me get in the flow (possibly because when I’m in it, I usually don’t think about it), and Wikipedia agrees:

One cannot force oneself to enter flow. It just happens. A flow state can be entered while performing any activity, although it is most likely to occur when one is wholeheartedly performing a task or activity for intrinsic purposes.

There are three conditions that are necessary to achieve the flow state:

One must be involved in an activity with a clear set of goals. This adds direction and structure to the task.

One must have a good balance between the perceived challenges of the task at hand and his or her own perceived skills. One must have confidence that he or she is capable to do the task at hand.

The task at hand must have clear and immediate feedback. This helps the person negotiate any changing demands and allows him or her to adjust his or her performance to maintain the flow state.

When I was reading this article, I simultaneously thought about how this translates to programming and I was surprised to see that every point mentioned very clearly suggests opinions I’ve held strongly for quite some time. Here’s what I came up with:

“It is most likely to occur when one is wholeheartedly performing a task or activity for intrinsic purposes” - good programmers love what they do. You can fake your way into mediocrity, but to reach the top, you’ve got to care.
“One must be involved in an activity with a clear set of goals.” - small programming cycles, consisting of well separated, well-formed tasks, as advocated by agile methodologies, are the most effective way to focus on what you’re doing, do it well, and move from your finished task to the next one with ease.
“One must have confidence that he or she is capable to do the task at hand.” - some people, and rightly so, are sometimes surprised by my hubris. While I try not to offend anyone, I believe that hubris is one of the virtues of a good programmer. It’s the thing that makes you write programs to do something that’s already been done, because you believe you can do it better.
“The task at hand must have clear and immediate feedback.” - some more agile words of wisdom. To me, this translated directly as unit tests. I never work better than when I, in an obsessive-compulsive manner, run unit tests as often as I save my code.

Reddit Thinks I'm a Spammer

Sat, 25 Aug 2012 21:52:19 +0300

When I published my post about else statements in Python, I got lots of comments and a score of over 400 on reddit.com/r/programming (okay, I realize I’m “bragging” again, but this actually is a part of the story). My several following posts got measly viewership although I posted them on reddit as well. I was surprised to discover they weren’t showing up on the New page at all. I thought I just wasn’t seeing it for some reason, but now I contacted a moderator and, well, here it is:

You’re not banned, but the spam filter has identified you (quite accurately) as a spammer. You have essentially only submitted your own domain, and have only commented on your own submissions. This is exactly the kind of behavior that the spam filter looks for, and accounts very much like yours get submitted to /r/reportthespammers all day long.

Please see Identifying Spammers 101 for some insight into what mods look for to identify spammers, and how you might be able to “legitimize” your activity on the site.

Well, I can’t blame the moderator as that’s their policy, I just have to wonder if they shouldn’t put some weight to the acceptance of “spam” posts by the community. Surely, I’m not posting cat photos from wesindicatecatphotos.com, am I?

Reddit thinks I’m a spammer, and in a way they’re right. It shocked me a little to discover this, as I consider myself a lawful citizen of the Internet. While I respect their need to protect their community and try to maintain members that are active in the community as a whole (as opposed to utilitarian parasites like me), I’m not sure if I’m going to try to legitimize myself for their spam filter. My main go-to technology articles site is HackerNews, and I don’t think I’ll abandon it for reddit (even though reddit is responsible for most of my viewership).

You Can't Handle the Truth!

Sat, 25 Aug 2012 19:18:00 +0300

I got a chance to review some other people’s Python code recently, and there’s one comment I almost always have to give, which is:

if x and if x is not None are not the same!
corollary: if not x and if x is None are also quite different, obviously.

This usually happens when someone assigns None to a variable (say, x) as a sentinel value, and then x may or may not be assigned to. The test is designed to check whether or not x was assigned to, or not.

When you do if x is None, you call the operator is, which checks the identity of x. None is a singleton in Python and all None values are also the exact same instance. When you say if x, something different happens. if expects a boolean, and assuming x is not a boolean, Python automatically calls x’s __nonzero__ method. i.e., if x is actually executed as if x.__nonzero__ (or bool(x)). __nonzero__ is pretty poorly named*, but it’s a method that evaluated a class as a boolean value. It’s one of Python’s Magic Methods. The confusing thing is, that bool(None) returns False, so if x is None, if x works as you expect it to. However, there are other values that are evaluated as False. The most prominent example is an empty list. bool([]) returns False as well. Usually, an empty list has a meaning that is different to None; None means no value while an empty list means zero values. Semantically, they are different. I guess people are just unaware of the semantic difference between the two ways to write the condition.

Here are some useful snippets to demonstrate:

Testing `None`

>>> x = None 
... if x: 
...     print 'if x' 
... if x is not None: 
...     print 'if x is not None'

Testing an Empty List

>>> x = [] 
... if x: 
...     print 'if x' 
... if x is not None: 
...     print 'if x is not None' 
if x is not None

Testing a Normal Value

>>> x = 42 
... if x: 
...     print 'if x' 
... if x is not None: 
...     print 'if x is not None'
if x 
if x is not None

Testing a Custom Class

>>> class Foo(object): 
...     def __nonzero__(self): 
...         print 'Foo is evaluated to a boolean!' 
...         return True 
... 
... x = Foo() 
... if x: 
...     print 'if x' 
... if x is not None: 
...     print 'if x is not None' 
Foo is evaluated to a boolean! 
if x 
if x is not None

* Fortunately, the folks working on Python had the sense to change this to __bool__ in Python 3.x!

Gathering the Comments of the Web

Mon, 06 Aug 2012 22:33:15 +0300

My recent post about the else keyword in Python was a tremendous success (relative to my other posts), reaching 20,000+ unique visitors within about 24 hours. It was especially successful in Reddit’s /r/programming, where it got over 400 total upvotes and 130 comments. However, in the post’s own Disqus thread, there were only 3 comments (one of them was mine). Now, I get that people like to comment in the community where they came from - Reddit folks want to comment on the Reddit thread, HackerNews people want to mingle among themselves, people want to post their comments as twitter responds, etc., but as a blogger, I want people coming in from anywhere to see that there are 100+ comments on my post.

A friend of mine told me that he saw the post (which I also posted on my facebook wall) and that he didn’t know where to respond - on my wall, on my twitter account, on the Disqus thread - so many options!

It got us thinking together on how to solve this issue. Obviously we still want to maintain the separation of comment threads on their respective sites, but as a site owner / blogger, I would like my website to show all of them. So the solution is quite simple: a comment system like Disqus, which allows users to comment as usual on the thread, which is also tabbed with different communities. When you finish reading, you can see immediately how many comments there are in different communities. There was already a post I saw in HackerNews that used the HN API to display HN comments in your blog. I suggest taking it a step forward and creating a dynamic tool which works (with plugins, I imagine) for different communities.

Self Printing Programs in Python

Sun, 05 Aug 2012 22:07:00 +0300

Let’s talk about self printing programs (or, quines). A self printing program is, as is its name, self explanatory. Today I thought about how to implement a quine in Python, I whipped up a solution on my own and then posed the challenge to some people in the office. These are the results:

My Version

s = r"print 's = r\"{0}\"'.format(s), '\n', s" 
print 's = r\"{0}\"'.format(s), '\n', s

This exemplifies a common way to implement a quine - the main problem is that you have to use some sort of function that prints. But of course, you also have to print that function, and so on. The way to deal with this is put the entire program in a string, except the assignment to that string, then print the assignment (where you can use the string itself to avoid explicitly writing it again, thus avoiding the recursion), and then the string. Notice there’s a lot of playing with quotation marks. Next is a version that tries to solve this.

Using `chr` for Quotation Marks

a = "b = chr(97) + chr(32) + chr(61) + chr(32) + chr(34); b += a; print b + chr(34); print a"
b = chr(97) + chr(32) + chr(61) + chr(32) + chr(34); b += a; print b + chr(34); print a

This version (while a bit cumbersome) solves the quotation marks problem by just explicitly printing the ascii characters.

Using `exec` Instead of Repeating the `print`

s = r"print 's = r\"' + s + '\"' + '\nexec(s)'"
exec(s)

I really likes this version, as it mostly avoids repeating the code in the two lines.

The Smartass Approach

Well, the first person I introduced this challenge to, had a pretty wiseass, but overall, clever approach. He did this:

print open(__file__).read()

This works, and is pretty clever, but it obviously isn’t what quines are all about. It also wouldn’t work in an interactive shell.

The “Google” Way

After I got the above answers, I just had to google Python quines and see what comes up. A StackOverflow thread points out this (pretty cool) snippet:

_='_=%r;print _%%_';print _%_

It assigns to the variable _ a string which is contains the entire code, except for its own value which is replaced by a formatting instruction, and then print _ and feeds itself into its formatting. Looks obfuscated, but it’s pretty cool when you take a deeper look.

TDGotchi - A Tamagotchi that lives in your Eclipse and feeds on tests and refactorings

Wed, 25 Jul 2012 06:35:36 +0300

TDGotchi - A Tamagotchi that lives in your Eclipse and feeds on tests and refactorings

What else is there in Python?

Tue, 24 Jul 2012 00:43:00 +0300

We all use the else keyword in Python, usually accompanying if statement:

if x > 0: 
    print 'positive' 
elif x < 0: 
    print 'negative' 
else: 
    print 'zero'

but Python has a few other uses to the else keyword that most people are unfamiliar with.

for .. else

I bet you didn’t know that you can put an else clause after a for loop! What does it do? When the items you iterate over are exhausted, the else clause is executed. When aren’t the items exhausted? When you use a break statement.

Using the keyword else for this clause is kind of silly, as else doesn’t really describe the behavior here, but this syntactic sugar can be useful if you put a break somewhere and need to know if it was used. Let’s say we have a computer object and a list of people, and we want each person to use the computer, unless one of them breaks it. At the end, we want to know if the computer was broken or not. Usually, we’d do it like this:

broken = False 
for person in people: 
    person.use(computer) 
    if computer.is_broken: 
        broken = True 
        break 
if not broken: 
    print 'The computer is fine!'

With for..else we can do it like this:

for person in people: 
    person.use(computer) 
    if computer.is_broken: 
        break 
else: 
    print 'The computer is fine!'

while .. else

This has pretty much the same semantics as the for..else syntax. The main while body is executed in a loop as long as the condition is satisfied - that far you already know. If the condition is not satisfied, the else clause is executed. However, a break statement will break out of the entire while..else block, so the else body will not be executed. In a nutshell, it’s the same as the for loop: the else will be executed unless you break out of the loop.

while usage < 10 and person.want_to_play: 
    person.use(computer) 
    if computer.broken: 
        break 
else: 
    print 'The computer is fine!'

try .. except .. else

You got some code in a try block. You want to catch certain exceptions and handle them, but what if no exceptions were raised? That’s where the else clause comes in. It’s executed only if no exceptions were caught, and before the finally clause, if it exists. It’s important to note that exceptions raised by statements in the else block are not caught by the preceding excepts:

 def get_person(people):
     try:
         person = people[3]
     except IndexError:
         person = None
     else:
         person.do_work()
     return person

The else clause is only executed if IndexError was not caught. Why is this useful? Well, one would probably put the person.do_work() bit inside the try block, but what if do_work raises an IndexError? In that case, it will be caught by our except block, which could be catastrophic if we didn’t intend for that. This way, if do_work raises an IndexError, it will propagate through the code, as it should.

Conclusion

Well, I haven’t found the else keyword very useful outside an if block. My opinion is that with for and while loops it should probably be avoided as its behavior is not intuitive. Use it only if it’s more readable than its more verbose alternative. Using else in a try statement, on the other hand, is much more intuitive, and is probably a better alternative than catching exceptions you didn’t plan on, or using a variable to store information on whether an exception was raised to be used after the try..except block.

Cool Syntax and Weird Documentation - Fun with Scapy

Wed, 18 Jul 2012 23:36:59 +0300

I was looking for a way to parse TCP/IP packets in Python, when a friend recommended Scapy. Scapy is a nice python package that’s got a very cool interface using the “div” operator, and is used like so:

packet = IP()/TCP()/"GET / HTTP/1.0\r\n\r\n"
str(packet) # returns the packet's binary data

which is pretty cool and creative. It makes the layers concept pretty visual. Now, I was looking for a way to parse packets, i.e., the other way around. So we were looking in scapy’s documentation. The section on “dissecting” seemed like it might be what we wanted, and here’s the introduction:

Dissecting

Layers are only list of fields, but what is the glue between each field, and after, between each layer. These are the mysteries explain in this section.

I ended up not needing to parse packets, but I did use it to generate TCP/IP packets, and I gotta say, it couldn’t be any easier. Go on, check it out. Their documentation also teaches Python.

Converting a Software Thief into a Customer

Wed, 18 Jul 2012 09:30:21 +0300

Converting a Software Thief into a Customer

A Late Introduction to Jools

Sat, 14 Jul 2012 20:18:07 +0300

A while back I wrote a small Java tools library called Jools. I never really presented it to “the world” (except for hosting it on Github). So I figured, now is my chance. Here are the features Jools provide:

Python-like Range Objects

This one is pretty straight forward

for (final int i : new Range(5)) { 
    players.add(new SmartPlayer(names.get(i))); 
}

Generating Permutations

PermutationGenerator<String> pg = new PermutationGenerator<String>("a", "b", "c"); 
for (List<String> permutation : pg) { 
    System.out.println("Permutation: " + permutation); 
}

This prints:

Permutation: [a, b, c] 
Permutation: [a, c, b] 
Permutation: [b, a, c] 
Permutation: [b, c, a] 
Permutation: [c, a, b] 
Permutation: [c, b, a]

The cool thing about this class is that it also allows to get a permutation based on its index (calculated efficiently in O(n) time, when n is the number of items (not permutation)):

System.out.println("Permutation #3: " + pg.get(3));

This yields:

Permutation #3: [b, c, a]

Iterable Wrapper For Looping with Indices

Similar to Python’s enumerate function:

final List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F", "G"); 
for (final IndexedElement<String> element : new Indexer<String>(list)) { 
    System.out.println(element.getElement() + " : " + element.getIndex()); 
}

That’s it. Not a big library, as I said, but it’s been helpful to me, and I hope it can be helpful to you as well!

Double Iteration in List Comprehension

Sat, 14 Jul 2012 02:33:00 +0300

Here’s something I didn’t know possible in Python: iteration over more than one iterable in a list comprehension:

>>> seq_x = [1, 2, 3, 4]
>>> seq_y = 'abc'
>>> [(x,y) for x in seq_x for y in seq_y]
[(1, 'a'), 
(1, 'b'), 
(1, 'c'), 
(2, 'a'), 
(2, 'b'), 
(2, 'c'), 
(3, 'a'), 
(3, 'b'), 
(3, 'c'), 
(4, 'a'), 
(4, 'b'), 
(4, 'c')]

Cool, isn’t it? It’s equivalent to the following snippet:

>>> result = [] 
... for x in seq_x: 
...     for y in seq_y: 
 ...         result.append((x,y)) 
>>> result 
[(1, 'a'), 
(1, 'b'), 
(1, 'c'), 
(2, 'a'), 
(2, 'b'), 
(2, 'c'), 
(3, 'a'), 
(3, 'b'), 
(3, 'c'), 
(4, 'a'), 
(4, 'b'), 
(4, 'c')]

It also supports both “if” statements and referencing the outer iterator from the inner one, like so:

>>> seq = ['abc', 'def', 'g', 'hi'] 
... [y for x in seq if len(seq) > 1 for y in x if y != 'e'] 
['a', 'b', 'c', 'd', 'f', 'g', 'h', 'i']

This is equivalent to the snippet:

>>> result = [] 
... for x in seq: 
...     if len(seq) > 1: 
...         for y in x: 
...             if y != 'e': 
...                 result.append(y) 
... result ['a', 'b', 'c', 'd', 'f', 'g', 'h', 'i']

The thing you should notice here, is that the outer loop is the first ‘for’ loop in the list comprehension. This was a little confusing for me at first because when I nest list comprehensions it’s the other way around.

To read more about this feature, check out this StackOverflow thread or the Python Manual.

Amir Rachum

Using 'screen' - The Absolute Essentials

My Licensing Wake-Up Call

Python: Number Conversion Chart

Making History with Bash

Moving Around with Bash

Python: The Dictionary Playbook

1. The “Are You There?”

The Lame Version

The Python Way

2. The “Yoda Test”

Do This You Must Not

English, Do You Speak It?

3. The “Get the Value Anyway”

The Boilerplate

The Awesome Way

The Even More Awesome

4. The “Make It Happen”

Spelling It Out

Getting Down with the Python

Rocking it Out

Moving Changes to Feature Branches After-the-Fact in Mercurial

Eclipse Quick Access - How Did I Miss this?

Is it possible to be productive with only a smartphone?

Programming in The Zone

Reddit Thinks I'm a Spammer

You Can't Handle the Truth!

Testing None

Testing an Empty List

Testing a Normal Value

Testing a Custom Class

Gathering the Comments of the Web

Self Printing Programs in Python

My Version

Using chr for Quotation Marks

Using exec Instead of Repeating the print

The Smartass Approach

The “Google” Way

TDGotchi - A Tamagotchi that lives in your Eclipse and feeds on tests and refactorings

What else is there in Python?

for .. else

while .. else

try .. except .. else

Conclusion

Cool Syntax and Weird Documentation - Fun with Scapy

Dissecting

Converting a Software Thief into a Customer

A Late Introduction to Jools

Python-like Range Objects

Generating Permutations

Iterable Wrapper For Looping with Indices

Double Iteration in List Comprehension

Testing `None`

Using `chr` for Quotation Marks

Using `exec` Instead of Repeating the `print`