[Jmol-users] Jmol/SwingJS and JSmol update

[Robert H. <ha...@st...>]

Sort of an end-of-year reflection....

As you probably know, the technology I implemented starting back in the
fall of 2012 for converting Jmol/Java to Jmol/JavaScript (aka "JSmol") has
done an admirable job of keeping us all in business (mostly a
*volunteer *business,
of course). It's been a great ride -- and no, I am not writing to tell you
I am done. Not at all. It has been a terrific 8 years, hasn't it? It
certainly appears that Jmol/JSmol is alive and well. The week of Oct. 4, we
had an all-time record-shattering download count of 5324 copies. And the
stats the past two months, with 14,159 downloads in October and 14,273
downloads in November, break all records by a long shot. These numbers are
17% higher than anything we have seen before -- beating the previous record
of just over 12,000 downloads for the month of October, 2012 (roughly when
I announced JSmol), and approximately doubling the monthly average of 6,389
for the period July 2018 - July 2020.

So, that is all very satisfying! It is terrific to be part of this thriving
community.

This past weekend I got InChI integrated into Jmol and JSmol, and that is
on its way to release in the next day or so. It is a full implementation in
Java and a partial one in JavaScript. I'd still like to be able to use
InChI "options" to fully show the power of InChI in JavaScript as well, but
unfortunately, it appears that that is harder than it looks. (Or at least
it's not obvious to me how to do that.)  In any case, I will need some help
with that if we want to fully implement InChI into JSmol. It might involve
C programming, or it might just involve a bit of manipulation of the InChI
extensions.

As you may or may not know, the technology I used for Jmol, now called
*java2script/SwingJS*, has extended this success to a large number of
applications beyond Jmol -- involving close to a 1000 applets or applet
instances in JavaScript, mostly within the fields of physics and
mathematics. And large Java applications have been successful as well.
Especially nice to see is that making Java projects "JavaScript-ready" has
gotten dramatically *easier* with additional development. Always a good
sign!

SwingJS is a vast improvement over the original "j2slib" still being used
for what everyone now knows as JSmol. Making that work back in 2012
required extensive reworking of the Jmol code, though. That was a difficult
challenge. Now, with SwingJS, there are only minimal changes that have to
be done in a working Java program to make it JavaScript-ready. Both
processes involve a java2script "transpiler" plugin for Eclipse. But the
one we use currently for JSmol is locked in Java 6, and the overall
technology just isn't able to be developed any further using it.

In contrast, the java2script/SwingJS transpiler supports syntax through
Java 11 and includes many of the Java classes that were introduced in Java
7-10. It's robust, well tested, and much more compatible with Java. There's
very little that needs changing in any Java program to make that program
also usable in JavaScript. So java2script/SwingJS is definitely the way to
go for Jmol as well.

So, what about Jmol-SwingJS (https://github.com/BobHanson/Jmol-SwingJS) aka
"Jmol 15"? The answer is that right now it has all the capability and
essentially the same code as Jmol 14. Every time I add something to one, I
am adding it to both. (Jmol 14 is on Sourceforge; Jmol 15 is on GitHub.)

I had put Jmol/SwingJS aside for a while, though, because I thought it
would be a big job to get that last 5% working. But yesterday I took
another look at it -- spent about 15 hours on it, actually -- and I am
quite pleased with what I see. I have the full Jmol *application *running
in JavaScript now, alongside the Jmol "Applet". The application can be run
as an independent "floating" frame or as an embedded app within a web page
(just like the applet, but with menubar and toolbar). The only real change
for the applet is that they both now use the same console -- the one from
the Jmol Application. This is a bit of an upgrade for the applet, as it
brings to the applet the real-time color-enhanced script parsing as you
type.

What's missing right now is the collection of "core" compressed packages as
well as timing comparisons. Compression is going to be important, as one of
the key improvements with SwingJS is that method names are "fully
elaborated", as in *newMeasurementData$S$javajs_util_Lst*. This was huge in
making SwingJS applications work smoothly, but it also adds quite a bit of
extra bytes to the JavaScript. The result is a larger download (19 MB for
all of Jmol-SwingJS code vs. 7.6 MB for the full JSmol code with no
compression).

But the good news is that it is all working, and I suspect working faster,
though I don't have data to back up that claim. (The java2script tweaks I
used for JSmol were pretty well optimized.) I'm looking forward to making
this transition possible. I hope to find time to try out some good
compression technology. (The absolutely complete SwingJS package, all told,
Java and all, is just over 4000 files and 85 MB, compressing down to 7.6 MB
using ZIP. Jmol adds another 20 MB to that.)  So getting this modular and
compressed is critical.

Anyway, that's where we are and, I think, where we are going with Jmol. I
hope you will join me for the SwingJS ride.

Bob



-- 
Robert M. Hanson
Professor of Chemistry
St. Olaf College
Northfield, MN
http://www.stolaf.edu/people/hansonr


If nature does not answer first what we want,
it is better to take what answer we get.

-- Josiah Willard Gibbs, Lecture XXX, Monday, February 5, 1900

*We stand on the homelands of the Wahpekute Band of the Dakota Nation. We
honor with gratitude the people who have stewarded the land throughout the
generations and their ongoing contributions to this region. We acknowledge
the ongoing injustices that we have committed against the Dakota Nation,
and we wish to interrupt this legacy, beginning with acts of healing and
honest storytelling about this place.*