Tao of the Machine

File retriever for PyPI?

This is just a thought, but now that the PyPI repository seems to have quite a few entries, is there also a way to easily retrieve packages?

It would make sense, IMHO; you can submit software through an online form or a script; the next step would be automatic retrieval. For example,

pypi-get.py wxpython

would use PyPI data to download the latest version of wxPython. Of course, refining should be possible;

pypi-get.py -v 2.4.2.4 wxpython

would download wxPython version 2.4.2.4, even if a newer version is available. Other switches I can think of:

pypi-get.py -f wxPythonWIN32-2.4.2.4u-Py23.exe
# if you know the filename

pypi-get.py --install wxpython
# try to unzip/install software after downloading

pypi-get.py --source wxpython
# download the source (default is binary)

pypi-get.py --platform=unix foobar
# download the Unix version of the 'foobar' package

etc.

An alternative approach could be, showing all the packages in a GUI, and let the user select them for downloading and installing. (Much like Fink, and the Cygwin installer, etc.)

Is this already possible? Would it be considered useful?

In theory, it would already be possible to write such a program, using the web interface. (Send a search string, scrape the resulting HTML form, download URL, find out download URL, download file.) That would be clumsy though; a dedicated interface would be better, e.g. a PyPI action that would return a record in XML format, or something like that.

Another caveat is that the "download URL" doesn't always point to a downloadable binary. In the case of wxPython 2.4.2.4, it points to the wxPython download page. Other packages have Sourceforge download URLs, which redirect you to a page as well.

