What was the project that made you feel skilled in Python?

Question

I'm trying to come up with more project ideas for intermediate learners, somewhat along the lines of
http://bit.ly/intermediate-python-projects .

So here's a question for people who remember coming up from beginner: as you moved from exercises like those in Learn Python the Hard Way, up to your own self-guided work on small projects, what project were you working on that made you feel independent and skilled? What program first felt like your own work rather than an exercise the teacher had assigned?

I don't want anything too large, but big enough that there's room for design, and multiple approaches, etc.

Answer 1

Easy answer from me: The Yosemite project. And the code still looks like a n00b wrote it. (On that subject: Pull requests welcome.)

The code is here: https://github.com/Rosuav/Yosemite

I wrote it in Python because I wanted to be able to run it on either the Windows box that drives our TV system, or the Linux box that actually stores the content. And it's still doing that, quite nicely.

Yosemite is a pretty simple system. It's broadly similar to a classic file-serving web server, but instead of making files available fo download, it invokes them locally. There are plenty of other ways to
achieve this, and I'm by no means sure I picked the best, but that's where it's at, and it was my first real Python project that's been published.

Answer 2

IIRC, my first production python projects were a bunch of file parsers. We had a bunch of text file formats that we worked with often. I wrote some state-machine based parsers which slurped them up and gave back the contents in some useful data structure.

Many of the files were big, so I added an option to write out a pickled version of the data. The parsing code could then check to see if there was a pickle file that was newer than the text version and read that
instead. Big win for speed.

Then, of course, a bunch of utilities which used this data to do useful things. I remember one of the utilities that turned out to be really popular was a smart data file differ. You feed it two files and it would tell you how they differed (in a way that was more useful than a plain text-based diff).

Answer 3

I wrote a library supporting fixed length field tabular data files. It supports reading specifications for such data files using configparser for maximum verbosity, plus a few other shorthand specification formats for brevity. Due to the nature of my work I need this library in virtually all my other projects, so I consider it a personal success and found it interesting to build.

Similar packages on PYPI made many different design decisions from the ones I did, so it seems like fruitful design discussion points could arise.

For example, two major design goals in the beginning where:
1. Ape the interface of the csv module as much as possible.
2. Support type declarations.

The former was a big success. I've had instances were switching from csv to a fixed file required changing one line, and of course if a person were learning the library their knowledge of reader, writer, DictReader and DictWriter would help.

The latter design goal was a failure. Most published fixed-length data file specifications include data types, so it seemed natural. But after trying to write programs using an early version I ended up removing all traces of that functionality.

One advantage of this idea as a project for an intermediate programmer is that the implementation is not complicated; most of the fun is in the design.