Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.

Post Syndicated from Bradley M. Kuhn original http://ebb.org/bkuhn/blog/2008/11/20/podjango.html

I had yet to mention in my blog that I now co-host
a podcast at SFLC.
I found myself, as we launched the podcast last week, in a classic hacker
situation of having one project demand the need to write code for a
tangentially related project.

Specifically, we needed a way to easily publish show notes and
otherwise make available the podcast on the website and in RSS feeds.
Fortunately, we already had a few applications we’d written using Django. I looked briefly at django podcast, but
the interface was a bit complicated, and I didn’t like its (over)use of
templates to do most of the RSS feeding.

The small blogging application we’d hacked up for this blog was so
close to what we needed, that I simply decided to fork it and make it into
a small podcast publisher. It worked out well, and I’ve now launched a Free Software
project called podjango under the AGPLv3.

Most of the existing code will be quite obvious to any Django hacker.
The only interesting thing to note is that I made some serious effort for
the RSS
feeds. First, I heavily fleshed out the
minimal example for an iTunesFeed generator in the Django
documentation. It’s currently a bit specific to this podcast, but should be
easily abstracted. I did a good amount of research on the needed fields
for the iTunes
RSS and Media RSS
and what should be in them. (Those feedforall.com tutorials appear to be
the best I could find on this.)

Second, I did about six hours of work to build what I called SFLC’s ominbus RSS feed.
The most effort went into building an RSS feed that includes disparate
Django application components, but this
thread on query set manipulation from django-users referenced from Michael
Angela’s blog was very helpful. I was glad, actually, that the
ultimate solution centered around complicated features of Python. Being
an old-school Perl hacker, I love when the solution is obvious once you
learn a feature of the language that you didn’t know before. (Is that the
definition of programming language snobbery? 😉

It also turns out that Fabian
Scherschel (aka fabsh) had started working on on a Django podcast
application too, and he’s going to merge in his efforts with podjango. I
preemptively apologize publicly, BTW, that I didn’t reach out to the
django-podcast guys before starting a new project. However, I’m sure
fabsh and I both would be happy to cooperate with them if they want to try
to merge the codebases (although I don’t want to use a non-Free software
platform like Google Code to host any project I work on ;). Anyway, I
really think RSS feeds should be implemented using generators in Python
code rather than in templates, though, and I think the user interface
should be abstracted away from as many details for the DTD fields as
possible. Thus, it may turn out that we and django-podcast have
incompatible design goals.

Anyway, I hope the code we’ve released is useful, and I’m glad for
Fabian to take over as project lead. I need to move onto other projects,
and hope that others will be interested in generalizing and improving the
code under Fab’s leadership. I’m happy to help it along.