But maybe this is already possible, and I have been blissfully unaware of it? (I haven't really been following the distutils and catalog SIGS.)

Designing a card game (interlude)

Maybe I should make a redneck-themed game, that should sell well around here (or so I hope :-). I could include such staple cards as:

• Roadkill
• My Cousin, My Wife
• Monster Truck
• Bubba
• Wide Load
• Burping Contest
• My Brother Daryll
• My Other Brother Daryll
• Roach Infestation
• Huntin Dawg

I wonder if people here would see the humor of it and buy the damn game. Hmm... I won't hold my breath.

Programming adventure games, anno 2003

Let's say that I want to write an adventure game. (By this I mean a text adventure, or interactive fiction.) In Python, or whatever; doesn't really matter.

This type of program is quite interesting, because modern ideas about good programming practice don't really apply to it. I can see at least two issues:

Problem 1: Incremental development. Sure, you can "do the simplest thing that possibly works", and add new features from there, incrementally. Works for many programs of all kinds. The problem is, that you cannot *release* the adventure until all parts are in place, unless your players are willing to put up with missing features. It sounds like an interesting idea: "version 1.2 now has 4 new quests", but somehow I don't think this would work. Playing the same game again just because it has a few extras?

So, I don't think "release early & often" will work here.

Problem 2: How to test it? Indeed, how *do* you test an adventure game? Can it be tested efficiently?

There's a difference between testing the basic stuff (does command X work?) vs testing "everything". The latter seems impossible. There are countless, maybe infinite situations; how can you possibly test them all? Even if we restrict the tests to every possible command with every possible object/person, that will be a hell of a job to test.

But, let's say we're going to try it anyway. How would one approach this? Maybe we need some kind of automation mechanism. Set up an environment... player in room X with objects Y and Z, creatures C and D, and objects E, F and G in inventory, execute command, test if it has the desired result.

A testable system like this might be useful. I'm not sure what the current state of the art is in the IF world; do systems/languages like Inform support testing? Or are IF authors still on their own (and dependent on playtesters) when it comes to verifying their games? I'll have to find out.

RPGs and adventures

RPGs and text adventures (also known as interactive fiction) are among my favorite types of games. They are not without problems, though. Adventures usually have little replay value. (The next time you play it, you already know what to do and what is going to happen.) RPGs theoretically have lots of replay value (never the same game twice), but I find that they get boring really quick. (You can’t get past that guy yet, so you have to level up, by picking lots of fights with lesser creatures. Repeat.)

When my daughter played Final Fantasy X (on the PS2), it looked like fun at first… interesting beasties to fight with. But after watching it for a while, the same creatures came up over and over again, and she was running pointlessly around in the same area, so random fights would start, in order to get to the next level and obtain some decent stats.

C’mon, even 3D shooters are more interesting than that. When I killed the baddies in Doom or Quake or Duke 3D, or recently in Heretic 2, then that had a purpose… they barred your way to progress. Such games are less repetitive because you move on. That is even true for breakout games, dissed by some as the most repetitive games ever.

I wonder if text adventures and RPGs can be mixed. I mean, adding RPG elements to an adventure should not be too difficult. Such a game could be very interesting. In fact, I’ve been playing with that idea for a while. I don’t think anybody would want to play it, though. :-(

*scratch*

And now for an update on my projects… Firedrop is kind of stalled. Like a beached whale, it won’t move in any way, and even if it was in the water, it would still be a big ass boondoggle. (OK, my talent for metaphor isn’t always up to snuff…)

Something went wrong along the way. It started out simple, but quickly grew in ways I didn’t really want it to.

Maybe I should rethink my goals, and restart from scratch. What if we keep it extremely simple? Sort of like Blosxom… posts are just files. I can still do the attribute thing. I can also provide a primitive GUI, because we need some convenience when editing… I won’t go as far as requiring people to use a text editor (although they are of course free to do so if they want to). There would still be embedded code. Simple Textile support (like Kaa 0.9 has it), as well.

Kaa is far, far from perfect, yet there are some things that it does better than Firedrop. I especially like how you can tell it that a post uses Textile, for example… just use a single ’#’ on the first line. In Firedrop, there are attributes that can be used for this, in several places. Not as easy. The new Firedrop should Keep It Simple as well.

Since this will be a tool for Python programmers, maybe a simple API would be best. User/programmer wants something more than the system offers out of the box? It should be easy to write your own code that manipulates the entries.

Hmm. We’ll see. Even now I have the feeling that the new ideas are still not simple enough. Enter minimalist mode…

An idea

Recently I've been looking up sites about various parts of the world... Sao Paulo, Costa Rica, Belize, etc. These sites are interesting, but I usually don't get to see them unless I have a specific reason. With a clickable world map, you could explore. When you're bored, you could go to that page and actually see something of the world, rather than reading yet another blog with political drivel or personal ramblings <wink>.

Rather than linking to specific sites, the world map could do a Google search. For example, clicking on the "pixel" for Sao Paulo would give you this.

I have of course no time for this, but since when has that stopped me from lauching weird ideas? :-)

Update. Something like this, but different.

Fed up

Seriously folks, I'm probably not the right person to do this (given my goldfish-like 20-seconds attention span and all that), but it's worth a try. I have big plans for this, but it could very well turn out to be a big failure. So, for now, all I'm going to say is that I started writing an editor for my own use. Some of the less lofty goals are that it should be easy to use, and that it should be easily extendable and expandable. (In Python that is.) It should be a bit like in Kaa, in that I want it to reach a useable status quickly, and then start using it, adding new features when I see fit.

Why not use vi or emacs (shudder)? vim is cool, but my major gripe with it is that if I open 20 files, I have 20 windows floating around. The Windows taskbar doesn't make it easy to see the filename. Unfortunately, vim doesn't use a tabbed notebook or something, so I want an editor that does.

More on this later. Maybe.

By the way, I'm using Tkinter and Pmw. Good documentation for both, at least to get going.

Another loony idea

• No access to a bookmark because you happen to be in the wrong browser. (I currently have IE5, Netscape 4.7, Mozilla, Opera and Phoenix installed. They all have bookmarks.)
• I tend to lose bookmarks when moving to a different machine, uninstall a browser, reinstalling an OS, etc.
• Bookmarks are unorganized. They're little more than a long list of titles of pages. Sure, you can organize them, but in some browsers this isn't so easy.

To make this work, we need a program that:

• manages and organizes the links in categories
• exports them to HTML at will
• uploads them

I could even take this another step further and mix it with a content management system. It stores stuff, and is capable of publishing it as well. Hmm. This needs more thought...

Content management made easy?

1. an easy way to "tag" an entry, i.e. associate it with a certain word, e.g. "faq", "main", "index", "ideas-page", etc
2. an easy way to display these tags in a list of entries, and/sort on them ("only show me the entries with tag X")
3. an easy way to generate pages with the given entries

#1 would not be difficult, either. We already use categories and the visible key in the entry.misc dictionary. Adding a tag, or several, would be trivial.

#2 isn't there yet. We would need a multi-column widget, or a table widget, or something. Sorting isn't there yet either, but that isn't so difficult.

So what can we do with the above? Easy content management. Create a new "blog" (IOW, a collection of entries), add entries, and "tag" them to associate them with a certain page. Some entries will make up my FAQ. Some may make up my main page. Some are documentation. Putting an order in is trivial by adding "sub-tags", like a number. (For example, if there are 20 entries with the "faq" tag, then we could figure out the order of the FAQ questions by using the "order" key which contains a number.)

The tricky part is to get the "tag management" right. If that is easy to do, then building a site will be easy to do. Same for generating the custom pages. There should be some default, like, associate a page name with a tag name, and generate that page in a custom way. For those who want more, there's always pagegen.py.

Content management, part 3

• A "project" would span a website rather than just a weblog.
• Within a project, multiple sections could be made. A section would be basically a collection of entries, much like Kaa has now.
• An "entry" or "post" is just a piece of HTML, again, just like Kaa.
• What to do with these entries, depends on the purpose of the section. You could have several "profiles" to choose from, e.g. weblog, articles, FAQ, documentation, etc. Depending on the profile, settings would differ, and so would some things you could do internally (in embedded code) and options. ("Categories" for example makes sense for a weblog, but probably not for a FAQ or documentation.)
• Some settings could be project-wide, and you could choose to override them per section, or just leave them alone.
• Similarly, publishing could be for the whole project, or per section.