The idiom for PropertyMock is to assign a PropertyMock to the type object of the Mock object whose property you want control of. What I found is that because Mocks auto-create properties, it’s possible to do nested mocking in one line, like this:

1
2
3
4

import mock
m = mock.Mock()
type(m.a.b.c).d = mock.PropertyMock(return_value = mock.sentinel.my_value)
assert(m.a.b.c.d == mock.sentinel.my_value)

So my soup example looks roughly like this (mixing testing and tested code, and repeating literals for brevity):

1
2
3
4
5
6
7
8
9
10
11
12
13
14

json_body = "{}"
with patch(gi.repository.Soup) as mock_soup:
    from gi.repository import Soup
    type(mock_soup.MemoryUse).COPY = mock.PropertyMock(return_value=mock.sentinel.COPY)

    # tested code:
    message = Soup.Message.new("POST", "http://fake.com/api")
    message.set_request('application/json', Soup.MemoryUse.COPY, json_body, len(json_body))

    # checking:
    assert(mock_soup.mock_calls == [mock.call.Message.new("POST", "http://fake.com/api"),
                                    mock.call.Message.new().set_request('application/json',
                                                                        sentinel.COPY # <--- this was the point
                                                                        "{}", 2)])

It’s often possible to think of a shorter, clearer use of the mock library after revisiting a problem, but so far this still seems good. Let me know in the comments if you have a suggestion for improvements.

I have a few religious beliefs about email. One is that processing incoming email is different from

that you should only process a message once - when you first see it, you should decide what to do next with it, even if that’s “read it again later”,

I call it a religion because I believe it, but I don’t always practice it. I have an inbox full of things I’ve looked at once and am procrastinating on, partly because it’s hard to move things to the todo list that I use from Gmail. It annoys me every time I look at my email, and I’ve forgotten important things that I left sitting there. This is exactly why I think it’s important that our tools encourage good habits, instead of encoding bad ones.

1. Don’t crash. A bouncer makes crashes recoverable, but I shouldn’t have to use one just to keep the backlog around.

2. I need to search the backlog. Incremental search is best.

3. Show multiple channels at once, in one window.

4. Highlight mentions of my nick so I can glance at a window and see if anyone’s asking me something. Use Growl or notification center, too.

5. Make it obvious when I’ve disconnected, and reconnect robustly.

6. Let me hide/fade out join/leave notifications and other admin messages.

7. Keep my place so I know what messages are new.

8. Make it obvious which channel I’m looking at, and even more obvious which channel I’m about to type in. (Nothing is great at this)

9. Spell-check is nice, but autocorrect is awful for IRC and technical discussions. Needs a global switch.

10. Don’t show unread counts. Some channels are chatty and I’m just in them listening for my name.

Here are the clients I’ve tried and why they aren’t quite perfect:

Colloquy

Colloquy is a nice full-featured open source client. I’ve used it the most. However - it doesn’t show multiple channels in one window at the same time, and doesn’t keep your place. I’ve had some problems with reconnection, where I thought IRC was quiet when I was actually just disconnected and didn’t know it.

I have to turn autocorrect off for each room I’m in, which I only remember after the first time it really annoys me by mangling some jargon.

There’s also some general buggy behavior, and I have a short list of bugs I’d like to report someday, but I don’t have time to fix them.

Years ago I hacked my own version of a place marker that I liked, but I can’t remember why it didn’t make it in, and of course the code is lost now.

The backlog search looks like it should be powerful, but in my experience it just doesn’t work - it never displays any results. I’m not sure what the deal is there.

(As a side note, Colloquy’s iPhone app is the only iPhone IRC client I’ve used. It seems to work fine, and I don’t use it enough to have specific gripes. Just having to have IRC open on my phone is guaranteed to annoy me more than the software itself could.)

Emacs ERC

