
Original Spec for Lotus Notes (1984) [pdf] - yurisagalov
http://www.kapor.com/wp-content/uploads/2016/12/Notes-Project.pdf
======
topspin
A well run Notes system was a real pleasure to deal with. I worked for a
300-ish employee company spread over 4 countries and 2 US states around
2001-2004 and we used Notes for all internal document management, email and
later even web content management. The thing just quietly kept everything in
sync; distributed servers, mobile users and their laptops and traditional
desktops, and never lost a byte of it despite flaky VPN connections, ISP
service, change conflicts, abusive use cases, multiple Notes client and server
versions, etc.

I haven't dealt with any Notes systems in years, but my memories of the one
time I did are largely good. The client had its quirks and Lotus could have
done themselves a big service if they had adopted more conventional behavior
and terminology, but the end user experience -- judging by easy adoption by
new employees -- wasn't as bad as is frequently alleged.

~~~
slantyyz
I used to work for a company that built Notes apps in the mid 90s, and while
the UI was clunky as hell, it was a great tool.

I was a big fan of the Domino back end too, in spite of the ridicule it got.
When Couch and Mongo came out, it was kinda refreshing to me to see "document"
oriented dbs come back.

~~~
open-source-ux
_"...the UI was clunky as hell..."_

The Interface Hall of Shame website (a now defunct, but once popular website
with examples of badly designed UIs) did a critique of Lotus Notes back in
1999:

[http://hallofshame.gp.co.at/index.php?file=lotus.htm&mode=or...](http://hallofshame.gp.co.at/index.php?file=lotus.htm&mode=original)

~~~
stan_rogers
Most of what's listed there is about bad application development (error
checking and so forth). Many other complaints come from the fact that Notes
was multi-platform (Win, Mac, OS/2, many Unices) and was consistent across all
clients, rather than trying to look native in any one of them. The thing about
that site that gives me the greatest kicks is that the pages of application
tiles on the workspace has since become _the_ way to do things, the only real
changes being colour depth, screen resolution and vogue colour choices. (About
F5/F9: F5 didn't mean "refresh" to anybody until MSIE came along; F9 did.)

------
scrumper
Notes is a real mixed bag. On the plus side, its open-ended, fully
customizable document database is a phenomenally powerful tool for creating
information management systems that map very closely to the unique workflows
and structures that arise in any business. As an expression of the promise of
office automation, it's pretty compelling.

On the other hand, it's the world's worst email & calendar client and much of
its bad reputation stems from users having to put up with that when there's
really no need for it ever to have been installed. (EDIT: given that, it's
interesting to see the prominence that email receives in the design doc. I'd
always thought it was a post-Lotus bolt on, but it was a day zero
consideration.)

But far, far worse than that is the stuff you don't realize when you embark on
the Notes path. It's a very powerful tool, but a dangerous one too: I saw a
telecoms company in the late 90s/early 2000s blow up partly because it relied
too heavily on a custom Notes solution that became prohibitively expensive to
change as the business evolved. Management got hooked on formalizing all their
business processes inside Notes, seduced by the promise of total transparency
and operational control. The system got big, and Notes scales badly. Reporting
runs that took a few minutes with a few hundred attributed documents in 1998
took over four hours by 2000; I helped put in a SQL Server instance to create
a relationally structured copy of the unstructured attributed documents to
reduce that time, but of course that was more money. The poor chap that owned
the company ended up having a stroke and the company was wound down. That's an
anecdote, but on the other two occasions I've seen Notes used for its real
value (as a document DB with associated processes) it's ended up in a similar,
sprawling and unmaintainable end state.

I guess one way to think of it is as a kind of Excel for processes and
documents. End users can do things with it very easily - you can set stuff up
that exactly reflects the flow of information and control processes unique to
a business, and that's a great tool for helping a business mature and control
its operational risks - but its limitations and the systemic risk it
introduces are not well understood and only become apparent when you've gone
too far with it.

~~~
codingdave
> solution that became prohibitively expensive to change as the business
> evolved

That sounds like bad coding. The downfall of many Notes systems is that it
made it so easy to write simple apps, you ended up with a lot of poorly
written apps because you did not need to be a proficient coder to deliver a
working product. I, too, have seen downright horrific apps. I've seen teams of
consultants hired just to maintain one form. And I've come in, re-written
those apps (still in Notes), and turned them into self-maintaining, scalable
apps that are 100% maintained by the business owners.

At the end of the day, it is a technology stack. People can use it well, or
they can use it badly.

~~~
scrumper
It was more that you had a set of Notes documents and associated workflows
which conformed perfectly to business operations when created, but then
gradually got heavier and harder to change as they were adapted along with the
business. There was nothing wrong with the coding as such, more the accrual of
features and exceptions and new types of related document.

It's a kind of tech debt for which a re-write is the appropriate solution, but
that was the prohibitively expensive part.

------
EvanAnderson
The timelessness of the promises made in this specification are very
interesting to me. A more idealistic (and younger) version of me would love to
help build an open platform that could fulfill a lot of these promises, likely
just because it's fun to build platforms. No doubt it such an effort would
also be doomed to relative obscurity, not unlike the other various
collaboration platforms that come to mind (Microsoft Exchange as an
application platform, FileMaker, and of course, Notes itself).

~~~
WalterGR
_The timelessness of the promises made in this specification are very
interesting to me._

To me as well. Reading the PDF, it reminds me of WinFS, which I worked on.
(Though I don't remember WinFS's collaboration story.)

 _Dreaming in Code_ [1] is a great book about Kapor's attempt to build such an
open source platform, post-Notes. I strongly recommend it to anyone interested
in the problem space.

[1] [https://www.amazon.com/Dreaming-Code-Programmers-
Transcenden...](https://www.amazon.com/Dreaming-Code-Programmers-Transcendent-
Software/dp/1400082471)

 _A more idealistic (and younger) version of me would love to help build an
open platform..._

This is still my dream. :)

