Planet Python

Jkx@home: 2D benchmarks on Linux Nvidia, Intel, ATI: xrender

2008-05-17T01:48:27+00:00

For my new computer I bought a ATI HD 2600 PRO with a bunch of memory. This card has some really good 3D results, and works well on Linux. But I run into some issues with de xv extension on this board. In fact the driver (the free or binary one) doesn’t seems to support [...]

Simon Wittber: Dear lazyweb...

2008-05-16T23:40:14+00:00

I'm setting up my Python dev environment on a new macbook... and easy_install is running like treacle down a hill. It is so slow!

Anyone else experienced this, and worked out what is wrong? I'm guessing its something network related...

Greg Wilson: File Under “Really Not Getting It”

2008-05-16T18:45:59+00:00

The New York Times ran a piece today on the under-representation of women in the sciences—in the Fashion and Style section, of course, because hey, women don’t read the business pages, do they? *sigh*

Doug Hellmann: October 2007 column for Python Magazine

2008-05-16T18:43:08+00:00

Has your multi-threaded application grown GILs? Take a look at these packages for easy-to-use process management and interprocess communication tools.

Read more

This article was originally published by Python Magazine in October of 2007.

Greg Wilson: I Will Buy You Lunch…

2008-05-16T16:29:40+00:00

…or maybe even dinner, if you will build a usable table differencing tool. I have some SQLite database files under version control that I need to merge (updated on my laptop yesterday while flying, not remembering that I’d made some updates on my desktop machine as well). Ditto spreadsheets: I store all my grades in Excel now, but every once in a while, I have to merge changes made at home with changes made in the office. Both are multi-tabular data (”multi” because there can be many tables in a database, and many worksheets in a spreadsheet); after images, I’d guess tabular is the most common format that people want to put into version control that diff(1) can’t deal with. I can’t promise wealth or fame, but you’d sure be popular.

Brian Jones: Social Media, The Future of News, and Data Mining

2008-05-16T15:39:21+00:00

I went to a very good panel discussion yesterday hosted by the Center for Information Technology Policy at Princeton University. There has been a conference going on there that covers a lot of the overlap between technology, law, and journalism, and the panel discussion yesterday, Data Mining, Visualization, and Interactivity was even more enlightening than I had anticipated.

The panel members included Matt Hurst, of Microsoft Live Labs, Kevin Anderson, blog editor for The Guardian, and David Blei, a professor at the Computer Science Dept., Princeton University. This made for a very lively discussion, covering a wide range of perspectives about social media, “what is news?”, how technology is changing how people interact with information (including news), how the news game is changing as a result (which was far more fascinating than it sounds), and how this unfathomably enormous stream of bits, enabled by lots of open APIs, feeds, and other data streams can be managed, mined, reduced, and presented in some value-added way (part of the value being the sheer reduction in noise).

Cool Tools for Finding News

Some of the tools presented by the panelists were new to me, and aside from being great tools for bloggers and other content publishers, there are some excellent examples of how to make effective use of the data you have access to through APIs like the Digg API.

BlogPulse

This was presented by Matt Hurst. It’s is pretty neat - it’s a tool that essentially charts blog buzz of a given phrase over time, and it even lets you compare multiple phrases, which is really interesting as well. Check it out here.

I’d like to know more about how it derives the metrics, but in doing a couple of quick comparisons using the tool, it seems to line up to some degree with simple comparisons of the number of search results for different phrases on sites like technorati and bloglines. Interestingly, even though there appears to be lots more data available at Technorati, in my very limited experimenting, the percent difference between search results for any two phrases appears to be similar, indicating that bloglines may be a representative sampling of technorati data. More experimentation, of course, would be needed to lend any credibility whatsoever to that claim. It’s probably irrelevant, because you can’t ask either service for any kind of historical data regarding search results

Twistori

This has the potential to be really interesting. Right now, it lets you pick from several different terms, like “love”, “wish”, “think” and “feel”, and after clicking one of those, it’ll start producing a constantly updating stream of twitters that contain those words. If this experiment is successful, I would imagine they’d eventually enable the same service for arbitrary keywords, which would be really powerful, and quite a lot of fun!