My current setup is just to run ERC in an emacs window alongside my code editing. This has super flexible window splitting and size management and unbeatable search for your backlog, since it’s just another emacs buffer. There’s another nice benefit - if you’re writing about code, emacs’ tab-completion for strings across all buffers means that you can easily autocomplete SomeReallyLongFunctionName in chats. This saves a lot of typing and cut n’ pasting. When you do need to cut n’ paste, it’s nicer to do it between emacs buffers than between apps.

The defaults are not ideal, as usual with emacs you need to dig around to find a good setup.

There’s a module to colorize nicknames according to a hash of the name, so it’s easier to tell people apart. Other clients have similar features but I think I like emacs’ the best for some reason - maybe the palette is nicer.

There’s a module to mark your place that only works if you left the cursor in the backlog, which is a little weird. It will highlight my nick when mentioned, but not the whole line.

Since it’s open source, I have the same problem as Colloquy, it’s hackable, but I don’t really have time for that. And emacs is fun to hack on, so it’s a potentially dangerous time sink.

Linkinus

This is a nice client with some minor flaws and a little flakiness. I liked it but moved on because of minor annoyances.

It has a kind-of nifty “conversation tracking” feature that tries to highlight messages in a back-and-forth when you hover over it with the mouse (but only in the currently selected channel). It’s not really that useful, but I think it could be if pushed further. I’d like to see more clients try this kind of thing, since separating multiple concurrent conversations is hard on IRC, and it can be hard to avoid them.

Lets you display multiple channels in one window, but that needs some improvement. There’s just one text-entry field so it’s easy to type something to the wrong channel.

The split display has some issues. The split channel views don’t show you the channel name anywhere, and in some cases don’t even show you the channel topic, which may or may not be helpful anyway. So it can take some effort to figure out what channel you’re looking at, especially if there are many of the same people talking on two channels.

It can save a set of channels as a group, but it doesn’t save the relative sizes of the splits in the group, so if you want to flip between groups, you’d better be OK with even splits.

Finally, it only supports vertical splits, so with more than two channels, you just get a couple unreadably long lines per channel.

It has a very barebones backlog search, but it does work.

They’ve also clearly tried to re-design the account setup / prefs experience, but I’m not a big fan of an inspector palette - I wanted to compare settings between two servers and it will only show me one at a time. This was also the biggest point of flakiness, where some edits wouldn’t commit and I couldn’t tell if the settings were being changed.

Textual

Textual is an open-source app (github.com/Codeux/Textual) that is for sale on the Mac app store. This is an interesting approach that I think has some merit - people may still contribute code or bug fixes, but it’s also nice to know that if the app ever gets abandoned, it could be resurrected. That said, I tried building from source to enable a quick hack once but the master branch didn’t build for me, so they’re not trying to make it easy.

It lets me hide some admin messages, has automatic & manual scrollback markers to keep track of what I’ve missed.

This has a setting to “Track conversations using nickname highlighting” but I couldn’t really tell what it was doing.

This also has a pretty barebones search, but again, it works.

I tried this for a few days and liked it, but ultimately switched away, I think mostly because you can’t display multiple channels - there’s just one window and it doesn’t split up.

Mango

I haven’t tried Mango. The screenshots in the App Store and feature listings don’t lead me to believe that it’s anything significantly different from the others. I’d be glad to hear from fans, though.

So, what do you use? Have I missed anything great?

testing with twisted.trial and python-mock works fine

Our filesystem events listening daemon was crashing occasionally on my system, and I didn’t know how to reproduce it. No one else seemed to be getting these crashes, either. The system was saving a backtrace, and it was always the same, but I wasn’t sure I believed its line numbers. As a start, I made a guess at the lines that were really failing, and added a ton of debug dumps to inspect the state. (Since this daemon is run as root using launchd, it’s still easiest to just use the old printf-n’-stare debug method.)

Then I tried a lot of stuff to poke at it, even leaving Spotify on overnight in an attempt to recreate the conditions of the bug. No luck. It seemed like it would only crash when I wasn’t trying to get it to crash - pretty frustrating.

