In deze blog wil ik Lotus Notes beschrijven zoals ik het 18 jaar geleden heb leren kennen. Hierbij wil ik me met name richten op een aantal zeer prettige eigenschappen van het product. Waarom? Omdat het al zo lang geleden is dat ik met Notes werkte en ik me wel eens afvraag waarom ik een aantal van die prettige aspecten zoveel jaren later in de dagelijkse praktijk moet missen. Het afgelopen jaar heb ik bij Finalist kennis mogen maken met modernere technieken, waarop de huidige webapplicaties zijn gebaseerd. Daar zitten toepassingen bij waar Notes niet geschikt voor zou zijn geweest, maar ook een aantal die ooit in zeer weinig tijd te realiseren waren en nu na zoveel jaren ineens weer raketwetenschap lijken. Waarom worden sterke kanten van Lotus Notes niet hergebruikt? Wellicht gebeurt dat ook wel maar gebeurt dat tot nu toe buiten mijn blikveld. Daar zou ik dan graag kennis van nemen. Vandaar ook de licht provocerende titel van deze blog. Mijn doel is om reacties uit te lokken.

Het is dus ongeveer 18 geleden dat ik als student bij ECT in Rotterdam kennismaakte met Lotus Notes. Het hoofd van de afdeling kantoorautomatisering had een zwak voor OS/2 en Lotus producten, groupware als hobby en wat budget over om iemand een paar weken met Notes te laten spelen. Hij wilde weten of Lotus Notes wellicht in te zetten zou zijn voor het automatiseren van het aanvraag/bestel/uitlevertraject van PC gerelateerde hard- en software. We hebben het dan over de tijd van WP5.1, Windows 3.11 en Novell Netware. Ik was vervolgens de gelukkige die de beschikking kreeg over een mooie nieuwe PC en een grote gele doos met wat even gele Lotus CD’s en boeken. Niet veel later was de eerste Notes server binnen het bedrijf operationeel en de eerste pilot versie van de Notes applicatie opgeleverd. In een latere periode bij ECT groeide dit uit naar een serieuze applicatie met informatie die automatisch werd bijgewerkt vanuit andere systemen en werd onder andere ook de afdeling Bedrijfsbeveiliging in no time volledig geautomatiseerd met Lotus Notes. En daar denk ik nog wel eens aan terug.

Lotus Notes was en is een vaak verkeerd begrepen product. Velen die al van Notes gehoord hebben, denken dat het een email programma is en niet het meest gebruikersvriendelijke bovendien. Dat is echter bij lange na geen term die de lading dekt. Notes is veel meer dan dat en eigenlijk niet onder één noemer te vatten. Notes was ook niet echt (zeker toen niet) met andere producten te vergelijken. Begin jaren ’90 was Notes v2 een client/server omgeving, een applicatie server met dedicated client software. Maar ook een (niet-relationeel) op documenten gebaseerd databasesysteem, een applicatie ontwikkelomgeving en een communicatie-platform. De wortels van Notes reiken tot diep in de jaren ’70 en voor wie meer van de historie wil weten kan hiervoor prima op internet terecht, bijvoorbeeld bij de huidige eigenaar IBM op deze site: http://www.ibm.com/developerworks/lotus/library/ls-NDHistory/

Bij ECT was het de bedoeling dat ‘iedereen’ via de PC zijn/haar hard- en software aanvragen zou kunnen gaan invoeren op een standaard elektronisch formulier. Die aanvraag had een status en die moest door de aanvragers en behandelaars opgevraagd kunnen worden. Aan de aanvraag werd uiteindelijk, als hij goedgekeurd werd, een bestelling gekoppeld met ook weer een status. En als die binnenkwam werd er uiteraard uitgeleverd waarvoor ook weer een elektronisch document moest komen. Elk document kon in dit proces voorzien worden van elektronische handtekeningen. En op elk moment moesten er actuele overzichten van al deze documenten in verschillende sorteringen, selecties en groeperingen opgevraagd kunnen worden. En dat over drie locaties met drie LAN’s die weliswaar gekoppeld waren maar over een lijntje met een beperkte capaciteit. Welke overzichten er precies nodig waren of hoe de formulieren er precies uit moesten zien was bij aanvang van het project nog niet bekend en zou nog vaak aangepast moeten worden. Hier viel voor het eerst in mijn prille carrière de term ‘voortschrijdend inzicht’.

Stel je eens voor dat je zo’n toepassing volgende week als webapplicatie zou moeten bouwen. Over hoeveel tijd hebben we het dan voor management, ontwerp, prototyping, ontwikkeling, testen en deployment? Doe maar eens een schatting. In Lotus Notes realiseerde je dit 18 jaar geleden, als je eerst een week of drie uittrok om het product te leren kennen, in één of twee dagen.

