Program

<custom-element> presents the MVP for application development without JavaScript based on HTML and XSLT markup. No compilers necessary, with native in-browser transformation performance. The presentation will guide over multiple aspects of related SDLC and how to build a fully functional app with HTML markup.

XML remains the best available way to markup text and is widely used in the publishing industry. XSLT, a declarative pattern matching language, remains the best way to transform XML from one form to another, and, importantly, to transform XML into HTML. Unfortunately, there have not been many implementations of XSLT 2 or 3 - the author only knows of one widely available (Saxon). With the release of fontoxpath, an XPath 3 implementation in TypeScript, it became feasible to implement an XSLT compiler that targets the JavaScript language. The JavaScript language has multiple implementations and can run on servers, browsers, and on “serverless” functions. With today’s JIT compilation, caching, and static analysis, we can target transform speeds comparable to other implementations. I will describe how compilation to JavaScript is achieved and some methods used for speeding up processing and present some possible uses for this project.

Domain Specific Languages (DSLs) are a flavor of declarative programming. Over the last few years I’ve designed several DSLs and implemented the engines for them using XProc. IMHO, XProc is particularly suited for implementing this. This presentation will be a practical guide on how to design such a DSL/XProc combo. Do’s and don’ts, tips and tricks. Several code examples are presented and explained. Another way to look at it is as a short applied XProc course: how to use XProc for a real world problem. I won’t assume too much XProc knowledge from the audience and will try to explain the examples in depth.

The TEI Processing Model (PM) is a TEI (Text Encoding Initiative) facility that can be used to give a declarative description of the expected behaviour associated with TEI XML elements. The paper will introduce the model and its implementation in TEI Publisher. It will go on to discuss a number of real-life edition requirements that the current model cannot handle. It will propose extensions to the model to deal with those requirements. Among these are: (i) being able to associate multiple behaviours with an element, such as in the case of a page break rendered as an image that is also a link (which could be handled by nesting associated behaviours); (ii) being able to generate new content, such as headers (could also be handled by nesting); (iii) sorting of output (which would require a new parameter); and (iv) more modularity in the PM (which could be handled by facilitating switching to another set of PM definitions). The paper will also argue that it is conceptually and practically not a good idea to define the PM as part of the schema specification and propose an alternative. The common aim of these proposals is to diminish the need for procedural coding in the creation of editions.

The talk purpose is to share the value and capabilities of StratML in order to articulate high level initiatives that involve large number of people, time or resources. We will also take a shot at fixing two of its weak points, available tooling and corrections needed to enable the automatic evaluation of the results. The talk will be structured around:

• A hands on presentation of the StratML part 3 form, an Xsltform based form currently in development. StratML parts 1 and 2 were quite minimalist, and while that may be appropriate for high end users it can be less attractive for least experienced ones. StratML part 3 include, for example, elements for describing plan context like PESTLE or SWOT frameworks or Driving Forces elements.
• A light introduction on StratML main elements, concepts and semantics.
• A proposal for a complementary schema for describing explicit result evaluation rules, enabling machine based evaluation of plan results and advances.
• Currently indicators and objectives are specified in natural language, and due to its inherent ambiguity and imprecision, there’s no direct way to perform a trustworthy evaluation that show if the results are met or not with. This limits the visual representation of the results, that is a key feature in plans follow up.
• The result elements (Actual and Target Result) of StratML can be too simplistic on situations where the data is provided from different groups with different levels of confidence or impact.

During the talk I will be showing a repository based (salvora plus xsltforms) forms interaction and final results evaluation with techniques like XSLT, XQuery and XProc.

XSL-FO is more declarative than you know. When the processing model has no feedback between the XSLT stage and the final output and no conditionals in the expression language, everything has to be declarative. You declare up front everything from the page masters to use for left, right, first, last, and only pages (if the document makes any of those) to the index keys and their classes that are collected and potentially merged into page number ranges to initial letters that are sized align at the top with small capital letters on the first line and at the bottom with the baseline of a line further down the block. This talk will cover all of those, and more, to show just how declarative XSL-FO can be.

It is often said that anyone can contribute to an Open Source project. One way for users (who may not be software developers) to get started is to help improve the project’s documentation. However, due to its very nature, technical documentation is often marked up in complex syntax and may require special tools to update it. This makes it difficult or prohibitive for new users to contribute. Petal is a browser-based WYSIWYG editor that allows users to easily edit documentation as if they were using a simple word processor. Behind the scenes, Petal is actually manipulating a highly structured and marked-up technical documentation format, namely LwDITA, but it only concerns the user with an editable view of the content. We will present a technical documentation publishing workflow that integrates Petal with GitHub to provide a simple syntax and tool-free approach for users to contribute to project documentation.

This is a case study of how I apply XSLT to SVG XML input in the creation and production of a playable dice and pegs game I am using to teach the basic rules of Major League Baseball to my grandchildren. The techniques developed can be applied wherever SVG layers need to be shared and re-used. The stylesheets and complete board game results are freely available on the Crane Softwrights GitHub account for anyone to use and to play. Questions regarding the rules of baseball are welcomed, but such answers are limited to the knowledge of just one enthusiastic fair-weather fan.

IFIP, the International Federation for Information Processing, held a computer-composed music competition in connection with IFIP Congress 68. I submitted a string quartet that received a special mention from the jury. The program that generated the score for the string quartet was based on an affix grammar, a two-level grammar formalism that I had invented earlier to generate natural-language text.