I finally found it, but only after giving up for a while. I checked in again after working for a while on another project, and hey, lots of new crashes! With all my extra debug info, I could see what was going on - a string that couldn’t be encoded in UTF-8 was being handled by some code that assumed it could be. It was a filesystem path with invalid characters.

What was the path that was killing my daemon? It was a temp file written by the test suite for the other project. It was a non-utf8 path, written to test the unicode handling of the GUI, and it had the wonderful (in retrospect) side effect of poking a bug in the daemon too. It’s so satisfying when you find a bug’s cause and it completely explains all the symptoms you were seeing.

One test exercising the unicode handling of multiple projects, now that’s coverage!

All the time, we’re throwing out something that still works, because there’s something new that works better.

Working better is great! Faster chips and better screens and cameras make our lives easier and help us make cool new stuff.

I used to work near people designing processors, so I know it’s plenty hard just to keep that part of the system progressing. And I know that newer stuff will use less energy, which is great. I know that people designing data centers think hard about their efficiency, and upgrade ruthlessly to improve it.

But how carefully are we considering the impact of getting rid of all that old equipment? How do we compare whether it’s really, globally, ethically, better to improve speed & efficiency vs. just keep using old stuff? How do we factor in things like resources mined in conflict zones?

I recently remodeled a house, and among all the advice I read, I remember this best: “The greenest building material is the one that’s already there.” (It was about floors. We put in new bamboo anyway. That old parquet was awful, but I hope the new stuff stays there for a hundred years or more.)

I know that designing e.g., a great modern smartphone, is extremely difficult, even ‘only’ considering functionality, space and power constraints. Designing something that small and integrated that could still be upgraded partially, keeping around parts that still work, sounds near impossible, but wouldn’t it be great? It sounds like a fun challenge.

Hackers compete on how fast they can complete code editing tasks from a variety of languages, with results plotted and dissected on a web leaderboard. The idea is not to evaluate language understanding or design, but simply editing skill and speed in the kind of thing that editor flame wars start over.

The tasks could be simple refactorings, like renaming a function throughout a source tree, or extracting code into a method. I’d expect this would show advantages of specialized refactoring tools in some IDEs. Other tasks might be more complex, like writing a new set of functions, a whole class, or adding functions to a class to conform to a protocol or interface. Good template support and autocomplete might be an advantage here. Or maybe you want to add conditional debug logging around a set of functions, with each call having a separate hardcoded counter value? Surely powerful macros win this task? Naturally, new tasks could be submitted by the public, and voted on. Each task would have a “correct” answer, but if you’re really clever you could always suggest a better correct answer.

Use of extensions and custom macros would be happily encouraged, as long as you can share what you’ve used.

You’d need either an editor plugin or at least something that watches files efficiently to get the split-second timing your contestants will demand. Ideally you’d be able to record keystrokes and grab the source for any macros you call, then the site would be able to show a replay for the viewing public.

It’d be fascinating to learn how other people use your favorite editor by watching the best of the best compete. Not to mention, just imagine the forum threads arguing over the graphs from the vast database of editor timings.

Anyone want to build this?