Tijd om Notes te leren kennen, die kreeg ik. Het bleek in eerste instantie een database-achtige applicatie. Je kon een Form definiëren, zeg maar een soort JSP avant la lettre maar dan in een grafische editor waarin je de labels, invoervelden en knoppen wysiwyg op het scherm kon plaatsen. Die velden gaf je een naam en vervolgens kon je via dit Form nieuwe documenten gaan invoeren in de database. Die documenten vormden een soort records, zonder vaste structuur, met wat speciale velden onder water waarvan het ‘Form’ veld en een automatisch uniek identificerend veld in eerste instantie de belangrijkste waren. Het ‘Form’ veld zou je even kunnen vergelijken met een tabelnaam, hoewel er absoluut niet zoiets als een recordtype in het Notes datamodel bestond. Maakte je met Form ‘Aanvraag’ een document aan, dan bevatte dat in het Form veld simpelweg de tekst ‘Aanvraag’. Maar niets stond je in de weg om de waarde van het Form veld in de documenten aan te passen, bijvoorbeeld via een macro. Of om het Form waarmee eerder documenten gemaakt waren aan te passen, een andere naam te geven of te verwijderen. Of bestaande documenten in een ander Form op te roepen. Velden in het form, al dan niet verborgen, konden voorzien worden van functies die werden uitgevoerd bij validatie en verversen of opslaan van documenten.

Vervolgens was het natuurlijk handig om te kunnen zien welke documenten er zoal aangemaakt waren. Daarvoor bleek de ‘View’ te dienen, een soort definitie van een lijstweergave. Opende je een database, dan kwam je in eerste instantie in zo’n View terecht. Van daaruit kon je dan documenten zoeken, openen, kopiëren, verwijderen, enzovoort. Initieel deed zo’n View niet veel, maar gelukkig was deze naar hartelust aan te passen aan je wensen. Er kon een selectiecriterium aan gekoppeld worden, bijvoorbeeld om alleen documenten te tonen met ‘Aanvraag’ of ‘Bestelling’ in het Form veld en die dit jaar aangemaakt zijn. En er konden kolommen worden gedefinieerd. Deze verwezen direct of indirect via functies zoals @UpperCase(Author) naar veldnamen in de documenten. Vervolgens konden kolommen worden ingesteld voor sortering en groepering (categorizing). Er was bovendien een voorziening die bijhield welke documenten door een gebruiker nog als ongelezen konden worden aangemerkt.

De enige relaties die Notes van nature kende, volgden uit de toepassingen waarvoor het ooit was ontworpen. Je Forms en de daarmee aangemaakte documenten waren van het type ‘Main Document’, ‘Response Document’ of ‘Response to response Document’. Hiermee kon een nieuw aangemaakt document een ‘parent’ document krijgen afhankelijk van een op dat moment geselecteerd bestaand document. Met als enig onderscheid het al dan niet bestaan van speciale referentievelden onder de motorkap en zonder enige afgedwongen integriteit.

Ander Form of een iets andere View nodig? Copy-paste, andere naam, et voila! Je kunt je voorstellen dat de mogelijkheden met zo’n vrij opgezet systeem, zeker voor die tijd, uniek en bijna eindeloos waren. Daarin schuilde overigens ook één van de gevaren in het Notes gebruik, want sommigen zagen niet in dat Notes zich niet zo leende voor typische ‘relationele’ systemen, zoals bijvoorbeeld een klant – product – order systeem. Maar voor workflow systemen, discussie databases, product catalogi, mail, bugzilla-achtige databases, rapportage databases, knowledge bases, kortom systemen met ongestructureerde data, was het een nagenoeg ideaal platform.

Voor meer informatie over ‘what the heck Notes is anyway’, verwijs ik overigens graag naar deze pagina: http://www.nsftools.com/misc/WhatIsNotes.htm

Een interessante pagina met een uiteenzetting van het Notes datamodel kun je hier vinden: http://www.notesdesign.com/ndhtml/ndtutor.htm

Wat waren behalve deze vrije, document gebaseerde opzet andere bijzondere eigenschappen? Naar mijn mening zijn dit wel de belangrijkste:

• Automatische replicatie tussen versies van databases. Onderweg met je laptop? Lokaal een replica maken van een bedrijfsdatabase, hierop offline vrolijk doorwerken en als je weer eens online was de boel synchroniseren. Toevallig met meerdere mensen hetzelfde document gewijzigd? Notes toonde dit als een ‘replication or save conflict’ in de Views en aan de gebruiker werd simpelweg het ‘mergen’ overgelaten. Bedrijf over meerdere locaties verspreid? Gewoon per lokatie een Notes server en onderling regelen ze op gezette tijden de replicatie wel. Eén server stuk? Opende je gewoon een replica van dezelfde database lokaal of vanaf een andere Notes server.
• Alles in één database file, de zogenaamde NSF (Notes Storage Facility). Dus niet alleen de documenten, maar ook bv de definities van de Forms, Views, Macro’s in speciale Designer documents. Alles wat bij je applicatie hoort dus in één eenvoudig deploybaar pakket.
• Beveiliging op basis van een Access Control List. Notes was één van de eerste systemen die gebruik maakte van certificaten, lokaal bewaard in een password beveiligde Notes ID file. Ook delen van Forms (secties) waren hiermee af te schermen (denk aan dat handtekeningencircuit uit de ECT case).
• Geïntegreerde full text search indexering.
• Ondersteuning voor database templates, de NTF files. Dit waren een soort NSF files, maar dan met alleen designer documents. Voor een aantal toepassingen werden deze met Notes meegeleverd waarna je ze volledig naar eigen wensen kon aanpassen. Ook ideaal voor versiebeheer van je Notes applicaties.
• Toegang zonder speciale Notes client. Aanvankelijk was die nog wel nodig, maar later in de jaren ’90 toen de internet browsers opkwamen werd Notes in rap tempo ook hiervoor geschikt gemaakt door een http/html server aan de Notes server toe te voegen (die daarbij meteen Notes Domino server als nieuwe naam kreeg).