Tweetwheel

Oh how boring my life according to twitter is. I’m still in the schizophrenic stage of settling on a live ‘update your friends on what you’re doing whether they care or not’ services. Facebook, myspace, twitter, jaiku… there are too many. I’m trying out the imified route now to consolidate all the cruft. According to tweetwheel, there are more places to update my status at any given moment than there are people who give a damn what my status is.

Anyway, tweetwheel shows how you’re connected to people through twitter. If you have lots of followers and follow lots of people, the wheel is really exciting to look at, as displayed by Kevin Anderson, who has a much more “robust” wheel than me — it’s actually interesting to look at. At some point I’d like to see this idea expanded to cover the other services like Facebook and even LinkedIn.

Digg Labs

You have to go to the Digg Labs site and see what people are doing with the Digg API. There are too many awesome utlities to cover them all here. It almost makes me wish I did fancy Flash UI stuff instead of back end data mining and infrastructure administration.

At a higher level…

Most of the discussion about social media seems to be about measuring buzz created by bloggers (at least where news/content publishing is concerned). However, although things have shifted dramatically in a ‘consumers are producers’ direction, causing people to start rethinking the definition of news, this shift is caused as much by consumers who are still *only* consuming as anyone else, and I didn’t see much in the way of tools that measure the interest of those people in any meaningful way. Perhaps the consensus is that the bloggers are a representative sampling of the wider internet readership? I don’t know. I would disagree with that if it were the case.

I work for AddThis.com, which seeks to provide publishers of news and all kinds of other content with statistics that help them figure out not just what pages people happen to be landing on, but which ones they have elected to take a greater interest in, either by emailing it to a friend, adding it to their favorites, or posting it to digg, delicious, or some other service. Maybe some day there will be an AddThis API that’ll let you easily do even more interesting things with social media.

Greg Wilson: But I Was Gone Less than 48 Hours!

2008-05-16T15:01:08+00:00

I left Toronto for Austin mid-day Wednesday, and got back at midnight last night. Lots happened in the interim, so here’s a linkandthoughtdump (which I bet actually is one word in German):

Gave a talk about Beautiful Code to the Austin Python Users’ Group Wednesday at Enthought’s swanky offices. (They’re the kind folks who provide web hosting for the Software Carpentry course.) About 27 people in attendance, and good discussion afterward; was grateful to Travis Vaught and Sergey Fomel for rides from the airport and to the hotel respectively.
Gave another talk titled “HPC Considered Harmful” at the Texas Advanced Computing Center’s Second Annual Scientific Software Days. I was a bit nervous about telling people at a supercomputing center that focusing on massive parallelism and peak performance is wrongheaded, but there were a lot of nodding heads.
I made lots of notes from two other talks that I want to follow up on at some point:
- Robert van de Geijn’s FLAME system lets you draw matrix operations, then automatically generates the corresponding high-performance code. It’s a great example of a real high-level programming tool for scientists (and yet another special case of what a real extensible programming system would support).
- Eric Jones (also from Enthought) talked about a tool they’re building that watches changes to variables in Python programs, and automatically generates interactive plots of their values. It sounds simpler and less impressive than it actually is; I’ve asked him to put together a screencast, and I think you’ll be wowed—I was. (Later: Steve Eddings from The Mathworks sent me a link about data linking in MATLAB, complete with a video tutorial.)
At roughly the same time, half a world away, Diomidis Spinellis presented a study comparing the code quality of Linux, Windows, OpenSolaris, and FreeBSD. Very cool work; wish I’d been at ICSE’08 to ask questions.
Meanwhile, Dmitri Vassiliev, who is continuing his work on SlashID this summer, has discovered that generated code is next-to-impossible to debug. Not to be a one-note symphony or anything, but I said in that same article about extensible programming systems that the real challenge is not extending notation, but creating extensible debugging tools so that those notations and high-level representations can be fixed when they break. Robert van de Geijn doesn’t think FLAME needs a debugger; respectfully, I disagree.
Science in the Open has a plea to scientists to make their raw data available, motivated by yet another irreproducible result.
Kosta Zabashta has posted early thoughts about integrating IRC into DrProject. (Gray on black? Kosta…your design skills rival mine…) I need to tell him that DrProject’s RPC module doesn’t handle tickets because Jeff Balogh is going to replace the entire ticketing system with an extensible one this summer, using his Dojo Form Editor as a front end…
Elisabeth Hendrickson has thoughts on automating tests for legacy web applications. Students, take note.
Thanks to Nick Jamil and others, we have instructions for installing DrProject on Windows. Yay!
Everything old is new again, including Ada and the Bletchley Park Colossus.

