

Django 1.5 beta release notes - kgrin
https://docs.djangoproject.com/en/dev/releases/1.5-beta-1/

======
quaunaut
The two big headline features, the configurable User model and Python 3
support, are both huge. The first, because as is right now, simply extending
the User model feels janky and possibly broken, and the second, because Django
is probably one of the biggest reasons people have not moved onto Python 3.

~~~
methoddk
Django is definitely my reason for not moving over to Python3.

~~~
SiVal
And Python3 is definitely my reason for not moving to Django.

Python3 became the living branch of Python during the Bush Administration.
Django has been claiming ever since that there is just so much _stuff_ in
Django that, even in early 2013, they won't be able to honestly recommend it
to Python3 programmers, except for "experiments".

So with this much baggage, what chance is there that Django will soon become a
sleek racehorse of a Python3 framework? It could happen, or not, but I'm
probably not the only one in the market for a sleek racehorse based entirely
on the living branch of Python.

~~~
ubernostrum
_Django has been claiming ever since that there is just so much stuff in
Django_

Well, no.

There are basically two competing things that made this take a while, and
which both stopped being issues right about the same time.

The first was that the initial Python 3 releases _were not_ production-quality
stuff. They worked, but they were there to let people get a feel for the
changes and maybe start trying out the porting process. Anyone who just jumped
to Python 3.0 shortly after release probably had no idea what they were doing
(or had a _very good idea_ what they were doing, but that group was a lot
smaller).

The second was that we've got this thing, called a userbase :)

And, well, lots of 'em were running operating systems that were still shipping
ancient stuff like Python 2.3, and we didn't really want to throw them under
the bus, especially since it was mostly beyond their control -- a corporate
department said "OK, we're going to go with RHEL", and that was that. So we
waited a bit for that situation to start improving, and kicked off a process
of deprecating one 2.x version each of the last few releases until, with
Django 1.5, we're at a minimum of 2.6.

As for the "stopped being issues" part: Python 3.2 and especially Python 3.3
are _very_ nice, much more mature releases than 3.0/3.1, added stuff that
makes porting much less ugly, etc. etc., so suddenly running production stuff
on Python 3 is really broadly viable. And, hey, we're on a minimum-2.6 stance
now, and 2.6 is when the really nice porting and unified-codebase stuff got
added!

~~~
SiVal
Thanks for responding. This is food for thought and may be encouraging. We
"just jumped on Python 3.0 shortly after release" and have been using it
without a glitch for four years. I don't doubt your claim about Python 3.0's
"readiness for production", though, because workstation number and text
crunching "production" and high-volume web "production" are so different, but
(in addition to other languages) we've been using Python3 as our only Python
for years with no (known) problems.

I'd prefer to start doing webdev in Python3, too, as long as we can just work
in Python3 without having our framework's (or our framework's vast, tortured
userbase's) endless upgrade problems become our problems. We have no Python2
legacy baggage of our own, and I have no desire to go back and pick up anybody
else's.

So when, approximately, will Django 1.6 ship, with "no reservations" about
Python3 for production?

And do you have an estimate for when Django will deprecate Python2 entirely,
so that Python3 programmers will become the assumed target for all features,
docs, tutorials, code snippet examples, add-on modules, etc?

------
elithrar
> Configurable User model

This pleases me greatly. No longer do I need to rely on plug-ins (and
therefore, them being updated) to minimally extend the existing User model for
small projects.

~~~
rheide
You could already extend the user model with a OneToOne relation plus setting
in settings.py that was supported in the official Django distribution. But the
way that was handled was a bit hacky so I'm glad they changed it too.

~~~
wahnfrieden
Yea and incur an extra DB lookup every time. This is very welcome.

~~~
the_cat_kittles
not to mention tastypie headaches when trying to update nested resources
(user->userprofile->something else)

------
scommab
Major Highlights:

\- Python3 support! (supports python2.6.5+ and python3.2+ in the same code
base)

\- {% verbatim %} (no collision problems with mustache)

\- Built-in Partial model saving

------
Alex3917
If I want to create my own database and write my own SQL queries instead of
using Django's object models and ORM, does it still make sense to use Django's
user model in my project?

~~~
est
Yes, all those password handling, django admin integration, Request.User
object, etc.

------
jfb
Can someone point me to a compare/contrast sort of doc between modern Django
and Rails? I don't do a lot of web app programming, but I'm curious as to
whether there's much of a difference between the two.

~~~
jarcoal
Rails is written in Ruby, and Django in Python. That's by far the biggest (and
maybe only) difference.

~~~
jfb
Sure. But, for instance, is Django as tied to the active record pattern as is
Rails? And yes, I know you can swap out persistence layers in modern Rails,
which is good (because active record is _utter bilge_ ), but who does that?

&c.

~~~
jarcoal
Maybe I misunderstood your question. If you're looking for reasons to pick one
over another, then it's whichever language you know best.

Web frameworks really only differ in philosophy, and in this case, both are
batteries-included, monolithic frameworks. They are practically identical
solutions.

~~~
andrewingram
Philosophically they're quite different. Every layer follows a different
approach: templates, controllers (views in Django), urls, model definition,
ORM etc. A lot of this comes from the core philosophies of the languages,
whilst Ruby and Python may be closer to each other in philosophy than either
are to say Java, they still have substantial differences.

------
hayksaakian
> python3 support

Go on

~~~
ceol

        We’re labeling this support “experimental” because we don’t
        yet consider it production-ready, but everything’s in place 
        for you to start porting your apps to Python 3. Our next 
        release, Django 1.6, will support Python 3 without 
        reservations.

~~~
josephlord
I haven't tested it and I might be being unfair but I have a feeling that
Django's experimental non-production-ready release may be comparable to other
web framework's normal production releases in terms of stability.

Although obviously plug ins and other components would also need to be
compatible too.

~~~
hayksaakian
Excellent, now all I need is a railscasts equivalent and I'm ready to test the
waters.

~~~
josephlord
Don't take my word for it, I'm guessing based on my impression of Django. You
know some projects you want to avoid the .0 release and others are pretty safe
at the beta release. I just have the feeling that Django is at the safe end. I
don't have any data to back it up at this point though.

