Since, recently, I’d learned that it’s possible to muck about in m0n0wall without pulling the CF card (despite the lack of proper SSH), I decided to take m0n0wall’s interfaces readout page, strip out everything that wasn’t necessary to get the WAN IPv4 address, and add an explode() call to separate the IP from the hostmask.

If you want it for your own m0n0wall box, here are the instructions:

1. Grab api_wan_ipaddr4.php from my GitHub Gist.
2. Go to exec.php on your m0n0wall box (http://192.168.1.1/exec.php with the default DHCP configuration)
3. (optional) Type “status_interfaces.php” into the download box and use a tool like diff to verify that I haven’t added anything nefarious.
4. Use the exec.php upload interface to upload api_wan_ipaddr4.php.
5. Run these commands using the exec field:

   mv /tmp/api_wan_ipaddr4.php /usr/local/www
   chmod 755 api_wan_ipaddr4.php

6. Load it in your browser (http://192.168.1.1/api_wan_ipaddr4.php with defaults) to confirm that it’s working.
7. Use wget/curl/etc. with HTTP authentication to retrieve your external IP whenever you want. I use this command for my conky:
   

   curl -s --insecure --anyauth --netrc https://192.168.0.1/api_wan_ipaddr4.php

The following questions are things I found myself frequently wondering, but feel free to ask me other questions. I’ll add answers for the “likely to be frequent” ones as time permits.

How do I create a new command for distutils?

As I find myself often forgetting this, I’ve posted a template with explanatory comments as a GitHub Gist.

How do I add my custom command to multiple projects without including it and setting cmdclass in each one?

As far as I know, using only distutils, you can’t. However, setuptools provides a mechanism.

How do I make a custom command fail gracefully if non-optional dependencies aren’t present?

• For dependencies internal to Python (modules, specific module versions, etc.), you can define your command inside a try/except or if block. my template includes an example.
• For external commands, I recommend defining your command inside an if block and using a which function to test for them. (Using an external “which” command is ugly and fragile)

How do I access the attributes I passed to setup() from my custom command?

This was a surprisingly involved thing to figure out. setup() passes its arguments to an instance of distutils.dist.Distribution which then parcels them out to various places.

The simple explanation is that, if it’s set in setup() and setup.py doesn’t complain about it being unrecognized, your command can access it as an attribute of either self.distribution or self.distribution.metadata. (With the possible exception of it being a command-specific option. I forget how those work)

However, the metadata also offers a comprehensive collection of getter methods which return strings like “UNKNOWN” in place of None, so you’ll probably want to ask PyDoc for details:

pydoc distutils.dist.DistributionMetadata

A practical example of the most common use I’ve had for this is retrieving the list of packages to be installed via self.distribution.packages so a tool like Epydoc or Pylint can be run on them.

Is there a clean, sane way to bundle resources (eg. custom toolbar icons) with my project

Not really. [1] [2] [3] The approaches linked aren’t pretty, but they’re all I’ve been able to find.

Where do I find new commands?

Given that Python has PyPI, you’d think there would at least be a repository of commands for setuptools. However, aside from the commands that come bundled with their associated programs (nosetests, flakes, build_sphinx, etc.), I haven’t found anything. The wiki mentioned in the next question has a very sparse cookbook though.

There’s really no community documentation for this stuff?

There is, but it only covers some of the questions listed here. One of these days when I’m not feeling so unmotivated, I’ll merge this FAQ into theirs.

Isn’t anybody working to fix this mess?

Yes, but it’s not going to happen overnight.

A few months back, I was informed of an offering known as the Humble Indie Bundle. Seeing it as an opportunity to finally pick up a copy of World of Goo, I bought in. However, my brother quickly insisted that I try another one of the games in the bundle…

Aquaria is an aquatic platformer. More specifically, an aquatic platformer with gorgeous art, beautiful music, and a focus on semi-linear exploration. If Braid is one possible expression of “Super Mario Bros.’s almost nonexistant story done right” (A review for another day), then Aquaria is an expression of “Super Metroid done right”.

Everything about the game seems carefully crafted to emphasize the atmosphere around you and it makes exploration a treat, there’s a wide variety of enemies, and the “forms” system throws back to the various weapons Samus had to use… though with less focus on different attacks and more on different skills to pass region barriers.

However, it is still firmly a platformer, so while the story gets a fair bit more work than Super Metroid, there are some rough edges which clearly show that storytelling was not the creators’ specialty and that, while a significant improvement on Super Metroid, improvements still could be made.

The combat mechanic does sometimes take precedence in situations where it’s detrimental to the atmosphere (for example, the boss battles where, without fail, you have to defeat enraged or corrupted gods, receiving boons from them in moments of lucidity before they finally die) and the descent into the abyss near the end of the game does make the game less engaging… something a corresponding increase in story-focus could have mitigated.

However, given how rare Metroid-style exploration platformers are and how much I enjoyed exploring the world, I’m willing to forgive that somewhat. It would definitely have been nicer, though, if they’d provided more “ancient turtle” warp points. (The three largest regions in the game still only get one apiece and one surprise region of respectable size gets none at all, while the surface waters get two) More frequent save points would also have probably been a good idea, given that not everybody is as flexible with their schedule as I am.

A more significant problem, story wise, was the feeling that, toward the end, the story was at once both rushed and sparse. Structuring the game more like an essay, with most of the abyss-crawling in the middle and the triumphant revelation of the coral reefs of the surface (or some “beyond” area) would have helped significantly, as would more voice-acted “vision” sequences. As is, it feels as if it’s building toward something as you head for the surface waters… and then the plunge into the abyss quickly ends the story with loose plot threads being tied up before they could fully be developed.

The fact that, apparently, some recipes in the cooking system are alternate paths to dishes and can only be found by experimentation further develops this impression as players tend to measure their progress by the proportion of discoverable items they’ve found compared to the total number. Speaking of the cooking system…

I did find the cooking mechanic enjoyable, primarily because it let me handle my health and powerup management in my own distinctive fashions (and because I used to play games like Harvest Moon), but I felt that, to use a programming term, the set of recipes was oriented too much toward depth rather than breadth. Too many ingredients useful in only one recipe, too many recipes that require multiple steps, and too much dependence on a small set of core ingredients that aren’t proportionally available unless you grind sources of them. Nonetheless, it was fun.

Finally, the collectable trophies seemed too “collectable for the sake of having them”, given how thoroughly hidden some of them were. (In some cases, you have to either know where they are already, or be just plain insane to find them) Of all the trophies I collected, the one I still like most is the ever-respawning pot of fish meat. (one of those few over-utilized base ingredients I talked about)

Overall, it gives the impression that the designers had plenty of skill and envisioned something that they, at the time, didn’t realize would be twice as long as they had the budget for. Nonetheless, I’d give it a solid 4.5 out of 5 and encourage anyone who enjoyed the old 2D Metroid games (or enjoys 2D platformers and 3D Metroid).

P.S. If you really want to feel the atmosphere to its fullest, let a friend or family member wait through the intro that plays the first time you start the game so you don’t see it, then click on the crystal in the menu screen to view it (for the first time) after completing Mithalas Cathedral. That way, you won’t have any potentially inaccurate preconceptions to color Naija’s initial realization that she knows nothing of her origins.

Update: If you get the chance, listen to the special OST-only track “Fear the Dark” before and after you play Aquaria. It’s a beautiful piece (preview) and it does a beautifully clever job of hiding its relation to Aquaria so that you only “get” it once you’ve beaten the game. (Thanks to their clever use of pronouns and implicit subjects, it just sounds like very beautiful, if ordinary, love song unless you know who is being talked about)

I’ve done some significant re-theming on http://www.ficfan.org/ and fixed a bug that was causing many of the quotes to not show their additional metadata.

While doing so, I noticed that, because of how wp-lifestream caches paths (though I can see no benefit to it), the switchover to the new fileserver caused it to get in a fight with PHP’s safe_mode. (Why doesn’t anybody tell me these things?) That is now fixed.

Finally, now that I’m on vacation, I had time to dig into wp-lifestream and add a workaround for the double-encoded YouTube links. YouTube faves in my lifestream now actually work.

Enjoy.

I also agree that, to make progress, you have to experiment. However, when the Chrome devs start making not-so-smart changes, ignoring mass-complaint by the users of their “Dev Channel” releases, not even compromising with a simple checkbox, and marking well-starred issues as WontFix, they start to approach the level of arrogance and hubris I once thought reserved for the developers of The GIMP. (They’re not quite there since, in my experience, GIMP developers will also insult you or dismiss valid complaints as rude before setting RESO INVALID or RESO WONTFIX)

Here are a few of the more controversial changes, to put it politely, which they have forced on Chrome users in the last few months:

• Chrome Linux single click does not select all (An “experiment” that has now lasted roughly 6 months, proven a bit divisive in the early-adopter community, and received neither the requested checkbox nor a satisfying response from the devs.)
• Type-ahead-find [2] (Apparently, the devs feel keybinding purity is more important than users… and “/” without modifiers is impure)
• Warn when closing with multiple tabs open (Apparently data loss is preferable to modal dialogs with “remember my choice” checkboxes)
• URL bar no longer shows http:// (A pointless nod to space-constrained cellphone address bars which has caused various regressions… including some not mentioned in the bug tracker)
  • It makes novice web developers more likely to produce broken links
  • It makes life more difficult for professional web developers
  • It’s not that different from the old “change for change’s sake” that UI design best practices warn against.

…and that doesn’t even cover the many issues that should be trivial fixes but have languished for months or even years… presumably while the UI change reviews required by Google are continually de-prioritized in favor of whatever it is that the devs actually care about. (eg. native RSS support, reliable middle-click, debugged pop-up blocker, file associations, working blur()/focus(), download completion protection, a comfortable download shelf [1] [2] [3], and various others.

I’m not saying they should do things my way, but I find it, at the very least, insulting to be forced to do things their way without so much as an about:config or hard-to-find checkbox.

To be perfectly honest, for all its flaws, if Firefox 4.x can provide compact toolbars and a properly responsive GUI on Linux, I’ll switch back in a heartbeat. It may be a messy free-for-all with an extension system based on fragile monkey-patching and a rendering engine that’s more sumo wrestler than rocket, but at least it doesn’t presume to tell me how to use my own browser.

Update: As I mentioned in one of the following comments, another reason this really gets to me is the condescension, arrogance, and hypocrisy of claiming to make these changes “for the user” and then implicitly qualifying it with “We know what you want better than you do”. There’s a reason I don’t like Apple, there’s a reason I don’t like Microsoft, there’s a reason I don’t like the Apple fanboys in charge of GNOME and Ubuntu UI design, and now it looks like I also have a reason to not like Google… especially given the good arguments for reverting and the convoluted excuses against reverting that I’m seeing on the issue tracker entry for the removal of http:// from the omnibar.

Update 2: And, in what seems like an admission of defeat to me, the Google Chrome devs have now marked the issue entry for the removal of http:// read-only. In my experience, that’s the corporate equivalent of  ”Ohh, nothing’s going my way. Mom!”

Update 3: While Google still seems to be convinced that their “we know you better than you do” approach to UI design is correct, they are not completely immune to reason. According to the Chrome 5.0.375.17 ChangeLog, they’ve temporarily reverted “http:// truncation, star icon, etc…”. Their official stance is “We are currently examining ways to address the usability issues that were raised and plan to reintroduce in a future release” though, so I doubt they’ll be willing to admit that stripping http:// on a non-cellphone browser is inherently a dumb idea.

Here’s my interpretation of said Bizarro world’s timeline:

1. Hitler is asked “Why so serious?” (where we see that Fegelein hasn’t yet distracted Hitler to the point where he essentially forgets about the Allies)
2. Hitler is informed he is Fegelein (which apparently takes place before Hitler catches on to the source of Günsche’s stupid reports)
3. Hitler is informed Fegelein has locked him into his room (where Hitler starts to realize that Fegelein is the source of all his problems)
4. Hitler is informed he is Hitler (…but he still hasn’t realized that Günsche is in on it)
5. Hitler is informed he is sitting down (…and now he has)
6. Hitler’s glued to his chair (Fegelein’s twisted sense of humor responds to the previous incident,  we see how typical this kind of thing is, and Hitler’s patience wears thin)
7. – Fegelein leaks the parodies which arrived on the web first –
8. Hitler is informed Fegelein is missing (when Günsche tells Hitler that Fegelein’s ass-kicking for leaking the early parodies will have to wait)
9. Various Pranks: Helium, Fegelein’s Death, Mass Cloning, etc.
10. Hitler is losing his voice (from ranting about Fegelein’s antics all the time)
11. Hitler is informed his pizza will arrive late
12. Hitler Phones Fegelein
13. Hitler is informed Fegelein is now the leader

All I can say is that it made my day evening.

Here are just some of the noteworthy objects I’d never thought to try:

• Longcat (possibly the only thing which can beat God, in-game)
• Tacgnol
• Keyboard Cat
• Ceiling Cat
• Philosoraptor
• O Rly
• Giant Enemy Crab
• Epic Fail
• Monorail Cat
• All Your Base Are Belong To Us
• Over Nine Thousand
• I See What You Did There
• Ninja Cat
• Om Nom Nom Nom
• LOLWUT or LOL WUT
• RickRoll
• Large Hadron Collider or LHC (which will produce a black hole if you turn it on)
• ROFLcopter (and lollerskates)
• Two One Seven, Neogaf, and Feep (proof that they’re not above letting culture feed back into their creation)
• Mongolian Death Worm
• Yomama or Your Mom

I also ran across some interesting ways to combine items (some of which exploit flaws in the engine):

• Lasso + Trampoline
• Doc Ock
• Two One Seven + Tornado
• Mind Control Device + Dragon
• Shoggoth + Shrink Magic

Commenters also recommended these terms:

• Ninja Shark
• Chinese Dragon (Unlike European dragons, these guys are friendly)
• Edison (A bandana-wearing T-Rex)
• Blob
• Chupacabra
• Maxwell (a copy of your character) and a Black Hole
• Urn (disturb it and you get a ghost)
• Corpse + Chain + Car Battery (or Lightning)
• Scribblenaut

Finally, just in case you want it, a complete list of all the terms the English version of Scribblenauts will recognize. Enjoy.

More recently, I was reminded of an interesting article titled Against School by John Taylor Gatto that originally appeared in Harper’s Magazine. More controversial, but also well-referenced and my personal experience generally agrees. Force kids to be surrounded by other kids, doing boring work and you’ll get mostly emotionally-driven, easily-manipulated adults with the less controllable being outcasts.

It wasn’t until today, though, that I realized how it all tied together. I discovered a long but very interesting article named “Roadmap to a New Economics: Beyond Capitalism and Socialism” by Riane Eisler. The central point of said article being that rather than thinking of capitalism vs. socialism, we should be thinking of domination systems vs. partnership systems.

It seems fairly obvious in retrospect that the real root of all these problems is this “Dominate first, co-operate only if that fails” mentality that our chimpanzee instincts encourage and society strengthens, and as my mother puts it, “bullying is endemic in our society”, but it doesn’t have to be that way.

I’ll leave this on a related note. I don’t have a URL handy, but I remember reading an article a few months ago about how, all around the world, there’s a direct inverse correlation between the size of the gap between rich and poor in a society and the life expectancy of everyone, rich and poor alike. (In other words, for whatever reason, the more unequal your society, the more years lost off your life… no matter how rich you are. Personally, I suspect stress as the culprit.)

Update: Since writing this, I received another TED talk about the necessity and lack of true liberal arts education in modern western society and an article about how kids teach themselves to read… and how could I have forgotten Bertrand Russell’s In Praise of Idleness?

I ended up discovering that MS SQL, Firebird, Oracle, and DB2 also lack OFFSET and the solution (MS SQL version) is to grab a list of primary keys which should be skipped using a subquery. (because retrieving just primary keys is faster than retrieving and discarding all the columns you don’t need)

To make sure I didn’t forget, I threw up an SQLite version on GitHub Gists.

While doing that, I also ran across jPaginate (demo), a jQuery pagination plugin that, as long as you provide a gracefully-degrading fallback, is probably my new favorite design for a page selector.

Update: This site is also useful.

Note: The closest I’ve come to actual functional programming languages is adopting parts of the functional style in Python. If my terminology is a little off but I got the gist of the thing, be diplomatic in your complaints. (I’ve had too much experience with math teachers who seem to think that it’s pointless to know how to use math without perfectly comprehending the relevant proofs and being able to write your own.)

The Easy Stuff

First, let’s cover a few things which are generally easy to understand… but only if you’ve heard of them:

Higher-order Function

A function which takes another function as an argument. To make this more comfortable, many languages treat functions and data equally. (In object-oriented languages, this is “everything is an object” taken to its logical conclusion). This allows for things like results = filter(arbitrary_test, input_data). This is an especially useful feature when combined with other features like closures. (explained later)

Pure Function

A function that only uses its arguments as input, doesn’t modify variables visible outside itself, and provides all of its output using the language’s “return” statement (or equivalent). In other words, a function with no hidden inputs or side-effects. Pure functions are a Good Thing™ because you know that, with a given set of arguments, they’ll always do the same thing. This helps immensely with testing and debugging. (and makes unit testing much easier and more reliable)

Tail Recursion

Getting loop-like behaviour by having functions re-call themselves as the last thing they do. People consider this a good thing because it lets you write loops in a purely functional fashion. (see previous explanation) Functional languages generally optimize this internally so you still get the speed and stack-avoidance of a loop.

List Comprehensions

Practically speaking, a list comprehension is just a shorthand for saying “Take the elements from list X that satisfy condition Y and perform operation Z on them, then return a list of the results”. The benefit of list comprehensions is that they’re a quick, easy, concise alternative to declaring an empty list and then wrapping a function in a for loop and an if statement. (Technically speaking, they let you build one list from another using set builder notation.)

For example, In Python, you could get the squares of all positive numbers in a list with new_list = [x**2 for x in old_list if x > 0]. Keep in mind, however, that list comprehensions aren’t limited to working with numbers. I often use one to quickly implement a simple, one-line input normalizer that, in plain English, would be “Take all lines which aren’t empty or beginning with # and strip leading and trailing whitespace.”

Monads

As one answer on StackOverflow put it, “Monads are simply a way [of] wrapping things and provid[ing] methods to do operations on the wrapped stuff without unwrapping it.” It’s a clear definition… but its doesn’t really give you that “Aha!” moment I was looking for. If you have any experience at all with Javascript, the explanations and examples in jQuery is a Monad should do just that. In short, Monads are useful for changing the set of verbs and how they behave.

The final realization of how useful they can be (and my first recognition of how nifty it can get when you mix functional and imperative styles in a compatible language came from another StackOverflow answer (same question) which showed how, in F#, you can use a monad to do Javascript-style asynchronous HTTP I/O without having to explicitly write callbacks.

Lazy Evaluation

When a programming language is given a statement or block of statements, there are various ways it can do things, ranging from fully strict evaluation to fully lazy evaluation. These are usually easier to explain with examples.

The most common subset of lazy evaluation is probably short-circuit evaluation. This means that, if I run something like fileContent = getFromCache(url) or getFromWeb(url) in Python and getFromCache returns something other than None, an empty string, or the like, getFromWeb will never run because “True or anything” will always be true, so why bother evaulating the second half? This can be confusing if you don’t expect it, but as my example shows, it can also be very useful.

As you probably guessed, strict evaluation operates on the premise that “they said to run it, so we run it… whether or not we’re throwing away the output”. Naturally, in every language, if/then/else constructs use lazy evaluation.

The area of lazy evaluation that is sometimes confusing is eager evaluation versus delayed evaluation. If you’re still reading this, you’re almost certainly familiar with eager evaluation. For example, if you look at a list, you might see something like [1, 2, 3, 4, 5, 6].

The gist of delayed evaluation is that, at any given time, that list could look more like [1, 2, 3, ...] with the language evaluating further into the “...” as needed. This is useful because you can do things like creating an infinite list (Wikipedia uses the Fibonacci sequence as an example) and then retrieving specific values from it.

On a more mundane note, lazy evaluation is also commonly used for improving program performance. For example, in graphical systems where drawing is done only at the last minute so that “Oops. Looks like those pixels aren’t visible to the user after all” doesn’t impair performance.

Haskell

I haven’t actually used Haskell yet, but from what I’ve seen, I think I’ll try to make time for it soon. (When I do, I’ll update this post) Here are the posts that brought me to that conclusion (In concert with what I’ve already linked, of course):

• Why Haskell is Beyond Ready for Prime Time (This is the more convincing one in my opinion)
• 37 Reasons to Love Haskell

Among other things, I love the idea of a code repository where you can search for functions by specifying the inputs and return types you need.