At 5:00 PM +0100 3/11/99, Robert Claeson wrote:
>> At 4:08 PM +0100 3/11/99, Robert Claeson wrote:
>> >Well, then scale up to a servlet engine such as IBM WebSphere. It
>> >supports servlets, Java Server Pages, load balancing, state
>> >management, database pooling, front-end caching, Corba, etc etc
>> >etc... It's still the same API, though.
>>
>> Oh definately.
>>
>> However, that's more of an application server using the
>> servlet API.
>
>Given that servlets are pretty "standard", i.e. used by several
>vendors, then please let me know why a client would lock themselves
>in to the WO product. I'm serious here, I need to explain this to a
>new client on monday.
First off, when you go with an app server, you're locking yourself into
whichever product you go with?
How you might ask?
Well, while the API for how the http server fires off java is well
established via the servlet calss... the classes to manage your application
server are not. Thus, to handle state, cache, session, pooling, etc... is
usually done via proprietary objects provided by the app server.
This is a trend I noticed when evaluating the different app servers.
So you might want to get rid of the notion that you're locked into WO yet
not locked in other environments just because they are servlet based.
To answer why WO is better than the rest, the one answer is RAD.
Rapid Application Development.
While the benefits of object programming and design are reasons to go with
something like Java, the next value of object design is some sort of visual
tool that allows you to work with the objects in a non-procedural way.
For example, most of us when we write C++ or Java programs just use our
compilers and start coding. We write our own init routines which initiate
our objects. We write our own code to get the presentation we want
(whether via HTML or in typical client programs via other OS APIs or AWT
like stuff in the case of Java). This typical method while traditional is
slow and tedious.
Enter a RAD environment.
Now I'm just going to use this as an example so don't be critical...
VisualBasic is a good example of why RAD is powerful. One can simply
definre a window and start choosing objects from a palette for placement in
the window. The visual state of the object is set via properties (or
members of the class). The developers does not have to write
initialization code. Just a few well placed pieces of code and the RAD
tool allows the developer to design an entire UI with program logic in
short order. Compare this to spending the hours it usually takes to code
all the initialization of windows and the window's objects.
Now enter WebObjects.
It's not just a deployment solution, it's a *development* solution as well!
WebObjects has a RAD environment to place dynamic elements on an HTML page
(all server side). These dynamic elements our bound to objects and their
properties (whether the object is Java, Obj-C or WebScript doesn't matter!).
The dynamic elements are pretty powerful.
For example, the Repetition object allows one to bind an array class to it.
This object iterates over the elements in the array.
So in my RAD environment, I select an HTML table I've defined which
contains a couple other WO dynamic elements to bind instance variables to
strings on the page. I think make the selection of that *single* row and
declare this dynamic repetition object around it and bind my array of
objects to it.
Guess what!?
No more coding. That's it.
I've just visually laid out an HTML table element, put dynamic content on
my cells, and then told the repeition object to iterate over the array...
without one line of code for the most part.
That's called POWER.
Also, WebObjects has several very powerful dynamic objects for placement on
the page (from the server side sense). One of them allows one to take
other completed components (HTML bound dynamic objects, etc) and put them
on other pages!
This is where one is not only getting code reuse... but visual object reuse
as well.
If I design a login panel, for example, I do it once. Now in other pages,
I simply draw out the component object and bind it to the complete login
panel and I'm done. Now there's only one place to maintain the login
panel... both the code and the presntation!
In this way, one is able to have the many objects and elements which make
up most web sites (consistant branding headers, nav bars, side bars,
footers, etc) and create them as reusable code elements. Not just the
code, but the entire HTML bound with the code!
WebObjects puts this all together on the server side at runtime.
I haven't even gone into the power of Eterprise Objects Framework.... the
heart of abstracting your datasources like databases, etc.
Just about any HTML tag you can think of can be turned into a dynamic
element bound to an object's instance variables. Add WebObjects' other
dynamic elements of repetition, conditional, etc... and you have a very
powerful RAD tool.
That's why you go with WebObjects.
Instead of spending the many, many hours it takes to roll your own via most
coding solutions... one can make use of the powerfuil RAD environment via
WO.
I shudder to think how long my current project would take if using the
traditional method of coding via Java on the server side.
mark
---------------------------------------------------------------------------
Mark F. Murphy, Director Software Development <mailto:[EMAIL PROTECTED]>
Tyrell Software Corp <http://www.tyrell.com>
PowerPerl(tm), Add Power To Your Webpage! <http://www.powerperl.com>
---------------------------------------------------------------------------
Member of Families Against Internet Censorship: rainbow.rmi.net/~fagin/faic
