|Latest 7 Posts
| Side-Project Monday Evening|
Tue, Jun 27th 2017 6
| Including a Headless DDE Build in a Maven Tree|
Tue, Mar 14th 2017 10
| That Java Thing, Part 17: My Current XPages Plug-in Dev Environment|
Sun, Feb 26th 2017 9
| Slides From My Connect 2017 Presentations|
Fri, Feb 24th 2017 9
| The State of Domino App Dev Post-Connect-2017|
Fri, Feb 24th 2017 8
| Reforming the Blog in Darwino, Part 2|
Thu, Feb 16th 2017 7
| Connect 2017 Final Stretch|
Wed, Feb 15th 2017 8
| Setting up nginx in Front of a Domino Server|
Thu, Sep 18th 2014 19
| How I Maven-ized My Framework|
Mon, Dec 8th 2014 15
| Things I Rarely Use: sessionScope|
Thu, Jul 3rd 2014 14
| Working with Rich Text's MIME Structure|
Wed, Jul 8th 2015 14
| Including a Headless DDE Build in a Maven Tree|
Tue, Mar 14th 2017 10
| Building an App with the frostillic.us Framework, Part 4|
Thu, Jul 17th 2014 9
| Delving Into NSF Raw Item Data|
Tue, Jul 29th 2014 9
| Arbitrary Authentication with an nginx Reverse Proxy|
Mon, Sep 22nd 2014 9
| Release Weekend: ODA and Darwino|
Tue, Aug 2nd 2016 9
| Quick XPages Utility: Keep Alive and Alert|
Tue, Aug 30th 2016 9
||Darwino for Domino: Conceptual Overlap and Distinctions
I've talked a bit so far about how Darwino related to Domino from a development
perspective, but I think it'd also be useful to delve into specifically which
concerns thw two platforms address, to see where they overlap and where they
There are two main categories to cover, since Darwino inherits Domino's unusual
trait of pouring over from "database" to "app-dev platform".
As I covered a few posts ago, the two are similar at a conceptual level, both
being replicating document databases with document-level access control. Aside
from the difference between an NSF note's format and a JSON document, the main
distinction is that Darwino doesn't cover the actual physical storage of data.
Instead, it is based on top of existing SQL servers of various stripes
(PostgreSQL and SQLite being the most common). A Darwino application creates a
series of tables and uses them as the backing store for the conceptual document
This has a number of implications. The main one is that there isn't a "Darwino
server" as such - instead, there are SQL databases and Darwino applications
acting in tandem. In developing an application, this isn't generally a concern:
the Darwino APIs are the same across each database, in the same sort of way
that a Domino application doesn't care about the ODS version. However, being
backed by a SQL server has some distinct advantages: the server can be
administered and optimized using the same knowledge you would use for a
"normal" SQL-backed app, and the ability of modern DBs to index JSON data opens
up a world of possibilities (think NSFDB2, except good).
The flip side of this bleeds into the second category, as it means that a
Darwino application consists of at least two parts: the SQL database and the
application, which veers from Domino's "everything in one package" promise
Things diverge most significantly (though at least as promisingly) when it
comes to the application level. Domino has a few "official" ways to develop
applications (Notes, legacy web, and XPages) and then hooks to sort of act like
a Java EE server, albeit with some notable limitations. Darwino, on the other
hand, exists as a sort of "glue layer" in between the database and the
application: lower-level than XPages but higher-level than just a database
Darwino provides a common platform for writing Java-based applications, with
various services for managed beans, user directories, and so forth, written to
work consistently across all of the platforms it targets. Again, this starts
out similar to Domino, but diverges in the areas where Darwino takes advantage
of other technologies.
At the low level, since Darwino's main requirement is "a Java runtime", it is
able to run smoothly on various Java EE servers, on Android, on iOS, and on
pretty much anything that provides a capable-enough Java environment (such as,
say, Domino). It also, incidentally, means that it works great on Java 8.
At the high level, Darwino doesn't prescribe a specific UI framework, so the
field is open to use any of the tremendous array of rapidly-developing Java
frameworks on the web side and, as desired, native UI toolkits on mobile.
There's a bit of an inherent bias towards REST+client JS applications, since
then the same code entirely can be used on both web and mobile (as not every
Java web tooklit works on the mobile mini web server as it is now), but that's
So the overall idea is that Darwino doesn't solve every problem that Domino
does, but the problems it chooses to farm out are in the areas where that
brings tremendous benefit. In each area where Darwino uses third-party support,
it benefits from the tremendous advancements made in recent years, without
requiring jumping through weird hoops to get modern techniques to work.
Jun 01, 2016
| Recent Blog Posts
Side-Project Monday Evening|
Tue, Jun 27th 2017 1:49p Jesse Gallagher
Yesterday, in one of my various Slack chats, the topic of JShell - the Java 9
REPL - came up in the context of how useful it would be for XPages development.
Being able to open up a "shell" into a running XPages application could be
really useful in a lot of ways - and I think that the XPages Debug Toolbar has
an SSJS-evaluate feature that would do something like this.
Still, it got me looking around a bit, and I ran across Groovysh Server, which
is a project that combines Apache's SSH
Including a Headless DDE Build in a Maven Tree|
Tue, Mar 14th 2017 4:45p Jesse Gallagher
Most of my Domino projects nowadays have two components: a suite of OSGi
plugins/features and at least one NSF. Historically, I've kept the NSF part
separate from the OSGi plugin projects - I'll keep the ODP in the repo, but
then usually also keep a recent "build" made by copying the database from my
dev server, and then include that built version in the result using the Maven
Assembly plugin. This works, but it's not quite ideal: part of the benefit of
having a Maven project being au
That Java Thing, Part 17: My Current XPages Plug-in Dev Environment|
Sun, Feb 26th 2017 4:23p Jesse Gallagher
It's been a while since I started this series on Java development, but I've
been meaning for a bit now to crack it back open to discuss my current
development setup for plug-ins, since it's changed a bit.
The biggest change is that, thanks to Serdar's work on the latest XPages SDK
release, I now have Domino running plug-ins from my OS X Eclipse workspace.
Previously, I switched between either running on the Mac and doing manual
builds or slumming it in Eclipse in Windows. Having just t
Slides From My Connect 2017 Presentations|
Fri, Feb 24th 2017 9:29p Jesse Gallagher
At this year's Connect, Philippe Riand and I co-presented two sessions: one on
ways to integrate your apps into the Connections UI and one on Darwino's role
for Domino developers. I've uploaded the slides to SlideShare:
DEV-1430 - IBM Connections Integration: Exploring the Long List of Options
DEV-1467 - Give a New Life to Your Notes/Domino Applications and Leverage IBM
Bluemix, Watson, & Connections (effectively, "the Darwino session")
The State of Domino App Dev Post-Connect-2017|
Fri, Feb 24th 2017 9:28p Jesse Gallagher
I'm en route back from this year's IBM Connect in San Francisco, and this plane
ride is giving me a good chance to chew over the implications for Domino
First off, I'll put my bias in this matter right up front: Darwino, which I've
been working on and discussing quite a bit, is one of the three "chosen"
vendors for app enhancement/modernization/what-have-you. So, while this post
isn't going to be about Darwino specifically, it's certainly pertinent for me.
In any case,
Reforming the Blog in Darwino, Part 2|
Thu, Feb 16th 2017 8:41p Jesse Gallagher
During the run-up to Connect next week, I turned my gaze back to my
indefinite-term project of reforming this blog in Darwino.
When last I left it publicly, I had set up replication between a copy of the
database and a Darwino app. After that post, I did a bit of tinkering in the
direction of building a (J)Ruby on Rails front-end for it, next to the "j2ee"
project. That side effort may bear fruit in time (as I recall, I got the
embedded web app serving default pages, but didn't implemen
Connect 2017 Final Stretch|
Wed, Feb 15th 2017 12:16p Jesse Gallagher
IBM Connect 2017 is less than a week away, and I've been furiously prepping for
a couple parts of what is promising to be a busy conference.
On Monday, before the official kickoff of the conference, OpenNTF is co-hosting
a Hackathon, where attendees will work on one of several potential projects.
The goal is to learn about new development methods, work with new people, and
hopefully kick off some useful open-source projects to boot.
During the conference proper, I'll be presenting two se
December Is Self-Aggrandizement Month, Apparently|
Sat, Dec 17th 2016 3:21p Jesse Gallagher
It's been a busy month (couple of years, really), but the last few weeks in
particular have involved a couple minor announcements that I'm quite
On the 14th, IBM announced the 2017 class of IBM Champions for ICS, and they
included me on the list. It's been a joy to be considered a Champion for the
last few years, and 2017 promises to be an interesting year to continue that in
our slice of the development world.
Mere days later, IBM sent out notifications about Connect
The New Podcast is a Real Thing: WTF Tech Episode 1|
Mon, Oct 31st 2016 10:31a Jesse Gallagher
As intimated at the end of the last This Week in Lotus, Stuart, Darren, and I
have launched a new podcast in a similar vein: WTF Tech. Since we're all in the
IBM sphere, that'll be the natural starting point for the topics we cover, but
it's not going to be IBM-focused as such. For this first episode, we lucked out
and had a couple-weeks period chock full of announcements, so we had plenty of
material. Give it a listen!
Cramming Rails Into A Maven Tree|
Mon, Sep 26th 2016 1:25p Jesse Gallagher
Because I'm me, one of the paths I'm investigating for my long-term
blog-reformation project is seeing if I can get Ruby on Rails in there. I've
been carrying a torch for the language and framework for forever, and so it'd
be good to actually write a real thing in it for once.
This has been proving to be a very interesting thing to try to do well.
Fortunately, the basics of "run Rails in a Java server" have been well worked
out: the JRuby variant of the language is top-notch and the