~~~
EvanAnderson
I have no specific questions to ask, but I'm intrigued to hear you worked on
WinFS. WinFS is something I wish happened, albeit I'm sure that what I thought
it was wasn't what it actually was (since I never actually used it, wrote any
code the APIs, etc, I can't ever be sure).

I was enamored with BeFS. When I heard about WinFS I was excited to think it
might bring some of the coolness that BeFS provided to a mass audience. It's a
shame what happened to both BeFS and WinFS.

Thanks for the link to the book. I had no idea that it existed. For awhile I
kept checking-in on Chandler, hoping it was going to actually happen.

~~~
bokchoi
I too was sad to see Chandler die as well. It looks like the source was
imported into github:

[https://github.com/owenmorris/chandler](https://github.com/owenmorris/chandler)
[https://github.com/owenmorris/chandler2](https://github.com/owenmorris/chandler2)

------
pasbesoin
I spent my years struggling with Notes. See the second paragraph below, for
what I'm told is some balance.

In good part, this consisted of problems and cruftiness with the UI, and
Management's use of it for a blizzard of very verbose, fragmented, and
therefore difficult and time-consuming to navigate documentation. E.g. what
should have been one quarter or half page document -- at most -- ended up
spread, sentence by sentence, checkbox by checkbox, around 30 - 50 Notes
documents within an often overwhelming hierarchy of template documents only
sparsely completed to alleviate the most annoying and insistent badgering of
project managers and the like -- the only ones to really seem to have any
oversight over the whole documentation package and to feel any ownership of
same. (The rest of us? Hate, hate, hate... Not for the idea of documentation,
but for the reality that could make it more difficult than the project
itself.)

Eventually, I came across a description of Notes that commiserated with this
state of things but also said, 'Hey, wait. You should understand that the
technical design and underpinnings of Notes itself -- its data management --
was actually quite solid and innovative.

And... I guess I could see that, in terms of how it generally held up to the
abuse of an entire, large corporation's daily use and abuse of it. And how it
could work well, when somebody clue-full laid their hands on it.

I'm not in a position to speak to this, further. Except to say that there are
a few documents out there -- that I skimmed, a long time ago -- that
apparently paint a pretty good picture of this upside of Notes. Those in the
know describe them as interesting and edifying.

P.S. If and as I recall, Kapor was also responsible for Lotus 1,2,3 , which
was initially far ahead of Excel and had a perspective on data representation
that took a long time to propagate to its competitors.

------
jquast
I appreciated the nosql-like database model of a "notes" and "views". It
inspired the way I managed data for the remainder of my career. I believe the
concept of "tags" of flickr or "labels" of gmail are Notes-inspired concepts.

Maybe it doesn't scale well for late 90's internet-enabled desktops, but Ray
Ozzie developed software with a solid 15-year shelf life.

I'm happy to have had the few years experience as a lotus notes developer, and
also happy to have it in my past.

~~~
jasondigitized
Absolutely agree. I spent a lot of time in Notes, read all the blogs, and had
all the certifications. It definetly shaped how I look at things even 15 years
later. The combination of the ACL, reader / author fields, views, agents, and
forms was beautiful

~~~
brazzledazzle
What do you think fills that role Notes had today? Or would you say it's split
between various products/services?

------
lenk
The date on Mitch and Ray's spec is December 1984 and we designed most of the
core parts of Notes soon after that in 1985.

Sorry to hear that many of you had to deal with our 1985 design choices all
through the subsequent years. But I think many of the commenters here are
maybe forgetting or not aware of what personal computing and networking were
like 32 years ago: Windows 1.0 (beta), EGA graphics (640×350 w/16 colors),
640KB main memory (kilobytes not megabytes), Ethernet/TokenRing LANs, dial-up
9600 baud modems (kilobits/sec not megabits/sec or gigabits/sec).
[https://en.wikipedia.org/wiki/Windows_1.0](https://en.wikipedia.org/wiki/Windows_1.0)

The Internet was just being formed out of the Arpanet and other research
networks. Mail services and protocols like SMTP and POP3 didn't exist.

We worked with Ron Rivest to define BSAFE and build the first real commmercial
product with public key crypto.

As far as the Notes database (again circa 1984): it seemed obvious to us,
especially Ray, that relational was not the best model, but we took endless
grief for not using a relational database.

In hindsight, we obviously could have made quite a few better decisions and
evolved the design and code more quickly, but as one commenter pointed out, we
were trying to maintain app and data compatibility across multiple client and
server software and hardware environments that were continually evolving
around us.

------
TsomArp
I used and developed in Lotus Notes for 13 years. All those years I heard how
Notes was awful, and how wonderful Exchange and Outlook where... so when I
changed company to a Microsoft centric one, in 2014, I was (eager and)
prepared to be blown away by the Exchange + SharePoint + Outlook 2013
combination. Oh boy, was I wrong. Lotus Notes runs circles around the E+S+O
combination. There is no way that they can touch the power and flexibility of
Notes. I was even SHOCKED to see how HORRIBLE the Outlook interface is. How
poor it is for a product that does two things: email and calendar. Also, I was
shocked how horrible Skype for business is compared to Sametime... And I still
don't get how Control-F is not FIND in Outlook...

------
sengork
I've seen Lotus Notes client installation's folder being migrated from Windows
XP to Windows 7 then onto RHEL and finally onto macOS.

Suffice to say that all of the user settings were preserved and the data was
readily usable on each platform. This happened over the span of 10 years.

Given the observation, I wonder how many other applications with similar
complexity would last even one migration, let alone rolling migration across 4
completely different platforms.

~~~
TsomArp
I have done a Windows Server, to Linux to AIX... it was only a matter of
moving the "DATA" folder... and it worked perfectly each time...

~~~
Intermernet
Once they introduced transactional logging (highly recommended for busy
systems) there were a few more steps to the migration, but they are all well
documented and surprisingly resilient.

I managed to migrate a few TB of email from a dying server and it handled mid
migration crashes surprisingly well!

I think the domino stack was getting better while the notes client was losing
the plot. Most people where I used to work were happiest with mobile clients
connected via exchange active sync to the domino servers.

------
chaosite
"Notes is a document creation, editing, and storage system."

Strangely, at the last (and only, thankfully) place where I had to use Notes,
it was not used for that purpose. Instead, it was used as an e-mail system and
an inventory management tool.

~~~
baldfat
I actually found Notes to be an amazing tool and found it to be a great system
to work with. I just wish they kept the development going with a strong user
experience in mind.

I found my love of using PIM in Notes.

~~~
glhaynes
It seems like everybody who ever used Notes either loved it or hated it. Makes
me wish I'd ever used it. Or glad I haven't?

~~~
baldfat
You can still use it.

The UI was not for the Non-Tech crowd and even then drove everyone a little
batty. F5 in Notes locked your account as opposed to Refresh and the like.
Different parts of the program would have very different UIs. I didn't mind
it.

They say more people use it now then ever but ....

------
orionblastar
I wonder if anyone wrote a free or open source version of Lotus Notes? I think
IBM stopped supporting it after a while. It is a shame that IBM bought out
Lotus and couldn't keep the Lotus software current and up to date.

A local newspaper used Lotus Notes to serve up stories on their website,
before Python Django replaced it.

~~~
smhenderson
I was going to link to IBM Lotus Symphony[1] in response to your question but
it turns out it's only tangentially related to Notes, sharing some marketing
names and, eventually, included with Notes (version 8 I think).

Symphony was initially proprietary, then freeware and finally, in 2012, turned
over to the ASF as a donation. It basically consisted of a typical
spreadsheet, word processor, presentation suite all using ODF as a document
format.

So, not what I thought I would find but still slightly related to your
question...

[1]
[https://en.wikipedia.org/wiki/IBM_Lotus_Symphony](https://en.wikipedia.org/wiki/IBM_Lotus_Symphony)

~~~
stonogo
Symphony was Openoffice shoved into an Eclipse UI.

~~~
smhenderson
Hah, yeah, that's a good way to put it. For some reason I had it in my head
that Notes got carried along with Symphony but it turns out it was the other
way around with Symphony being given away as a free add on to Notes.

I had the "pleasure" of using a Notes/Domino solution back in the mid 90's but
it was only for a couple of months; when I joined they were most of the way
through a migration to MS Exchange/Office. Can't say I loved/hated it with the
same zeal as other posters, just didn't have enough time to form an opinion at
the time.

------
andrewstuart
It's hard to convey how forward thinking Notes was back in the day - a
replicated, document oriented database with encryption and visual user
oriented programming.

Some loved it, some hated it but it was certainly unique.

I'm happy not to be using it any more but I thank Lotus Notes for paying my
rent and food bills for a long time.

------
raesene9
Whilst Notes had it's frustrations (mainly as a user revolving around its
insistence on using its own terminology and layout for everything), I thought
it had strong points that made it an excellent tool for knowledge management.

Notes databases were easily replicated for offline use and encrpyted for data
security (when I was using it was back in the mid 2000's before Full disk
encryption became common).

In the days of poor Internet connectivity this made it immensely valuable for
travelling consultants who could easily take large quantities of information
on the move with them and synch it when in the office.

These days for end users I guess OneNote comes closest to that, but even there
I don't think it has all the features that Notes did...

------
jasondigitized
I cut my teeth on Lotus Notes straight out of school. It was way ahead of its
time and anyone who knows about Ray Ozzie knows that dude puts out good kit.
Bill Gates didn't make him CTO for nothing.

Anyone who reduced it to a email client didn't understand where its true
powered lied which was workflow and document / record management. If you knew
how to combine the ACL with forms, views, and agents you could build some
pretty amazing apps really quickly. Unfortunately it was always known as a
email client which was actually just a Lotus Notes App.

~~~
redcap
I'm currently working in a patent law firm in Japan, and we make heavy use of
Notes to manage work we bill and to manage all the information relating to
filing cases and managing the client correspondence for each case. There's a
myriad of forms but it all (still) works.

Naturally at this point we use a different email client, but I don't think
there's any incentive to shift away from Notes as it just works.

------
riprowan
My first experience with Notes was in grad school in 1992. It looked ugly and
didn't make much sense to my relationally-educated brain.

I bumped into it again in the mid-90s when Notes 3 was released and the
lightbulb went off. I became a Notes developer overnight.

Things Notes solved years before its time include:

1\. distributed databases everywhere even over a crappy pipe

2\. distributed software releases through replication (this was genius -
everyone forgets in the 90s most end-user software was still distributed on
floppies, but with Notes you just push the design out in a replica and all of
your end-users get their client apps magically updated)

3\. A fully integrated visual app dev + server admin platform that made design
of apps a snap. It became possible to sit down with a team and instead of
writing down requirements, actually _building a working model of the app in
the meeting as they describe their needs_. This was 1994, and it's still hard
to do in most development environments compared to the ease of Notes.

4\. Public-Private key identity management and a terrific security model all
the way down. It made it very easy to enforce a very granular security policy
across all the apps down to individual rows of data with the same global
security mechanism. As a dev it made it trivial to build a highly secure app
without having to think much at all about security.

5\. OS independence!

I worked in one shop in a ~$1B/rev company in 1997 - this team had 3 admins
and 4 devs handling email and all the internal corporate apps, pretty much all
built in Notes except the financial system which was its own team. This
company had fully embraced Notes as an internal app dev platform and had built
a marvelously powerful set of workflow apps for all of their core business
processes - some 30+ apps total - all of which integrated with each other.

Watching a team of 7 people manage and develop this awesome backoffice system
was a big eye opener for me. This company leveraged their IT staff 10:1 or
better compared to similar companies using typical tools. A well-run Notes
shop in the Glory Years of Notes (1995-2005) was truly a sight to behold.

My longest-lived solutions are Notes apps I built ~16 years ago still being
used today.

Fun fact: CouchDB was built by Damien Katz based on a lot of his experience
working on Notes / Domino while at Lotus, and Damien Katz is a badass it turns
out.

------
zokier
Considering the relatively positive comments here and its prominence, it is
fairly interesting that there are no notable FOSS alternatives for Notes, not
at least any that I'd know of. I suppose writing corporate software is not
that sexy, but on the other hand I'd imagine document management is something
that would be a itch to be scratched even in personal use (it certainly is for
me)

~~~
nradov
CouchDB is the FOSS alternative to the Notes (Domino) back-end database. Other
alternatives exist for the user directory, PKI, web application server,
messaging, etc. No single FOSS alternative contains _everything_ , but you can
stitch together a substitute out of various pieces.

------
cha-cho
I would be interested to see the original spec for Lotus Agenda. That product
still has a legion of fans extolling its virtues online. And it was a DOS
product.

------
euroclydon
I used to curse our Notes based document management system with custom
approval workflow... Until it was replaced with something _better_. Man do I
miss Notes!! It may have been slow at times, but it did a great job at it's
core purpose.

------
mgkimsal
Wish I'd seen this doc before I started using Notes - would have given me a
much clearer perspective (although... I might have 'grokked' as much at such a
young age).

Notes left a bad taste in my mouth in 96-97, as I was working at a company
doing custom Notes app (not originally, but we morphed in to Notes after I
started). I was tasked with doing Notes app customization and creation on and
for laptops with Win95 and a whopping 8m of RAM. Doing anything in Notes was
_painful_. We had one project where we got... 32m I think, and that was
certainly bearable, but I was canned shortly after that...

------
noahmend
As many people here are saying, Notes was at its core a remarkable achievement
for its time. One thing that kept it from more widespread adoption as an
application platform, I believe, was the lack of any synchronization or
atomicity model. The open "multimaster" replication model was ahead of its
time in allowing offline updates, but every application had to reinvent any
needed reconciliation logic more or less from scratch, and with few helpful
tools.

If Notes could have done more to solve that problem, I think people would have
flocked to it as a distributed application platform.

------
derefr
Oh boy, Notes. I worked at IBM last year. I had, in turns, a frustration, a
revulsion, and finally a great admiration for Lotus Notes. Not for any
practical reasons—the implementation leaves much to be desired. But in the
abstract? It's kind of cool.

See, Lotus Notes is essentially (the modern conception of a) web browser: an
MDI navigation chrome, plus rendering engine, plus VM runtime. Each time you
open a Notes "document" (like an HTML file), the code embedded in it is run
through the VM to create a DOM, which is rendered by the rendering engine and
displayed in the window/tab representing the document. One of the common DOM
element types is a text link, and Notes documents frequently link to other
.nsf files, which then are downloaded and which then open in Notes in new
windows/tabs.

The one crucial thing that Notes has over web-browsers, though, that made all
the difference in how the two ended up evolving, is that in Notes, each Notes
document has a _remote_ database associated with it, that _the document_ can
read from and write to.

It's a bit like a site or mobile app that uses Parse or Firebase: there's no
need to write backend logic; you just write your client, and then point it at
a _generic_ app backing-store server. In this case, the backing-store server
is called Lotus Domino.

Like Parse or Firebase, Domino handles authenticating clients. For each Domino
server a Notes client is signed into, they have an "identity file" (PGP
keypair) the server recognizes as "them", and which their Notes client uses to
sign any documents it authors (where an update sent by a document to a Domino
server is sent as a small signed document.)

This is in a lot of ways similar to how browsers use TLS client certificates,
but lighter-weight, in a similar way to how e.g. an Apt repository's pre-
signed packages are lighter-weight than HTTPS. In TLS, a piece of data will
lose its origin once it passes out the other end of a TLS tunnel, and so the
server must make a metadata record of who it was talking to, and vouch for the
data _itself_ (with another TLS tunnel) when someone else requests it. With
pre-signed documents, the server can be a dumb store-and-forward server, and
the documents will always just "stay" signed by whoever first created them,
without needing un-wrapping and re-wrapping on every transmission.

And _that_ means that, unlike Parse or Firebase where linearization is done on
the server, a Notes document can just download all the store-and-fowarded
update message-documents representing its database, and then linearize them
itself, using the Notes client's own configured trust settings to decide what
operations in the event stream were authorized changes, and then the
document's own merge policies to decide how to linearize the data (i.e. what
fields are CRDTs, what fields are last-write-wins, etc.)

Then, finally, you can understand what is going on when Lotus Notes opens up
and shows you what looks to be an email client: it's a Notes document (like a
web-app) syncing down a Domino database full of signed update-messages from
other Notes clients (one of which can be an SMTP gateway server, allowing
messages to get pushed in from outside the Notes system.) The email client
document _chooses_ to represent its (considered-authorized) update-messages as
individual email messages in a list—but some of them are also other things,
like e.g. edits to previously-sent messages.

Each signed update-message might just contain a plaintext message, or it might
effectively be a publish-event pointing the Notes client at a Notes document.
The email-client document is responsible for deciding how to render the
plaintext messages when you focus those; but if you focus a message
representing a reference to a Notes document, it just downloads/syncs that
Notes document into your local database and then the preview pane displays it
in the Notes equivalent of an <iframe>, allowing it to run all its own code.

So, you could picture the default Lotus Notes email client as being less like
Gmail, and more like Slack: it syncs a history of update-messages, some of
which are modification-events for real "messages". Like Slack, you can upload
files "to the service" and then just send references to them to other users in
your team. And some of these files could be small, self-contained HTML5 apps,
talking to a service like Firebase.

The key differences, then, are that 1. you actually interact with such
documents _within_ the client (so, picture if you could post HTML documents
into Slack that would be displayed _as an <iframe>_); and 2. the messaging
service itself is hosting the Firebase-alike functionality, such that every
"app" built with the Firebase-alike functionality gets an implicit User model
mapped to the user of the messaging app.

When described like that, it actually sounds a bit _less_ braindead than
Google Wave, doesn't it?

------
astannard
Notes got me over my email checking addiction. Having to use it at work I
checked my email twice a day rather than 20 times, since I hated the
interface. I guess that made me way more productive in itself. People started
using unofficial channels instead such as skype messaging for some
communications or just speaking in person.

------
goatlover
What replaced Notes for doing custom workflows? Despite whatever hate or
legitimate criticism it received, Notes was really good at letting you putting
together workflows. And the Domino servers with their ability to replicate
databases was really nice.

~~~
Jaruzel
Microsoft would like you to believe that OneNote and SharePoint filled that
gap.

------
EvanAnderson
This spec doesn't mention it, but Notes was arguably ahead of its time w/
respect to cryptography. The political climate of the time, w/ respect to
export restrictions, certainly didn't work in the product's favor.

There's some more good background here:
[http://www.ibm.com/developerworks/lotus/library/ls-
NDHistory...](http://www.ibm.com/developerworks/lotus/library/ls-NDHistory/)

------
twsted
A quick search out of curiosity brought this:

[http://www-03.ibm.com/software/products/en/ibmnotes](http://www-03.ibm.com/software/products/en/ibmnotes)

------
BillySquid
My first programming gig was Lotus Notes developer (v4.3). It was ahead of its
time

------
TAForObvReasons
Somewhat related: I came across the visicalc documentation from 1981:
[http://toastytech.com/manuals/VisiCalc%201.1.pdf](http://toastytech.com/manuals/VisiCalc%201.1.pdf)

Page 123 of the pdf (page 3-3/3-4 ) is a massive state machine showing all of
the commands and modes.

~~~
Someone
And for those wanting to play along, there's a legal download of the
executable from Dan Bricklin's site:
[http://www.bricklin.com/history/vcexecutable.htm](http://www.bricklin.com/history/vcexecutable.htm)
(also has the reference cards)

------
douche
Ah, Notes. NoSQL before it was cool to be NoSQL.

------
robert_tweed
Strangely, the words "spawn" and "satan" do not appear anywhere in this
document.

~~~
dang
I understand the trope, but comments like this tend to push discussion in a
shallow direction. Not that 'shallow' is a direction.

It would be better if you wrote substantively about some of your experiences
with Lotus Notes.

~~~
Intermernet
Hi dang, I agree with your moderation and comment here, but as a previous long
term notes / domino dev and admin who quite liked the platform I thought that
comment was, in this particular context, apt.

Also, shallow is a direction, but only in a relative sense ️

~~~
dang
I hear you, but even if that's true, the comment is uninformative to readers
who haven't had direct experience.

What we want instead is comments that share experience, so others can benefit
from it. It's basically a variant of 'show, don't tell'.