En last but not least een eigenschap waar ik echt nog vaak met heimwee aan terugdenk: eenvoudig en snel aanpassen van applicaties. Eindgebruiker aan de lijn die een knopje op een andere plaats wilde hebben? Form openen, aanpassen, opslaan. Gebruiker op F9 laten drukken (verversen in Notes, het bleef een product van ver voor de Windows conventies) en nog tijdens het telefoongesprek is de gebruiker geholpen met een ‘nieuwe versie’. Nog niet meteen voor iedereen deze aanpassing doorvoeren? Form weer kopiëren en plakken, alleen die ene gebruiker rechten geven, enzovoort. Ik ben nooit meer een platform tegengekomen waarin dit soort aanpassingen zo eenvoudig door te voeren waren.

Natuurlijk zijn er ook nadelen aan Notes op te noemen. Eén voorbeeld dat genoemd wordt is het monolithisch en gesloten karakter van Notes. Juist vanwege de sterke kanten van Notes was vaak de verleiding te groot om ook naar Notes te grijpen voor toepassingen waar het platform zich eigenlijk niet voor leende. Of andersom geredeneerd: Notes had net even wat meer aanpasbaarheid moeten ondersteunen. Vaak wilde je na een tijdje toch net iets meer dan het platform toeliet. Het latere toevoegen van onder andere LotusScript deed daar niet veel aan af. Dat is niet een taal waarin je je business logica verspreid over allerlei View, macro en veld definities in terug wilt vinden nadat een applicatie een tijdje in ontwikkeling geweest is. Vaak voldeden applicaties toch net niet helemaal aan wat je wilde. Een iets andere layout of gebruikersbeleving, vooral bij gebruik van de latere webinterface, meer elegante mogelijkheden tot koppeling met andere systemen, tonen van gegevens in één Form uit meerdere documenten, toch meer structuur in het datamodel, dat zijn punten waarbij ontwikkelaars tegen een stevige muur aanliepen.

Interessant wordt het als we lering kunnen trekken uit het Notes verleden en dit kunnen meenemen naar moderne technieken. Frans Maas, tot voor kort Lead Architect Corporate IT, Strategy & Innovation Management Bij Philips (en vader van onze Peter) heeft deze stap gemaakt en schreef hier desgevraagd het volgende over:

“Moderne omgevingen als Rails en Flex zijn enorm veel productiever door hun openheid, een consequent volgehouden object model en krachtige ontwikkelomgevingen. Iets eenvoudigs als het feit dat in beide omgevingen de code is opgeslagen in “normale�? tekstbestanden maakt dat opeens standaard zaken als version management gewoon beschikbaar zijn. Door toepassen van bijvoorbeeld Subversion krijg je het equivalent van de Notes replicatie voor je programmacode, maar dan op een standaard manier. Bij InContext (mijn huidige werkgever) onderhouden wij een hybride applicatie gebouwd op Rails en Flex via één geïntegreerd version management systeem. En regelmatig vinden we in een van de communities handige uitbreidingsmodules om ontstane behoeften in te vullen. Voorbeelden zijn graphics processing, unique id generation, encryptie. Het excellente gedistribueerde database systeem van Notes, met zijn unique identifiers en replicatie, kan eenvoudig worden nagebouwd op basis van componenten als SQL en UUID generators die zowel voor de Rails als de Flex omgeving gewoon beschikbaar zijn. Dat is geen rocket science. Het betekent wel een extra inspanning in het bijeensprokkelen van de totale configuratie, en ook het integreren en testen. Maar bij Notes moest je onverrichter zake zeer lang wachten op een volgende release, waar je nauwelijks invloed op had. Nu kun je gewoon verder in je eigen tempo.

Conclusie:

• Moderne tools als Rails en Flex zijn in de basis minder geavanceerd dan Notes.
• Door de openheid en productieve ontwikkelomgevingen haal je deze achterstand pijlsnel in en ben je uiteindelijk veel flexibeler en productiever.

Waar wachten we nog op?