I guess I’ll give them a few more months of my soul.

But seriously, if I knew how to search with mutt like I can search with gmail, gmail would get the boot.

ShareThis

Mark Ramm did a talk about WSGI where in one slide he showed how to build up something akin to the full Pylons stack by just applying lots of WSGI middlewares. That really inspired me. Sure, frameworks are great, but I think I’m going to try to going to the opposite extreme for a while — building up from components, rather than using somebody else’s aggregation of components.

Based on a few hallway conversations, It turns out I’m not the only one using version control as a way to deploy code in production. My production box runs a git clone of my production branch.

jonEbird did a talk on using LDAP with Python. It was the first time I had realized that LDAP can do more than user authentication.

I liked Mike Naberezny’s talk on routes also. Good introduction. It reaffirmed my idea that it’s not going to be all that difficult to string a bunch of stuff together for my next web app.

Chris Perkins showed some neat TDD / agile programming techniques possible and made SQLAlchemy seem much friendlier than when I looked at it last year.

ShareThis

ZIP FILE RIGHT HERE

ShareThis

• better
• more obscure
• crasser
• worse

You can see my netflix queue and become my Netflix Friend when you click on this link.

ShareThis

We’ll all know who you are soon — you can’t hide your cold sores forever.

ShareThis

ShareThis

Ditz is written in ruby, and it uses yaml files to store all the issues (tickets) and groupings of issues. Ditz allows issues to be grouped into releases.

$ ditz releases
0.6 (unreleased)
0.4 (released 2008-07-27)
0.5 (released 2008-08-20)

I wrote an extension that would show all the issues attached to a particular release, like this:

$ ditz help ri
Show issues for a particular release.
Usage: ditz ri <release>
 
$ ditz ri
Error: command 'ri' requires a release
 
$ ditz ri bogus
Error: no release with name bogus
 
$ ditz ri 0.6
x  ditz-61: Use text editor for multiline input where possible.
x  ditz-72: add model object post-creation validation
x  ditz-71: 'ditz add' shouldn't ask for comments
x  ditz-76: allow configuration of whether the editor is used or not
x  ditz-69: Store issues in .ditz directory by default
_  ditz-42: support tiny issue identifiers (like #34) in the single-component case
x sheila-1: check for a "git push" having updated the issue db, and reload if so
.… lots more issues snipped for brevity.


Thanks to all the really neat plumbing already built into ditz, my patch was trivial to write:

operation :ri, "Show issues for a particular release", :release do
end
def ri project, config, opts, release
  puts todo_list_for(release.issues_from(project))
end


Ruby is a pretty neat language and people do neat stuff with symbols. In that code above, the operation method takes the symbol :ri and effectively decorates my ri method with the help text. I’m really impressed by how ditz took the fact that my ri method takes a :release symbol as a parameter, and because of that, it knew how to search in the list of releases and then give me the relevant release.

ShareThis

I do this kind of this kind of thing every so often in my code:

def f(x):
    class C(object):
        y = x
    return C


That function takes a parameter and makes and returns a class based on that parameter. Whoop-di-do. I was surprised to learn that you can’t do this:

class C(object):
    x = 99
    class D(object):
        y = x + 1


I gotta explore this some more until it makes sense.

Here’s another neat trick: It isn’t possible to add two classes together:

>>> class C(object):
...     pass
...
>>> C + C
------------------------------------------------------------
Traceback (most recent call last):
  File "<ipython console>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'type' and 'type'


But if you want to support this, the solution would be to define an __add__ method on the metaclass:

>>> type(C)
<type 'type'>
>>> class MC(type):
...     def __add__(self, other):
...         print 'Adding!'
...         return 99
...
>>> class C(object):
...     __metaclass__ = MC
...
>>> C + C
Adding!
99


Wacky, right? More realistically, I could build a new class by taking attributes of both classes together. In other words, if class C has a class attribute x, and class D has a class attribute y, then we can use a metaclass to add C and D together to get a new class E, that has both x and y as class attributes.

In this example, C has a class attribute x and D has a class attribute y. When I add the two classes, I get a new class with both of those class attributes.

>>> C.x, D.y
(99, 98)
>>> E = C + D
>>> E.x, E.y
(99, 98)


Here’s the metaclass that allows this sort of nonsense:

class MC(type):
 
    def __add__(self, other):
 
        class E(self):
            pass
 
        for k,v in other.__dict__.items():
            if k not in ('__dict__', ):
                setattr(E, k, v)
 
        return E


ShareThis

Anybody want to get dinner or meet up that evening? We can talk about Python or theorize about these things.

Anyhow, the slides for my talk are here. I’m going to update them before the talk with more detail on class decorators vs metaclasses. I welcome feedback.

ShareThis

Anyhow, I like this post a lot.

ShareThis