My bank offers me my bank records as CSV, which is easy enough to convert to XML for input to my XForms banking application. But they don't offer my credit card records digitially, only as a screen display. To solve this I use ixml to convert that text to XML, as input to the application. A real-world application of ixml.

For a long time, John Benjamins Publishing Company has published books and journals using a production pipeline based on XML and the XML tool chain. Manuscripts are converted into JATS or BITS XML, which is then converted into ePub, PDF or paper. Earlier this year, we were processing a book that contained code fragments in the R programming language. The manuscript, in Microsoft Word, contained code blocks that used shading, font properties and colored characters for syntax highlighting. Apparently, these code blocks were copied and pasted from an editor that supports R syntax highlighting.

Encoding the syntax highlighting in JATS would require an understanding of the R language. Even then, manually encoding the syntax highlighting would be too laborious, so we ended up with <code> blocks with plain text and no syntax highlighting. Since the author insisted on syntax highlighting, and we did not want to add markup to each of the 509 <code> blocks manually, we looked for existing syntax highlighting software. A popular highlighter supporting R is highlight.js. Being under time pressure, we decided to make an XSLT transformation based on the highlight.js code. Highlight.js uses regular expressions to extract syntactic constructs, which may then be marked and styled. Our XSLT takes the same approach.

Although this was sufficient for most small code fragments in a single book, it was clear from the beginning that regular expressions fall short when it comes to parsing programming languages. Therefore we want to see if it is possible to apply syntax highlighting using a real parser. This requires a grammar and a parser generator, and iXML is an obvious choice for the latter. In this presentation, we will show how to go from regular expression matching to iXML parsing, and why this is worth the effort.

We will show how the resulting markup can be styled with CSS, in compliance with WCAG guidelines and the European Union's Web Accessibility Directive. An interesting situation occurs when a <code> element contains other elements. This is possible in JATS for making text bold, underlined; for embedded links, footnotes, or even to specify syntax highlighting. Both regular expression matching and parsing have difficulty dealing with this situation, because they expect plain text as their input. We use an extension to invisible XML (transparent invisible XML, or tiXML) to make the embedded markup transparent to the parser, and keep it in the parse result.

JSON is ubiquitous in Big Data systems, enabling heterogeneous data to be efficiently expressed in a human readable format. Analysing JSON data means using either extensions to SQL or languages with native-JSON support, like JSONiq. The former relies on extensions to the relational model and so cannot adequately express JSON’s heterogeneity. While the latter intelligently expresses analyses of document data, standard JSONiq systems do not support modifying documents without complete overwrites. JSONiq Updates solves this by introducing Pending Update Lists and Update Primitives to support several new expressions that enable fine-grained updates to JSON data.

In this presentation, we showcase these expressions in a JSON execution engine, namely RumbleDB, and introduce a unified Target-Selector-Content interface for expressions that enabled extensible and simple processing. Further, we describe a simple scoping mechanism to dynamically enforce the mutability semantics of JSONiq updates and we outline RumbleDB’s integration with Databricks’ ACID compliant Delta Lake to persist these updates. We also showcase the extent of the expressivity of JSONiq Updates in RumbleDB through the TPC-C and Github archive benchmarks.

Our work brings to RumbleDB the ability to perform side-effecting expressions and function invocations using scripting, additionally extending the capabilities with local variable declarations, while loops and assign expressions. Built for large, unstructured and heterogeneous JSON datasets, RumbleDB is a query execution engine running on the JSONiq query language, and is highly integrated with Apache Spark.

JSONiq adapts the XQuery syntax and semantics to support expressions using JSON, rather than XML, however the similarities allowed us to incorporate XQuery specification for a scripting extension within JSONiq. The complexity of scripting stems from its introduction of side-effects in the non-side-effecting environment of JSONiq, which required careful design and implementation details to support these effects at runtime. Moreover, the scripting semantics transitions the declarative style of JSONiq closer to an imperative experience, where users may write operations closer to what imperative languages like Python have to offer, from declaring local variables that can be re-assigned later on, to running while loops with break or continue operations and stopping function executions early with exit statements. Moreover, adding scripting supports previous versions of RumbleDB workloads, and only enhances the experience with side-effects when needed. Experiments show no significant degradation of RumbleDB’s performance on previous workloads. Finally, we showcase the verbosity of scripting within RumbleDB by providing an implementation for QuickSort and by modifying a dataset through repetitive function invocations. Our results demonstrate the usability of scripting in RumbleDB workloads and future work may provide integration with databases or DataLakes to support long-lived updates done directly using side-effecting operations.

With the increasing pace of digital transformation, content management faces complex challenges in delivering relevant, personalized experiences across multiple channels. Content-as-a-Service (CaaS) has effectively addressed some of these challenges, such as the separation of content and presentation. However, it now reaches its limits in addressing the growing complexity of data integration and semantic interoperability. As organizations encounter increasingly diverse and interconnected data sources, the need for advanced data structuring and linking becomes evident. This presentation explores Content-as-Linked-Data (CaLD), a paradigm that extends CaaS by employing declarative and semantic principles. CaLD leverages technologies like RDF and SPARQL to enhance content meaning, cross-domain connectivity, and usability across platforms, unlocking digital relevance and seamless omnichannel orchestration at scale. By aligning with the Semantic Web's principles, CaLD offers significant benefits for diverse stakeholders. These benefits include more targeted content delivery for marketers, easier maintenance of modular, reusable components for developers, and leveraging external datasets to enrich proprietary knowledge, leading to better decision-making and strategic insights for executives.