Ted Husted wrote:
I'm trying to put together a list of the typical types of applications
that enterprise developer write in real life.
My current main project, which has been my main project for about two
years now, is an application that seeks to unite all the back-office
applications in our organization into one consolidated offering. Right
now we have image viewing capability with workflow integration, new
account creation and maintenance, account inquiry for call center
personnel and account transfer creation/tracking/processing. We're a
few weeks away from rolling correspondence creation under the common
application. There are at least four separate projects going on that
are new pieces that "snap" into this main application.
We offer a host of management reporting capabilities, real-time
dashboarding of statistics and metrics for managers, multi-level
security backed by a highly robust LDAP-based security infrastructure,
and a host of web services for various clients. But all of this is
under a common umbrella application... each piece is a separate bit of
functionality (as evidence by the fact that some clients want part A and
nothing else and we're able to provide that with the flip of a switch),
and yet all the pieces are integrated (not just "at the glass" either,
we're talking the ability for one component to use the data from another
seamlessly) but at the same time they are developed independently and
are, with few exceptions, highly isolated in terms of packaging and
development cycles.
This is a highly complex undertaking that is pushing the limits of RIA
development as most people know it today. It's using virtually every
cool buzzword out there today in some form or other :) I have no qualms
about putting it up against any other web-based application out there in
terms of complexity and in terms of how close it actually comes to
looking, feeling and functioning like a fat-client app. It's extremely
flexible, powerful and pretty elegant architecturally (that's not to say
it's perfect: when you do something this large and complex you're bound
to learn some things through the process, and we certainly have, but it
says a lot about how good the underling architecture is that we've been
able to extend it and frankly correct things along the way without
killing ourselves, our budget or our timelines).
This is a back-office application primarily, but as I mentioned, parts
of it are used by various remote clients (the application and the web
services, which are two separate offerings) as well as more
front-office-type concerns (and all three groups are getting expanded
functionality little by little... this is without question the
fastest-growing application we have as most new development is targeted
to be a part of it).
So, if anyone else is up for sharing, I'd be interested in hearing
what sort of things other people are doing these days. (If your not
comfortable posting the list, feel free to mail me direct.)
Over the past 10 years, here's a rundown of some of the other
applications I've developed:
* An application for creating, tracking and reconciling transfers of
assets between accounts (this capability has been rolled into the
previously mentioned application). This is also very definitely an RIA
and for a long time was the model for more advanced web UI applications
throughout the company.
* An application for maintaining insurance accounts. This was a very
interesting project because it was the first large web-based application
that used data (and processing) on the mainframe. It was also notable
because we didn't have an app server at the time, just a web server with
some now-defunct IBM technology allowing us to talk to the mainframe.
This application was actually developed around 1999, but it's in many
ways *the* model for an RIA: with no app server, the *entire*
application lived on the client... the calls to the mainframe were
essentially service calls that always returned nothing but data that the
client then did something with. Ironically, this is largely the model
we're using for the first app I mentioned at the start, except now we're
doing it with DWR and a far fancier UI.
* An application for processing of complex corporate actions (stock
splits, things like that). This was one of the more logic-heavy
applications because of the nature of the processing involved, and we
essentially custom-developed a very capable rules engine for it. This
was another RIA for sure, but it was a little server-heavy for my tastes
(didn't use AJAX per se, but pulled a lot of the same sort of partial
page refresh tricks).
* An application for processing of incoming payments. This was an
interesting project because it started out as a Visual Foxpro-based
Windows app and we pretty much ported the whole thing to the web in
terms of look and feel... I remember many comments by long-time users
that they couldn't tell the difference unless we told them (we simply
updated the icon on their desktop to point to a URL rather than an
executable).
All of those were internal-facing applications, some with client-facing
applications. A few of the external-facing applications I've done:
* An application for viewing of canceled checks online by shareholders.
This was again developed in the 90's, but it actually did what we'd
all probably now call COMET (you could actually sit and watch a queue
waiting for your check to show up in real-time).
* Created a portal (before there was such a term!) for our shareholders
so they could monitor their holding, get messages from us, etc., all
completely definable by them in terms of layout and content.
* Created an HTML-based facility for folks to securely download
generated investment reports as they saw fit. I frankly don't even
remember a whole lot about this except that it had some requirements
that couldn't be achieved with kind of "basic" technologies, it required
some pretty fancy coding to make work as specified (it hasn't been live
for a couple of years, hence I've cleared out that portion of my brain
to make room for more useful knowledge!)
Err, actually, I think that's it! Most of my work has been
internal-facing. Oh, I actually consulted on an interface for CheckFree
at one point too :)
I'm leaving out all the Windows-only products I developed since I assume
they aren't terribly relevant to anyone on a Struts list :) None of
that is more recent than about 1997 anyway.
-Ted.
Frank
--
Frank W. Zammetti
Author of "Practical DWR 2 Projects"
and "JavaScript, DOM Scripting and Ajax Projects"
and "Practical Ajax Projects With Java Technology"
for info: apress.com/book/search?searchterm=zammetti&act=search
Java Web Parts - javawebparts.sourceforge.net
Supplying the wheel, so you don't have to reinvent it!
My "only partially serious" blog: zammetti.com/blog
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
