Stephan Sokolow's Blog

This morning, in typical distracted fashion, I got the urge to start experimenting with using CSS to style a website for printing and decided to use the copy of TiddlyWiki I use for personal organization as the test bed.

I was so impressed by how nicely the results printed out that I just had to share them. The particular pages that most impressed me are private stuff, so I can’t share them, but here’s the TiddlyWiki markup reference:

Here’s the full PDF. (Note: There is actually a visible difference between reading the PDF on-screen and printing it. DPI makes all the difference. I was also going to experiment with page margins, but I liked the results so much that I didn’t want to change anything.)

The CSS below works perfectly with a completely un-modified default TiddlyWiki theme… though it does also include a couple of tweaks that only really have an effect if you’ve got certain plugins installed. (eg. CheckboxPlugin)

Depending on how you use TiddlyWiki, you may want to skip the “Hide tag-related floats” or “Page break before each tiddler” lines in your copy. I made sure that, before I hid them, the floats didn’t look too horrifying.

To really exercise the stylesheet, print out a stream of several tiddlers with at least one outline list full of checkboxes and at least one span of text similar to an O’Reilly book. (Roughly a page worth of paragraphs with some technical nouns marked up in italic here and preformatted text there)

UPDATE: After sleeping on my results, several improvements occurred to me:

• Fixed table heading color in Chrome (Not sure how I missed this one)
• Adjust things to look good when printing of background colors and/or images is enabled.
• Create a CSS class that can be applied using {{checkList{ ... }}} to hide bullets if your list starts each entry with a checkbox anyway. (Much prettier TODO lists both on-screen and in printouts)
• Switch to vertical-align: bottom for checkboxes after more eyeball-testing with Firefox and Chrome

While working on a project I haven’t yet made public, I found myself needing to migrate data into a Django project without being able to use the simple, common “Use inspectdb, then migrate to the new form with South” approach some suggest.

Here’s the simplest sequence of commands I’ve found for performing a migration to an existing app with some possibility for reusing the migration later if necessary:

django-admin.py startproject <throwaway project>
cd <throwaway project>
python manage.py startapp <real target app name>
[repeat for all target apps]
[edit settings.py and tell it about your DB and apps]
python manage.py inspectdb > temp_models.py
[look at temp_models.py and make any adjustments necessary]
[edit models.py for each app and move the relevant bits from temp_models.py]
python manage.py syncdb
python manage.py dumpdata > migrated_data.json
[...and then set up South to prevent future pain] 

Nothing fancy. Just something that saved me some hassle and might do the same for someone else. Here are the actual commands I used for clarification:

django-admin.py startproject gbi_temp
cd gbi_temp
python manage.py startapp gbindex
python manage.py startapp icolinks
python manage.py startapp ffcms_core
vim settings.py
python manage.py inspectdb > temp_models.py
vim temp_models.py gbindex/models.py icolinks/models.py \
    ffcms_core/models.py
python manage.py syncdb
python manage.py dumpdata > migrated_data.json
mv migrated_data.json ../ffcms/
cd ../ffcms
python manage.py loaddata migrated_data.json

After years of wanting it, I finally got around to setting up an IPv6 tunnel. (My brothers’ Flash plugins weren’t too pleased for some reason, but I’ll re-enable IPv6 on their machines later)

I quickly discovered that there was one small problem though. Hurricane Electric’s TunnelBroker.net doesn’t offer a DynDNS-style API for DNS-O-Matic to replicate my m0n0wall DynDNS updates to.

They do provide a more homegrown HTTP API and I tried e-mailing DNS-O-Matic to see if the could add support for it, but got no response and, since m0n0wall doesn’t let you hook on-reconnect events, I needed something ddclient-like.

I checked around to see if anyone else had m0n0wall-based solutions, but found nothing and, being the geek I am, I felt more like whipping up a custom tool in an afternoon than spending an hour trying to puzzle out the search keywords for a more flexible ddclient-alike.

upd_ipv6.py requires Python 2.5 (I think) and LXML (m0n0wall’s interfaces status page isn’t well-formed enough for ElementTree and I didn’t feel like doing any SAX-style parsing by hand). It’ll probably work on Windows and MacOS, but I’ve only tested it on Linux and it’s not a daemon, but that’s what cron and the Windows task scheduler are for.

