[storm] some questions about Storm (from the perspective of Grok)
Martijn Faassen
faassen at startifact.com
Sun Mar 16 12:12:06 GMT 2008
Stuart Bishop wrote:
[snip]
> An application that doen't need to scale to vast amounts of users or massive
> quantities of data is a Noddy application by my definition.
I don't know what "Noddy" means, so you can define it as anything you
like. :) I take it you don't want Storm to be a fit for Noddy applications?
> That doesn't
> mean they are not useful (and this is why I don't use the real world term
> here). You don't care about the scalability issues with generated schemas
> because scalability isn't an issue. You don't care about integrating with
> existing data sources because there are none. You don't care about
> maintainability or upgrades because data model required by the application
> is so simple it doesn't matter.
Quibble: I can see a schema generation system care about maintainability
and upgrades, such as apparently RoR is able to do. Just not in the same
way as you'd do with a Vast Application.
> Just don't try to retrofit scalability later.
Actually, it may still be worthwhile to do this in some cases. Time to
market matters, and apart from that, many developers are encouraged when
they get something running quickly, even if it's a bit dirty. Such an
application may still grow into something scalable later on. The
transition will in many cases be painful, but it might nonetheless be
worthwhile to go this route for a project.
[snip expressing advanced features of relational database schemas are
hard to express in a Python-driven schema]
I am not debating that Python-driven schema are what everybody should
use, or that they should in all circumstances. I accept the arguments in
favor of hand-written schemas. I don't think that schema generation is
the unadulterated uselessness/evil that I am picking up from the vibe here.
>> Do you think that SQL *queries* created by tools such as Storm are
>> also so inferior to hand-written queries that they are only suitable
>> for toy applications? If not, why is query generation already there
>> while schema generation is not?
>
> The SQL queries generated by some ORMs are vastly inferior. Storm and other
> ORMs targetting non-Noddy applications are designed to allow formulation of
> complex queries with enough control to have them perform efficiently.
I find the differences here fascinating. What makes generating queries,
with all their complexities, all right and useful but generating schemas
something that shouldn't be done? Is generating queries correctly that
much easier?
> And if
> the Python syntax turns out to not offer fine grained enough control or
> access to that proprietary feature you need to access, then you can fall
> back to using SQL fragments but still have the results retrieved into your
> object model.
Yes, same argument applies to schema generation too, though.
[snip]
I think I'm dealing with a cultural issue here: it's an important part
of the Storm approach to want to write these schemas in SQL. There are
of course excellent reasons to do this in many circumstances. I do have
the feeling it's like arguing about threading to Twisted developers - it
might be instructive but it is not very useful. :)
Regards,
Martijn
More information about the storm
mailing list