And then there’s this:

Thanks again to Sergey Fomel for inviting me down, and for introducing me to the reproducible research community—I’m looking forward to many more discussions.

IronPython-URLs: PyCon Italia Presentation Materials Online

2008-05-16T12:45:00+00:00

Menno Smit has put the materials for his presentation on IronPython to PyCon Italy online (the materials are in English). This includes the S5 presentation, sample code and an example Resolver One spreadsheet:

PyCon Italia Presentation Materials Online

Ian Bicking: pdb in the browser

2008-05-16T07:36:22+00:00

People have asked me a few times about evalexception and pdb — they’d like to be able to use something like pdb through the browser, stepping through code.

The technique I used for tracebacks wouldn’t really work for pdb. For a traceback I saved all the information from the frames — mostly just the local variables — and then let the user interact with that through the browser. But with pdb you pause the application part way through waiting for user input, and the routine only completes much later.

While writing WaitForIt I played around with techniques to deal with very slow WSGI applications. Not that hard, really — you launch every request in a new thread, and you manage those requests in an application of its own. So I started thinking about pdb again, and it started seeming feasible. Whenever the app reads from stdin it goes into an interactive mode, showing you what comes out on stdout and letting you add input to stdin. It’s nothing specific to pdb really.

So, with a bit of hacking, I added it into WebError (which is an extraction of the exception handling in Paste). To give the demo a try, do:

hg clone http://knowledgetap.com/hg/weberror/
cd weberror
python setup.py develop
# You need Paste trunk:
easy_install Paste==dev
python weberror/pdbcapture.py

What you’ll see is not polished, it’s just working, but since I mostly did it to see if I could do it, that’s good enough for me.

Nick Efford: Mercurial

2008-05-16T07:16:33+00:00

In the past, I’ve used Subversion for the one-person software development projects with which I’m often involved. Just recently, however, I thought I’d give Mercurial a spin, having heard good things about it and seen a lot of people start using it.

So far, I’m impressed - particularly by the ease with which you can clone a repository to create a new branch for development, and then merge changes made there back into the original. Another nice feature is the ability to view repository changelogs with a web browser, courtesy of Mercurial’s built-in web server. And then there’s the fact that large parts of it are written in Python…

Spyced: Quick tip for debugging with Jython

2008-05-16T06:40:03+00:00

Currently, Jython ships with the pdb debugger module from Python 2.3. Unfortunately the 2.3 pdb is primitive even by command-line debugger standards. (For instance, if the program you are debugging throws an exception, it will take pdb down with it. Seriously. Did anyone actually use this thing?)

Fortunately all you have to do to get a much better experience is grab pdb.py, bdb.py, and cmd.py (for good measure) from a 2.5 CPython installation and run against that instead.

I've only tested this with Jython trunk but I think it should Just Work with the 2.2 release, too.

Jesse Noller: Sausage on the brain.

2008-05-16T01:30:36+00:00

Mandlebraut: Rendering Sausages.

These are the ideas I get when I'm coding and thinking about food.

Jesse Noller: Getting Processing into the stdlib

2008-05-16T01:10:56+00:00