To configure it, run ./upd_ipv6.py --dump-config and then edit the config file at the path it mentions. You’ll probably want to create a custom m0n0wall user that can only access the Status > Interfaces page.

Once that’s done, just stick it somewhere out-of-the-way, add a cron line like this to run it once every five minutes:

*/5     *       *       *       *       ~/bin/upd_ipv6.py

It’ll only contact TunnelBroker.net if your IP changes.

CoffeeScript is a simple, clean, fast language which compiles to JavaScript, either at build time, with a caching framework plugin on the server, or at runtime in the browser.

The syntax looks like a cross between Python and Haskell¹ and, generally speaking, is used similarly enough to Python that you’ll have little trouble picking it up and using it comfortably.

It does have a few of what non-Ruby programmers will consider distasteful warts, but for the most part, it’s an elegant and delightful language.

You’ll probably want to keep the syntax reference open in a background tab at first, but if you’re comfortable with Python and you’ve done any programming with jQuery or some other modern JavaScript library, you’ll feel right at home.

Below, I’ve summarized the points which the documentation doesn’t completely prepare you for as a Python programmer.

Helpful features with no direct Python analogue

A.K.A. Things which you’ll probably forget to use at first, but which you really should work to remember.

Use almost anything as an expression

Not only does CoffeeScript have anonymous functions, you can treat pretty much anything as an expression and it’ll be wrapped in an anonymous function if needed.

Indent-stripping multi-line strings

If you use single-quotes rather than triple-quotes for multi-line strings, it’ll still work and leading indentation common to all lines will be stripped. (like textwrap.dedent(), if you’re familiar with it)

Embedding expressions in strings

Given how much string templating is done in JavaScript, it really helps that you can put any expression directly inside the Ruby-style #{string interpolation operator}

for own key of

To iterate over only the properties which weren’t inherited, use for own key of rather than for key of. (Very useful since JavaScript doesn’t make a distinction between properties and associative array keys)

Fat-arrow function syntax

To bind this to the parent object, even in a callback, simply define it with => rather than ->

Ultra-concise constructors

Rather than filling your class constructors with this.foo = foo, you can simply use the @ shorthand for this. and write constructor: (@foo, @bar) -> with an empty method body.

Checking for the existence of variables and properties is concise.

Use variable ? "default value" and obj.method?().thing?.widget

Similarities and differences with Python not explicitly mentioned

A.K.A. What the documentation won’t directly prepare you for if you have Python instincts.

Ternary syntax will break your muscle memory

For a ternary expression, Python uses result = a if test else b while CoffeeScript  uses result = if test then a else b. (The if statement syntax on a single line)

a = b and c or d works Pythonically but you don’t need backwards-compatibility with pre-ternary Python releases

Boolean operators don’t coerce the return value to a boolean (a will be c or d, not true or false) but 99% of the time, what you really want is the ternary operator.

Comprehensions use when, not if

If you write result = (x for x in list if x % 2 == 0), you won’t get an error… but you will get a loop inside a conditional rather than a conditional inside a loop.
(If item in the parent scope isn’t evenly divisible by 2, the loop will be skipped. If it is, result will be identical to list)

Comprehensions iterating two lists produce a two-dimensional array

In Python, this syntax will produce a one-dimensional list while, in CoffeeScript, it produces a list of lists.

a+b for a in A for b in B

newList = list1 + list2 + list3 is not array concatenation

You could use newList = [].concat list1, list2, list3 instead, but a cleaner and more flexible alternative is to use splats. This example cleanly concatenates three lists and two individual numbers into a single list:

newList = [listA..., numA, numB, listB..., listC...]

In my opinion, this makes CoffeeScript cleaner and more intuitive than Python for this task.

When foo is an array, if foo is always true

[] != false so, to check whether a list is empty, you have to do if foo.length instead.

someFunction(arg3 = 1) is not the syntax for positional arguments

…but because assignment is valid in an expression, it won’t raise an error. What you want is someFunction null, null, 1 or someFunction(null, null, 1)

There is an equivalent to someFunction(x, y, *args)

As in Python, splats aren’t just for function definitions.

 someFunction x, y, args...

Counter-intuitive Perl/PHP/Ruby/etc.-isms

A.K.A. Where most of your subtle, hard-to-find bugs will come from as a Python programmer.

If you don’t use parentheses in a function call, CoffeeScript will guess them for you