• Our approach to replication in computational science - “bioinformatician makes code and all analyses available. very admirable, and yet a little worrying that this is so rare. It is also rare in computer science, where it is arguably easier to share.”
• ModSquadHockey Forums - good reviews of equipment with painful forum UI. BTW, yes, a Bauer Concept II full shield will definitely fit a Stealth S19 (2010 model) helmet. You’re welcome.
• Hockey Helmet Cage/Visor Compatibility Charts - really useful, but sadly not fully complete. An impossible task.
• Opengazer: open source gaze tracker for ordinary webcams - Presented without comment. Have you used this?
• Storm Python ORM - Python ORM from Canonical, used in launchpad.
• What it takes to build great machine learning products - I think the answer was careful definition of the problem domain?
• A calculator that only shows the answer after you give a suitable estimate - Really cool idea. The magic is in how to adjust the tolerance so it seems fair. Linked to the HN post because the comments are so polarized - it’s interesting to swatch people violently miss the point.
• GNU Parallel - Well if you don’t know, now you know: “GNU parallel is a shell tool for executing jobs in parallel using one or more computers.” Super useful. You don’t have to use GNU parallel if you like something else that’s similar, but you should probably know at least one tool for this stuff.
• GNOME + Do - quicksilver for gnome. I left out the part in the page title that says “Crazy Delicious” because come on, people. These are computers.
• Field visualization software - “An environment for writing code to rapidly and experimentally assemble and explore algorithmic systems” - A really fascinating project. It looks like big ball of squeak, python, and processing that Bret Victor rolled up. I wanted to try it out in April but haven’t had a chance.
• circa - A programming language that lets you manipulate the AST and do round trips. I forget what I meant by that exactly. I also wrote that ‘state is first class’. You’d better go look at the page if that sounds interesting. Don’t ask me!

That’s it for April. Look for May’s bookmarks sometime in 2014.

These posts about blogging are really only interesting years later, and only to me, when I look back and think about what I was doing that I thought I had time to mess with blogging software.

Last time I made a major change was switching to wordpress from blosxom back in December 2005, over Christmas break. I was at my parents’ house and had nothing to do after everyone went to bed at 9pm.

These days I can’t remember the feeling of having nothing to do, but I went ahead and switched things up anyway, exactly because I don’t have time to mess with things like upgrading wordpress.

So I’m going with octopress on github user pages. I like generating a static site from text files, and github pages are sort of convenient. (sort of)

• Why I still program - “I believe that the rejection of programming as a lower activity can be explained by the Theory of the leisure class. In effect, we do not seek utility but prestige. There is no prestige in tool-making, cooking or farming. To maximize your prestige, you must rise up to the leisure class: you work must not be immediately useful.”

• From counting citations to measuring usage (help needed!) - Building a Better Citation Index

• workhacks.com: Top 3 Gmail Management Apps for Mac - Mailplane Blog - includes a list of gmail plugins that look useful

• Melopy -
"""

  from melopy import Melopy m = Melopy('mysong') m.add_quarter_note('A4') m.add_quarter_note('C#5') m.add_quarter_note('E5') m.render() [==================================================] 100% Done """

• Rust Language Tutorial: Expression Syntax - Starts out good, but the “leave out a semicolon to return a value” leaves a bad taste. Why overload semicolons like that? Why not just use ‘ret’?

• Forget Self-Improvement -

• The Magic of Doing One Thing at a Time - Tony Schwartz - Harvard Business Review - A few good points on avoiding multitasking burnout. Nothing too new, but maybe if people keep repeating it in places like HBR, then it’ll start to become conventional business wisdom?

• Stuart’s “Law of Networkdynamics” -

• Flattr - Social micropayments - An interesting model that I hadn’t heard of. You set a monthly amount to spend and when you see a flattr button, you click on it. They then divide your monthly amount among the people you clicked on that month.

Sounds great but I have never seen a button, unless it’s been hidden among many other warts.

• Haskell: Functional Programming, Solid Code, Big Data (1)) - Bryan O’Sullivan’s Haskell tutorial from Strange Loop 2011

• QuickCheck | YELLOSOFT - Lots of ports of QuickCheck

• Simple Quickcheck implementation for Python - Random test generation that is not as nice as Haskell’s quickcheck but will do the job.

• Magic Maps: Now You See It. - Very cool app for working with maps and time series data

• How Not To Sort By Average Rating - Shows the best way to sort by positive/negative rankings that is robust to small sample sizes

• terrorism hardly existential threat. 2010 -

• workhacks.com: Top 3 Gmail Management Apps for Mac includes a list of gmail plugins that look useful

• Yesod Web Framework for Haskell -