I shot an email out to Python-Dev earlier this week asking for comments/questions regarding my push to get the Processing into the standard library. There's been some decent discussion about target releases and other meta-issues around getting it in.

Right now, it looks like I am going to try to target 2.7 and 3.1 - this makes sense for a few reasons.

First, the PEP deadline was uh, a year ago for 2.6 and 3.0
There's some cleanup on the module which needs to be done
There might be some renaming requirements
Need to talk to R. about a 1.0 release
Need to chunk out some time to convert the tests to unit test format.

That all being said - it doesn't look unfeasible to accomplish - and the response both on list and to me privately has been 95% +1 and 5% -.5 and -1 - the positive response really does make me feel that this is the right approach to take.

I am currently working on revised benchmarks for processing vs. threads vs. pp vs. other right now - I'll be publishing those as soon as I complete them to both here and the mailing list discussion as a counterpoint to some of the open questions.

I'd like to see if any of you, oh internet people, have anything else you'd like to have answered for this or anything you'd like to add to the discussion.

Note, I am not trying to solve the "distributed" problem with the inclusion of this - the remote capabilities of the processing module are a side-benefit - not the primary benefit to trying to get this in. I am taking some of the distributed stuff mentally into account - but the goal is to scratch one specific itch - not to solve everyones problem with a single addition.

Now all I have to get over is some bizarre errors with parallel python ramming into ulimit, uh, limits. Luckily I have everything from a dual core to an eight core to hack on!

Ned Batchelder's blog: Water + laptop = ok

2008-05-16T00:58:59+00:00

This past weekend, someone accidentally spilled about half a cup of water onto my laptop keyboard. I actually shouted "Agghhh!" like a cartoon character, and we all burst into action, grabbing paper towels, mopping up water, moving books, etc.

When I picked up the laptop, water came dribbling out the other side of it, making a puddle on the table. It was not the kind of thing you want to see involving your laptop. The screen started flashing and going into video conniptions, so I flipped the computer over and removed both batteries.

Max searched Google for what to do, and found a page recommending opening every part you could, and blow-drying on the coolest setting. So I got a screwdriver and started opening panels. When I got the hard drive out after 20 seconds and three screws, Max (a hardcore Apple devotee) exclaimed, "Wow, you can get it out just like that!?" I was a little pleased to have at least a small advantage go to the PC.

Max also found the service manual for my model laptop, so we could get under the keyboard and other hard-to-reach places. The scary thing was that no matter where I looked, I saw droplets of water, except on the RAM.

Over the course of two hours, we blow-dried it a few times, marveled at the insides, and discovered new places to poke paper towels to get the last of the moisture out. Finally, I put it all back together, put in the batteries, and booted it up. With a sigh of relief, I saw that it was going to be fine.

Once it was all over, my computer was cleaner, and I learned something to add to my Middle-Aged Man repertoire of minor but useful knowledge.

PyAMF Blog: Flash Player 10 Beta Released

2008-05-15T18:52:54+00:00

Today Adobe released the first beta version (10.0.1.218) of the upcoming Flash Player 10, code named “Astro”. You can download the new player for Mac OS X, Linux and Windows from Adobe Labs (make sure you uninstall older players first). There are quite a few enhancements but unfortunately the documentation of the new APIs isn’t available yet (will be released at a later date through Adobe’s Livedocs system) so I haven’t been able to play with them in Actionscript yet.

Content created with the open source Flex 3 SDK is designed to work with Flash Player 9 (9.0.115.0 and higher) and will continue to function as expected with Flash Player 10. To build Flex content that takes advantage of the new features, you need a Flex SDK 3.0.x nightly build which can target the Flash Player 10 Beta.

Some of the highlights in the new Player:

Speex Audio Codec