…but Haskell programmers and shell scripters will be surprised when a b c d means a(b(c(d))) rather than a(b,c,d). This also means that foo () is sometimes invalid when foo() is OK.

On the plus side, it works very well for ensuring that anonymously defined callbacks aren’t an exception to the “indents, not braces” block syntax.

The rules are simple but it’ll still take some getting used to before I’ll stop occasionally tripping over them. Here’s how jashkenas explained it to me:

The call wraps forwards to the end of the line, or to the end of the indented block, with one specific exception for postfix conditionals.

alert a alert(a) alert inspect a alert(inspect(a)) alert inspect a if b alert(inspect(a)) if b

Colons aren’t part of the block syntax

Habitually typing a colon after a function name or control statement will turn it into an object property (think dict literals)… which can do all manner of crazy things if it’s something like “else:” which is still valid CoffeeScript.

You can’t shadow a higher-level variable

…only refer to it as in Ruby’s “local scope”, so expect to cause subtle bugs if you habitually reuse a handful of temporary variable names. If you want to get out of the habit, PyLint‘s default configuration will complain when you do this in your Python code.

Like Perl and Ruby and unlike JavaScript, CoffeeScript does implicit returns

…so expect subtle bugs until you internalize that CoffeeScript’s function syntax is really a multi-line lambda.
(As the docs say when talking about comprehensions intended only for their side-effects, “Be careful that you’re not accidentally returning the results of the comprehension in these cases, by adding a meaningful return value, like true, or null, to the bottom of your function.”)

As with PHP, single- and double-quoted strings have different meanings

…with interpolation only working in double-quoted strings.

Like in C and many C-inspired syntaxes, and explicitly unlike Python, you can do assignment inside an expression.

So expect to shoot yourself in the foot on occasion by accidentally typing = instead of == and not getting an error message. (You can, however, reduce the risks by habituating yourself to the is and isnt aliases for == and !=)

Caveats to re-mention for JavaScript programmers

A.K.A. Where subtle, hard-to-find bugs may come from if you have a lot of experience working with plain old JavaScript.

Switch statements don’t allow you to fall-through to the next case

CoffeeScript automatically inserts break; into every case. However, when statements will accept comma-separated lists instead. (I seem to have misplaced the response which gave me this tip. Help appreciated in tracking it down so I can link it.)

To avoid namespace pollution, everything is run in an anonymous wrapper

…so you have to explicitly attach things to the window object if that’s what you want.

== and != are converted into === and !==

If you really want the intransitive, coercion-inducing version, wrap the expression in backticks to mark it as raw, untranslated JavaScript.

CoffeeScript’s in is Python’s in

JavaScript’s in is CoffeeScript’s of.

Python features still to find equivalents for

• Concise any(iterable), all(iterable), and reduce(function, sequence) without relying on Underscore.coffee or ECMAScript 5.

Did I miss something?

I’m new to CoffeeScript, so please let me know if I’m wrong or if I forgot to mention some area where Python instincts will steer you wrong with CoffeeScript.

Also, don’t forget to read the FAQ. It’s not as noticeable as the docs, but it’s almost as useful. 🙂

^1. Technically, the syntax is inspired by Ruby and YAML, but I know quite a few Python programmers for whom that wouldn’t mean anything, so I compare to Python and Haskell first instead.

So there I was, waiting for some nVidia drivers to compile so I could get back into X11, flipping through images in fbi, when I realized I was sick and tired of fragile, irritating, one-liners to pipe lists of images into it.

Enter gqfbi. A little, one-hour creation of mine which makes using fbi so much more comfortable.

GQfbi is a small, Python-based wrapper script for the fbi framebuffer image viewer which will make it just Do What I Mean™.

Features include:

• Automatically excluding files fbi won’t recognize to prevent it from pausing for a second or two to force you to read the “couldn’t load this image” message.
• Support for taking any combination of paths to images, directories, and GQview/Geeqie collections.
• Calls fbi with readahead and auto-scaling enabled. (I’ll make them optional when I get around to actually making optparse do something useful)

Planned features:

• Support for asking fbi to slideshow, shuffle, and loop.
• Support for taking Zip/RAR/CBZ/CBR archives as input for framebuffer manga-reading.
• Its own git repository rather than lurking in my roaming profile’s ~/bin

If you like it, please let me know. I don’t use it often, so you’ll probably be single-handedly responsible for getting a feature implemented.