• beets: the music geek’s media organizer - The purpose of beets is to get your music collection right once and for all. It catalogs your collection, automatically improving its metadata as it goes using the MusicBrainz database. (It also downloads cover art for albums it imports.) Then it provides a bouquet of tools for manipulating and accessing your music.

Because beets is designed as a library, it can do almost anything you can imagine for your music collection. Via plugins, beets becomes a panacea:

Embed and extract album art from files’ tags. Listen to your library with a music player that speaks the MPD protocol and works with a staggering variety of interfaces. Fetch lyrics for all your songs from databases on the Web. Manage your MusicBrainz music collection. Analyze music files’ metadata from the command line. Clean up crufty tags left behind by other, less-awesome tools. Browse your music library graphically through a Web browser and play it in any browser that supports HTML5 Audio.

• 7 Years of YouTube Scalability Lessons in 30 Minutes - Notes from a PyCon talk about the very pragmatic design philosophy at YouTube.

• bkad/discoball * GitHub - shell tool to match and colorize lines of text

• The Pragmatic Bookshelf | The Developer’s Code -

• How to see around corners : Nature News & Comment - And we thought the future was flying cars.

• ARM’s ultra-low-power fridge-puter chips: Just what the CIA ordered • The Register - Out of context interesting quote: “The spy boss was chiefly concerned with the huge amounts of data that can be collected from American citizens who intend to become CIA agents - in an age when parents set up Twitter and Tumblr accounts for their newborns, managing the identities of future operatives suddenly becomes non-trivial.”

• Who needs access? You need access! - new site about open access to research aimed at lay people (I think)

• CodeMirror - “CodeMirror is a JavaScript library that can be used to create a relatively pleasant editor interface for code-like content ― computer programs, HTML markup, and similar. If a mode has been written for the language you are editing, the code will be coloured, and the editor will optionally help you with indentation.”

• Latexian: A LaTeX Editor for Mac OS X - Nice looking latex editor with live preview.

10.6 or higher so I can’t try it just now.

• Core Graphics live - YouTube - Demo of live-preview graphics drawing tool

• DRC: Digital Room Correction - “RC is a program used to generate correction filters for acoustic compensation of HiFi and audio systems in general, including listening room compensation. DRC generates just the FIR correction filters, which can be used with a real time or offline convolver to provide real time or offline correction. DRC doesn’t provide convolution features, and provides only some simplified, although really accurate, measuring tools.”

• ASP: A SEJITS Implementation for Python * shoaibkamil/asp Wiki * GitHub -

• python - Does PyPY translate itself? - Stack Overflow - An informative answer about how PyPy works

• On reviewing research papers « Lars Bergstrom - So, PL has a culture of really useful reviews, huh?

• How to Do What You Love - “If you think something’s supposed to hurt, you’re less likely to notice if you’re doing it wrong. That about sums up my experience of graduate school.”

Boom!

• The Millions : Ban This Book: An Uncensored Look At The Lorax And Other Dangerous Books -

• A Neighborhood of Infinity: You Could Have Invented Monads! (And Maybe You Already Have.) - A practical way of thinking about monads.

• Pretty Lisp | Hacker News I don’t like this. Great comment thread though - lots of people agree with me. I think maybe enthusiasm for structure editors is a sign of youthful optimism and inexperience.

• 2004 Rob Pike Q&A Interview - Slashdot - “(And speaking of Doug, he’s the unsung hero of Unix. He was manager of the group that produced it and a huge creative force in the group, but he’s almost unknown in the Unix community. He invented a couple of things you might have heard of: pipes and - get this - macros. Well, someone had to do it and that someone was Doug. As Ken once said when we were talking one day in the Unix room, “There’s no one smarter than Doug.”) ”

• How To Build a Naive Bayes Classifier | Hacker News - Useful comment thread about building naive bayes classifiers

• A Legal Issues Primer for Open Source and Free Software Projects - Software Freedom Law Center -