The open source Speex voice codec offers an alternative to the older, proprietary Nellymoser for audio that delivers the lowest-latency audio experience possible. Flash developers have requested an open source voice codec since the day Macromedia added Nellymoser to Flash Player 6, and it’s great to finally see it happen at Adobe. Nellymoser audio can be decoded by FFmpeg but unfortunately it looks like Speex is one of the missing formats in the FFmpeg audio codecs list at the time of this writing. For Python there are the PySpeex bindings that allow you to create an audio stream object and encode and decode speech audio data. Other software that uses Speex are Asterisk, the open source PBX, the headsets in Microsoft’s Xbox Live and the in-game VOIP function of Half-Life 1. Java developers might want to take a look at JSpeex, a port of Speex for the Java platform.

Real Time Media Flow Protocol (RTMFP)

RTMFP provides a UDP-based secure network transport alternative to RTMP-over-TCP. UDP (User Datagram Protocol) is an efficient and standardized Internet protocol for delivering media assets because of its support for lossy delivery, improving performance of real time communication. RTMFP is always encrypted which helps protect media delivery. With Speex it will be possible to take advantage of the new RTMFP partial-reliability feature to reduce network latency and it also works over the Flash Player’s Real Time Messaging Protocol (RTMP). PyAMF was created for the AMF support in the RTMP protocol, which we’re trying to build for Python with Twisted in the RTMPy project. Adobe basically baked P2P into the Flash Player and creating applications like LimeWire or VOIP applications like Skype should be trivial.

Dynamic Sound Generation

In Flash Player 10 you will be able to dynamically create audio. The API is designed to provide a low level abstraction of the native sound driver, providing the most flexible platform to build your music applications on. Tinic Uro, one of the Flash Player engineers at Adobe, writes that “the API has one big compromise which I can’t address without large infrastructural changes and that is latency. Latency is horrible to the point where some applications will simply not be possible. To improve latency will require profound changes in the Flash Player which I will tackle for the next major revision. But for now this simple API will likely change the way you think about sound in the Flash Player”. He also mentions that extracting audio data from a microphone and extracting audio from a NetStream object is not possible for this release, but they’re aware that it’s a highly desirable feature. Keith Peters created a sample application that demonstrates the new API.

File Reference runtime access

Macromedia added the FileReference class in Flash Player 8 to give developers the ability to upload and download files using a native Flash Player API. With Flash Player 10 it’s will be possible to save those files back to the local hard disk as well. Files can be accessed as a ByteArray or text using a API in ActionScript without round-tripping to the server. You no longer need to know a server language or have access to a server to load or save files at runtime.

Check out the Adobe Labs wiki for the complete feature list and release notes.

Arthur Koziel: Secure authentication cookies with Django

2008-05-15T16:03:52+00:00

Some time ago Alex X. Liu published a research paper on secure cookie protocols. I tried to implement the protocol in Python, but sadly had to remove some fields from the protocol. You can download it here.

Changes

This is the original protocol:

user name|expiration time|(data)k|HMAC(user name|expiration time|data|session key, k)
where k=HMAC(user name|expiration time, sk)
and sk=secret server key

I removed (data)k and session key, which changes the protocol to:

user name|expiration time|HMAC(user name|expiration time, k)
where k=HMAC(user name|expiration time, sk)
and sk=secret server key

The data field was removed because I couldn’t find a good two way encryption library for Python, and the session key was removed due to the lack of SSL.

The new structure is similar to the one used for the authentication in the backend of the recently released Wordpress 2.5.

Usage

To create a cookie in Django, use the set_cookie method of the response object:

cookie = myutils.generate(‘arthur’, 1210708139)

response = render_to_response(‘index.html’)
response.set_cookie(‘mycookie’, cookie)

return response

Greg Wilson: Student Blogs

2008-05-15T15:20:21+00:00

Some of our summer interns have started blogging about their projects:

I’ll add more as I get them.

IPython0 blog: Embedding IPython in GUI apps is trivial

2008-05-15T14:50:34+00:00

Here is a little known secret: IPython can be trivially embedded to GUI apps with event loops. This is verified to work with Tk and Qt4, at least. What you need to do is this: def embed_ipython(w): from IPython.Shell import IPShellEmbed ipshell = IPShellEmbed(user_ns = dict(w = w)) [...]

