I initially wrote jstructural as a set of XSLT stylesheets. That quickly became unmaintainable as the complexity of the stylesheets increased. I rewrote them in Java. I eventually got tired of writing documentation in XML (I didn't know that better XML editors existed) so I ended up wanting to add the ability to write documents as S-expressions.
The right way to do this was to redesign jstructural so that it defined
a core AST type and added multiple parsers that all
produced values of this core type. Converting between documents of different
types would then be a matter of parsing using one syntax, and then serializing
the AST using another.
The most natural way to express an AST is as a large algebraic data type.
Java doesn't have direct support for these yet (although it's slowly getting
them via Project Amber). I therefore
looked at other JVM languages that did support them, and the choice was either
Scala or Kotlin. I
chose Kotlin, after multiple nasty experiences with Scala. kstructural
was born.
Fast forward to the present day, and I'm utterly sick of working on Kotlin code. The tools are slow. Compilation is slow. The people in charge of the ecosystem think devolving to special snowflake imperative build tools like Gradle is a good idea.
I'm going to do a new Java implementation of the structural language,
and I'm probably going to redesign the language to make it even easier
to implement. Nowadays, XML editing is fast and painless thanks to various
tools (with real-time validation errors). XOM is essentially
unmaintained, so I'll replace the XML parsing code with an efficient SAX
parser (and actually get lexical information in the parsed AST, unlike with
XOM).