Lotus Notes certainly was one of the most successful rapid
application development platforms of the '90s. The speed at which you
could develop workflow applications to streamline your business
processes was simply unparalleled. What made Notes ideal for
developing this particular class of applications is a unique
framework that was architected from the ground up around three
fundamental concepts:
A tight integration with messaging and directory services
But Notes still has many idiosyncrasies and design
limitations that can be directly attributed to its 15-year-old
proprietary architecture. Seasoned Notes developers have built
valuable expertise in working around these limitations and made a
career out of their Notes and Domino skills. But today it is no
longer Lotus Notes, but rather J2EE, WebSphere, and WebSphere Portal
that are the new IBM technology darlings.
If you are a Notes developer and your company hires a team of
fresh Java talent to work on WebSphere projects while excluding you,
I would be quite worried if I were you. You can always try to make
the case that developing the same application in Notes would be a
much better choice because it will be five times faster to implement.
But it seems that developer productivity and the ability to work
closely with the business are no longer driving IT decisions these
days.
I have been following the heated debate about the future of
Domino on the different forums and blogs. What I find most
interesting about this debate is that developers tend to think that
their survival in the job market depends on the survival of the
technology that they have invested so many years to master. The sad
truth is that Notes jobs are on the decline and WebSphere jobs are on
the rise. So the survival of Notes as an application development
platform is clearly not what Notes professionals should bank their
careers on. The move of a million developers to standards-based
application development is inevitable, if quite painful.
While IBM has done a very good job at marketing WebSphere, it
has done very little so far to help the Notes/Domino community make
the transition to WebSphere. From a developer perspective, there is
almost nothing in common between the Notes and J2EE development
models. It's like comparing apples and oranges. This means a steep
learning curve and - especially for collaborative/workflow
applications - a significant loss of productivity. Notes is a much
higher-level application development model. Using the Domino
Designer, in no time you can create a database, forms, and views to
access documents created with these forms. In contrast, with J2EE you
have to understand Java, the J2EE APIs, and the Model-View-Controller
architecture. Even frameworks like Struts are functionally very poor
compared to the Notes framework.
Scripting inside HTML tags can be construed as bad design, as
it cannot preserve the WYSIWYG development experience of Lotus Notes
or Microsoft Visual Basic. The latest attempt by IBM and the Java
community to improve the JSP developer experience is called
JavaServer Faces (JSF), which was proposed in JSR127. Simply put, JSF
will allow JSP developers to manipulate visual components instead of
taglibs. IBM has announced that it is currently developing a Web RAD
component for a future release of WebSphere Studio based on JSF and
is advertising that this will make J2EE more accessible to Notes
developers. Quite frankly, JSF is no better than Microsoft's ASP.NET,
and this is probably why more and more developers are weighing the
benefits of .NET rather than WebSphere right now.
Perhaps the solution is to port the Notes development model
itself on top of the J2EE stack. This seems like quite a daunting
task, but it suffices to re-create the entire Notes framework in
native XML. Consider an XML document-centric development model, an
LDAP-based security framework, and a virtual XML document store to
replace the NSF format for information sharing.
Also, a "VB-like" component model can enhance the J2EE
development experience to make it completely WYSIWYG. Draw an HTML
form, drop XML documents as data sources, and bind them to the form
fields using W3C's XPath standard. There is absolutely no reason why
J2EE should be more complex than Notes. EJBs are dead. You want
scalability? Try Grid computing. I just came back from OracleWorld,
and the new Oracle 10g infrastructure gives you infinite scalability
without having to specifically design for it. Just add as many cheap
computers to the Grid as you need when you need it. It's that simple.
As always, expect innovation to come from the Lotus Business
Partner community itself. When you have a million captive developers,
there is a high likelihood that someone has already started digging,
and chances are that the tunnel has already been dug. Of course,
there will always be those who will continue waiting for the door to
magically open some day. But the good news is that there is life
after Notes.