Greg Wilson: SE-CSE Workshop

2008-05-15T14:40:17+00:00

One of the downsides of being in Texas is that I couldn’t attend the First International Workshop on Software Engineering for Computational Science and Engineering, which was held at ICSE’08 in Leipzig this week. Papers are here (I’ll be reading them on the flight home); they look interesting, but the biggest thing for me is the change in the workshop’s name—it used to be “Software Engineering for High-Performance Computing Applications” (2004, 2005, 2006, 2007), and I’m hoping the change of name reflects a genuine broadening of focus.

Brett Cannon: What would it take for Python to have a regular release schedule?

2008-05-15T14:45:08+00:00

Mark Shuttleworth has been writing about release cycles in open source as of late on his blog. An interesting thing he is arguing for is some level of synchronization between related upstream and downstream projects. For those of you who don't know what those terms mean, a project is upstream to you if you rely upon it (e.g., Python is upstream to Ubuntu because it relies on Python for its infrastructure, on top of including it in its distribution).

What Mark is advocating is a rough lock-step release cycle amongst upstream projects that are core, upstream applications, and Linux distributions. The idea is that Python, GCC, etc. all release in the same month their next versions, applications follow a month later, and then finally Linux distributions a month after that. The idea is that the Linux distros would then all ship with the same version of their upstream projects (e.g., everyone would ship with Python 2.5.x in 2008, 2.6.x in 2009, etc.).

I have to admit, from a Python developer's perspective, that does sound nice. Because the Linux distributions and their users tend to be a large chunk of the Python users out there, we see bug reports on the various versions of Python that each major distro is shipping. That can be annoying as there is a chunk of time where we can still get reports a whole version behind of what is stable. If a nice chunk of our users moved over to the same version each year the bug reports would be against a consistent version and thus hopefully lead less extraneous bugs being reported about older versions.

Now I don't think a one month spacing is enough for everyone to do thorough testing. I suspect spacing it out over six months instead of three might work out better (but since Python has hardly any external dependencies this is just from outside observation and not experience).

Locking down releases might also help us schedule sprints. If we said we would do major releases every September, and minor releases September and March then everyone would know when to submit language proposals, what they must hit for something to make it in, when python-dev will most likely need extra help to finish that final push to beta, etc. We would then know when betas would hit, and thus have sprints three months before so that there is enough time for crazy ideas that come up at the sprints to be coded, implemented, vetted, and tested before the beta hits.

There are a couple of questions that need to be answered if this were to happen. One is whether python-dev has the discipline to pull this off? I say yes as long as we have a release manager that is willing to take the hard line on reverting patches that don't make the time cut-off. So far that has worked this year with our monthly releases.

Another question is whether we are structured for this kind of thing? Releases take a couple of hours from several people. Now having a regular schedule would suggest that it would be easier for these people as they would know when to expect the big push to hit.

Lastly, do we have the infrastructure and tools? Merging between the trunk and a branch is a pain. But if we really start to hold up features because they don't reach a release point means people really should start all work in branches and expect to miss a release instead of expecting to actually make their target and only shift to a branch if they miss. If this isn't done code goes stale thanks to the length of time it takes for Python to go from beta to a final release (this is why I shifted my importlib work to bzr since I expected I would miss 3.0).

If the final releases for 2.6 and 3.0 go well I might try to push for a regular release schedule for Python.

Greg Wilson: Another DrProject Design Question

2008-05-15T13:42:52+00:00

We’re pleased to welcome Liz Blankenship, a Season of Usability intern, to the DrProject team. Liz, a grad student in HCI, is going to help us redesign DrProject’s admin interface. Along the way, I’m hoping she can give us some advice on a few other things as well, chief among them the notion of the “All” project.

The background is this: Trac (DrProject’s ancestor) only allows one project per installation. We weren’t going to install it forty times to manage a class of eighty students working in pairs, so one of the first things we did back in 2005 was extend it to support multiple projects per portal. We then faced two questions, which we decided were related:

What project does a newcomer to the portal see by default (i.e., what’s “home”)?
How do reach everybody who has an account with a particular portal (e.g., to nofify them of impending downtime)?

Our solution was to say that every portal has an undeletable project called “All”. Every user of that portal is automatically a member of that project, so mailing “all@wherever” will reach everyone, and that project’s wiki acts as the portal’s home page. As a bonus, this also provides a logical place for people to file tech support tickets: if you need your password reset, for example, you could file a ticket against “All”.

It was nice in theory, but it hasn’t worked out that well in practice:

Lots of people find it confusing. This might be the project name (some people think that registering for “All” means asking to be put in all of the projects managed by a portal), but I don’t think that’s the whole story.
There turned out to be lots of reasons not to automatically include everyone in the “All” project. For example, external clients for undergraduate projects really don’t care about administrative matters; they only want email forwarded from their specific project, so we had to allow people to opt out and/or turn off email forwarding.
Almost nobody figures guesses “ticket All for tech support”. Instead, many users file tickets against “All” that should go against other, more specific, projects. Since we don’t have a way to move tickets from one project to another, this causes recurring irritation.

So what should we do? Options include:

Change the name of “All” to something like “home”. This would be (nearly) trivial, but it seems unlikely that a simple renaming will actually solve our problems.
Modify the URLs so that the project is a parameter, rather than part of the path; if a project isn’t specified, take the user to a default project. This would make the URLs harder to read aloud (a test I think any good web application should pass), but it would be more reliable than using URLs that might or might not contain a project name.
Get rid of “All” and:
1. require admins to mark one project as the landing pad, or
2. give people a 404 if they don’t specify a project when trying to connect.
Create a special kind of project for the landing pad with:
1. a wiki that can only be edited by the admin,
2. that automatically says something informative about all the public projects,
3. and whose mailing list includes every user, but can only be sent to by the admin.

As you can guess, #4 is my current favorite. It could even be implemented without significant code changes, by defining a new role and giving every user who isn’t an admin that role in the default project. There’d still be the problem of its name, though.

So, what do you think we should do? And why?

Peter Bengtsson: split_search() - A Python functional for advanced search applications

2008-05-15T13:00:00+00:00

Inspired by Google's way of working I today put together a little script in Python for splitting a search. The idea is that you can search by entering certain keywords followed by a colon like this:

Free Text name:Peter age: 28

And this will be converted into two parts:

'Free Text'
{'name': 'Peter', 'age':'28}

You can configure which keywords should be recognized and to make things simple, you can basically set this to be the columns you have to do advanced search on in your application. For example (from_date,to_date)

Feel free to download and use it as much as you like. You might not agree completely with it's purpose and design so you're allowed to change it as you please.

Here's how to use it:

$ wget http://www.peterbe.com/plog/split_search/split_search.py
$ python
>>> from split_search import split_search
>>> free_text, parameters = split_search('Foo key1:bar', ('key1',))
>>> free_text
'Foo'
>>> parameters
{'key1': 'bar'}

IronPython-URLs: IronPython in Action: New chapters, website and sourcecode

2008-05-15T12:43:00+00:00

Three new chapters (on WPF, ASP.NET and system administration) are now available in the IronPython in Action Early Access Program. There is now a new IronPython in Action website, where the sourcecode to accompany the book (well - the first eleven chapters so far) can be downloaded:

ironpythoninaction.com: New Chapters and Sourcecode Available

IronPython-URLs: IronPython - Classes within separate files

2008-05-15T12:41:00+00:00

Ben Hall comes to IronPython from 'traditional' .NET languages like C# and VB.NET, which have a different way of structuring applications into namespaces. In this blog entry he explores how Python uses files to arrange classes into modules:

IronPython - Classes within separate files

IronPython-URLs: IronPython for Printing from Second Life

2008-05-15T12:38:00+00:00

Peter Quirk muses about whether he can solve the problem of not being able to print from within the Second Life environment by using realXtend, the scripting host for IronPython:

Pursuing a solution for printing a notecard in realXtend