Hi Jean-Christophe,
Before I set out (on something that has turned out longer than I
intended, as usual), I want to say that although these answers don't
seem very specific and almost certainly aren't addressing things in the
language -- using a direct comparison to Java -- you would like.
However, that's because there really is a bit of a language/concept
mismatch between the Java world and, well, pretty much anywhere else,
but particularly the Python world. It's not antagonistic or anything (on
the whole), but the domain language differences (I mean "Java terms" ->
"Python terms", not French to English) means that it sometimes seems a
bit mind-twisting to convert from on to the other.
I've also gone into possibly more detail than you care about here so
that we've got something in the archives in the future for people to
ignore when they repeat this question. :-(
It's would be accurate to say that something Django doesn't have at the
moment is any kind of, say, whitepaper called Introducing Django to Java
Framework Developers that plays the role of translation tool. Partly
that's because it's not hugely worth doing that before a little
stability sets in at 1.0 -- the corporate Java community tends to be
less accommodating of rapid change than the Python community -- and
because there's some really specialist knowledge required to do it well,
since you need to be familiar with both areas. Few people are going to
have that knowledge combined with the motivation.
What will almost certainly happen when we (the community, not anybody in
particular) get a chance is to take some of the more sensible Java
example problems and write them using Django (emphasis on 'sensible': I
will personally ruin the life of the first person to implement "pets by
mail" in Django as a case-study). That will at least provide the
beginnings of a dictionary for people who like reading code.
The next step is to write similar things with more words and less code
for the technical manager and above level, who may not have fewer
skills, but usually have less time to play around with something before
working out whether it needs the time. At the moment, this stuff isn't a
priority for the maintainers, as we've got other things that are more
important, but given that it's a volunteer-driven community, anybody can
step up and write this stuff if they want.
On Sun, 2008-02-17 at 07:02 +0100, Jean-Christophe Kermagoret wrote:
> Hello, I'm coming from Java world and I'm looking in Django for a high
> level framework to write very quickly new applications.
> Does Django provide the following features ?
The answer to many of your questions is both "yes" and "no", since
almost all of these things are items that work in conjunction with
Django or are built on top of it. Given that there's another thread
going on that's providing more or less the same spin on things (which
you've already replied to), I'll just put down brief answers here and
refer you to the other thread (and -- please! -- the documentation) for
the philosophy and details.
Keep in mind, though, that Django tries very hard not to make a decision
for you in areas outside of its specific domain. So HTTP
request/response handling and providing a way to call function X for URL
Y with data Z, putting a bag of data into a layout (template) and
turning that into a string for output, and providing persistence and
retrieval of data is stuff Django does. Most other things are orthogonal
to that -- in that there's no direct dependency -- so Django doesn't
provide them and just gets out of your way. There are other Python
libraries around that provide those extras and they, similarly, work on
their own area and leave the rest to, say, Django.
> * JSR 168 (or portal alike) component, with aggregation and
> personalization ? Is it possible to personalize it through the user's UI
> like in netvibes ?
Fortunately (or unfortunately in my case), I've read JSR 168 and know
what it's trying to do, so I can draw some comparisons.
The answer is "yes" in the sense that any model-view-controller
situation can be modelled with Django. The answer is "no" if you mean
"out of the box" and "in the same way Java does it", since Django's
templates and view functions are split a little differently to what you
might be used to if coming from the Java frameworks world.
The split between Django's template and business logic functions is
different to a lot of Java frameworks. The tendency is to collect all
the data up front (in Django) and then push it to the template for
display. I'm simplifying a bit there, since template tags can execute
arbitrary code, so anything is possible, but the "normal" sort of Django
information flow tends to be more linear than in a lot of Java
template-driven situations I've worked in.
> * Business model's automatic persistence ? What are the limits ?
The problem is that "automatic persistence" implies there's some natural
point to save data, which isn't true in most cases. It's sometimes true
in some container-like setups because the call/response flow is a lot
more restricted. However, the only real life-cycle management that you
have in Python is variables going out of scope and that's not a reliable
indicator of when to save, since Python uses "pass by reference" and
reference-counting to determine the lifecycle, so something may not go
out of scope until long, long after it was last updated. Also, Django is
totally driven by incoming requests. There's no background server
running code periodically or anything like that. It makes it very robust
(this is part of the "shared nothing" architecture that things like
Django and PHP and a bunch of other frameworks use -- no cross-request
overlord process, so nothing that can fail in the background). That
means there's no direct Javabeans equivalent, for example.
You'll probably be better placed to ask questions along these lines if
you work through, say, the initial tutorial first to get used to how
things work. Again, the template/view/ORM split being a little different
to what you're used to probably comes into play here.
The business logic in Django is mostly in what we call the view
functions (which don't correspond to the "V" in "MVC") and any other
functions they call. The data that is acted upon by this code is in the
models, managed by the ORM. You have to call save() on those models, but
that's pretty natural, since you're writing Python code in any case.
The flow is (highly simplified, but not fundamentally incorrect or
omitting important parts)
1. request comes in
2. view function is called based on URL, given request data
3. view function does whatever it likes
4. (Normally/optional) view function constructs a dictionary of
data (the context) and sends that, plus a template to the
template rendering function, which returns a string -- the
output.
5. view function returns an HttpResponse object containing
whatever should be sent back to the caller.
> * Forms management ? What kind of widgets are already available ?
Read the forms documentation for this:
http://www.djangoproject.com/documentation/newforms/
The short answer is that Django provides a way to render all HTML
form-related elements, with full control over the attributes you attach
to them, plus you can easily write your own objects to render anything
else you might like.
> * Data vizualisation management ? Are there any ajax components already
> linked in Django ?
There's the databrowse application to give a way of browsing existing
data to try to spot relationships; that answers the first question.
However, that's more of a developer's tool than anything else -- very
useful for its purpose, though.
For the second part: AJAX and Django are orthogonal. Django provides a
way to implement the above five step process, primarily. AJAX provides a
way for the client to call the server. So you can use whatever AJAX
library you like. It still just sends data to a URL, which is processed
by a Django view function. There are plenty of examples around the Web
of people doing that. Generally the community is pretty good at
contributing back via blog post write-ups of any experiments they've
done.
> * Workflow management ?
Again, a bit non-specific. You can do whatever you like. You're asking
about something that doesn't make sense at the level Django operates at.
It's basically a Python library. "Workflow management" doesn't exist in
Python code (or pretty much any programming language). You could easily
-- and people often do -- design models that have a "current status"
field and which your business logic functions work with.
> * Reporting management (through Birt, iReports, another ?) ?
Again, not something that makes sense at the level of Django, since it's
mostly orthogonal. Reports are made from data in the database and
anything can query the database. On the other hand, there's not natural.
The only interaction that's really needed is working out which fields
mean what from the models and conveying that to the reporting producing
code.
If you're asking in the "Django + world" view whether an application
eqiuvalent to iReports exist, I don't know of anything, but that could
be because I've never had to go looking. I suspect it wouldn't be hard
to write something that's fit-for-purpose, though. People have already
written tools to introspect the model structure for other purposes (e.g.
http://code.djangoproject.com/wiki/DjangoGraphviz ).
Regards,
Malcolm
--
The only substitute for good manners is fast reflexes.
http://www.pointy-stick.com/blog/
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-users@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en
-~----------~----~----~----~------~----~------~--~---
