Leanpub Header

Skip to main content

Nasdanika SDK Runtime Bundle

A modular Java runtime that makes structure cheap enough to keep, in one overview and five in-depth manuals: Draw.io, Groovy DSL, command lines, test traces and Playwright.

Bought separately

$63.97

Minimum price

Free!

$29.00

You pay

Author earns

$

Also available for 1 book credit with a Reader Membership

These books have a total suggested price of $63.97. Get them now for only $1.00!
About

About

About the Bundle

Most enterprise knowledge is glass: it holds its shape and makes sense up close, and nothing connects it. People skip structure because it costs more to keep than it pays. This bundle is about a Java runtime built on the argument that the cost has changed, and about putting it to work.

It is one overview and five in-depth manuals. The overview is the menu: the why, the what and a high-level how. The Nasdanika Zephyr Books are the recipes, each one an in-depth manual for one part of the runtime that stands on its own, so you can start with whichever book matches your problem.

The overview

Nasdanika SDK Runtime: More Structure with Less Effort. Models written as text and generated by a Maven build, capabilities found by type, telemetry kept as a model, volumes, and a command line assembled from contributions, on the JDK, EMF core and the OpenTelemetry API.

The Zephyr Books

  • Draw.io: Diagrams That People Draw and Programs Read. How much structure a diagram should carry, from picture to model, and a Java API that reads, changes and renders Draw.io documents.
  • Groovy DSL: Models as Scripts, with a DSL for Every EMF Metamodel. EMF models and metamodels written as Groovy scripts, in a language derived from the metamodel with no grammar, parser or generator.
  • Declarative Command Lines. Picocli command lines that assemble themselves from the modules present, with commands placed by the generic types they declare.
  • Harness: Tests That Leave a Trace. Integration tests whose requests and the server's work are one OpenTelemetry trace in one JVM, recorded as a model.
  • Walk-throughs with Playwright: Browser Tests That Leave a Picture Book and a Trace. Browser sessions from Java with each step a span, the server's work under it and screenshots in the step.

Where to start

  • Architects: the first part of the overview, then the first part of Draw.io. Neither needs code.
  • Modelers and tool builders: Groovy DSL and Draw.io.
  • Java developers building platforms: the overview, then Declarative Command Lines.
  • Testers and anyone documenting web applications: Harness, then Playwright.

How the books keep you honest

Every listing in every book is included from code that is built and tested before the book is rendered, so a listing that no longer compiles stops the build. Status labels say what is AVAILABLE, what is a SKETCH and what is PLANNED. The books follow the runtime's quarterly releases.

All six books are also free on the runtime's site, runtime.sdk.nasdanika.org; buying them here supports the project. The text is licensed under CC BY 4.0 and the code under EPL-2.0. The code needs Java 25.

Books

About the Books

Nasdanika SDK Runtime - Draw.io

Nasdanika SDK Runtime - Draw.io

Diagrams That People Draw and Programs Read

Most diagrams are drawn once, looked at a few times and then left to drift away from what they describe. They don't have to be. A diagram drawn in Draw.io is a structured document, and with a little discipline it can be documentation, configuration, a program's wiring or the source of a model, while it stays a picture anyone can open and change.

The why: the visual communication continuum

The first part needs no code. It places every diagram on a continuum: a picture, an interactive diagram with tooltips, links and layers, a documented diagram, a diagram as data that a program checks and reports from, an executable diagram, and a diagram as a model. It gives rules for choosing a point: start on the left, move right when readers ask the same question twice or when a program needs the answer, and never redraw to move, because each point keeps the file of the point before it.

The how: Draw.io documents from Java

The second part is for Java developers who are handed diagrams and asked to do something with them. It covers the Draw.io module of the Nasdanika SDK Runtime, a small Java library with few dependencies:

  • The document model - Pages, layers, nodes and connections, mirroring Draw.io's file format closely enough that what you learn holds for the format itself.
  • Navigating and querying - Properties and placeholders, selectors and property paths, and links between pages, elements and documents.
  • Creating and changing diagrams - Geometry and order included, saved back as files Draw.io opens.
  • Rendering - Pages as PNG and SVG, and videos, drawn by Draw.io's own viewer in a browser driven by Playwright.

The last part shows where the runtime goes next: diagrams as models, generated and laid out diagrams, and diagrams for AI assistants.

Who it is for

  • People who draw: architects, analysts and engineers who use Draw.io and want their diagrams to do more than sit in a wiki.
  • Java developers who need to check, generate, publish or synchronize diagrams.
  • Anyone building tools on diagrams.

How it keeps you honest

Every listing is included from the module's tests and runs when the book is built. Every figure is a PNG with the Draw.io diagram embedded: open it in Draw.io and edit it, or load it with the API and get the document the next listing works on. Status labels mark what is PLANNED and what is a SKETCH.

This is a Nasdanika Zephyr Book, an in-depth manual for one part of the Nasdanika SDK Runtime, and it stands on its own: you don't need to know the runtime to start and finish here. The code needs Java 25. The text is licensed under CC BY 4.0 and the code under EPL-2.0.

Nasdanika SDK Runtime

Nasdanika SDK Runtime

More Structure with Less Effort

Most enterprise knowledge is glass. It holds its shape and makes sense up close, and nothing connects it. The definition of a customer lives in a database schema, a Java class, a wiki table and three spreadsheets, and each one is a projection of a model nobody ever wrote down. Ask who owns the definition and you get silence. An AI assistant can't be fed it either.

People don't skip structure because it is useless. They skip it because it costs more to keep than it pays, and a spreadsheet never asks anyone to adopt anything.

This book argues that the cost has changed, and shows a runtime built on that argument. The Nasdanika SDK Runtime is a set of modules on three foundations: the JDK, EMF core and the OpenTelemetry API.

  • Models as the API. Data and operations are written as text in Xcore and generated by a Maven build, with no Eclipse IDE. Models can be saved as XMI, JSON, YAML or binary, and their operations can be called by a command line or an agent.
  • Capabilities. Code says what it needs and the framework finds it among the modules present, by type, down to the generics.
  • Telemetry as part of the code. Watch work live with no OpenTelemetry SDK and no backend, or save it as a model next to the models it changed.
  • Volumes. A model, a running JVM or a remote system can be presented as files, served over HTTP or mounted as a drive over WebDAV.
  • A command line assembled from contributions. Adding a dependency adds commands.
  • Models that ship with it. Meta, the JVM, HTML, Bootstrap, TypeScript, React, and diagrams with Draw.io, ELK and SVG.

A solution built on it runs in one JVM, on a laptop or a single virtual machine, with no cluster, database server or message broker to ask permission for.

Who it is for

  • Architects who want more structure with less effort. You don't need to write Java to get value from the first part.
  • Java developers who want an observable, testable foundation with few dependencies.
  • Researchers and R&D teams who need to try an idea before anyone will provision infrastructure for it.
  • AI assistants. The terms are used consistently, the rules of thumb are collected in one place, and every listing compiles.

What it is not

It is not an introduction to modeling or to Java. My sister, who knows modeling a bit, says of this material that someone walking in from the cold will not get it. She is right. If the problems are not yet yours, the book will keep until they are.

How it keeps you honest

Every listing is included from example modules that are built and tested before the book is rendered, so a listing that no longer compiles stops the build. Status labels say what is AVAILABLE, what is a SKETCH and what is PLANNED.

This book is the menu: the why, the what and a high-level how. The recipes are the Nasdanika Zephyr Books, in-depth manuals for the modules that need more than a chapter. Draw.io and Groovy DSL are on Leanpub in a bundle with this book, and all of them are free on the runtime site and Maven Central.

The book follows the runtime's quarterly releases. The text is licensed under CC BY 4.0 and the examples under EPL-2.0.

Nasdanika SDK Runtime - Playwright

Nasdanika SDK Runtime - Playwright

Browser Tests That Leave a Picture Book and a Trace

A browser test does what a user does: it opens a page, types, clicks and checks what appears. When it fails, the question is always the same: what did the page look like, and what happened behind it? A screenshot answers the first half. The second half is on the server.

This book shows how to keep both. It describes the Playwright module of the Nasdanika SDK Runtime, which drives a browser with Playwright from Java against a server started for the test, and records the whole session in one OpenTelemetry trace:

  • Steps are spans - The session runs in a span and each step is a child span.
  • The server's work is in the step that caused it - Every request the browser sends carries the step's span, so the server's spans, logs and exceptions are its children.
  • Screenshots are part of the record - The pictures taken before and after each step are log records in it, along with the browser's console, uncaught page errors, narration and an optional video of the session.
  • The trace is a model - Saved with the runtime's telemetry model, a walk-through is a typed record of a scenario, with pictures, that people, programs and AI assistants can read.

The first part needs no code: why a browser test should leave a picture book and a trace, and the decisions behind the module. The second part walks through a small catalog application and a React application generated from Java models, then covers what a walk-through records and how the browser joins the trace across origins. The last part looks ahead to user guides, slide decks and narrated demo videos generated from recorded walk-throughs, which are planned.

Who it is for

  • Java developers who test web applications end to end and want a failed test to show the page and the server's side of the failure together.
  • People who document web applications and want screenshots retaken on every build.
  • Architects who want traceability from a user's step in a browser to the code that served it.

How it keeps you honest

Every listing is included from the module's sources or tests and runs when the book is built. The figures are screenshots the tests took. Status labels mark what is PLANNED.

This is a Nasdanika Zephyr Book, an in-depth manual for one module of the Nasdanika SDK Runtime, and it stands on its own. The code needs Java 25 and Chrome, Edge or Playwright's Chromium. The text is licensed under CC BY 4.0 and the code under EPL-2.0.

Nasdanika SDK Runtime - Declarative Command Lines

Nasdanika SDK Runtime - Declarative Command Lines

Command Lines That Assemble Themselves from Java Modules with Picocli

A command line tool usually knows all of its commands. The main class lists them, and adding a command means changing the tool. That is right for a tool with one purpose and one team. A platform is different: its capabilities come from modules written by different people and released at different times, and its command line should be the sum of the modules it runs with.

This book describes the cli module of the Nasdanika SDK Runtime, which builds a picocli command tree from whatever modules are on the module path. Nothing lists all the commands. Add a module and its commands appear; remove it and they are gone, with no other change.

Placed by type

The harder question is where each command goes. A command that saves a model needs a parent that can give it model objects; it does not care whether they come from a file, a Draw.io diagram or a database. So it says so, with generic types, and the runtime places it under every parent that can provide what it needs, before anything runs. Supplier<String> and Supplier<EObject> are one class at run time, but here they are two different contracts, matched the way the Java compiler matches them.

  • Commands and factories contributed as capabilities, through the module descriptor.
  • Wiring by type: what a command needs from its parent, what it asks for lazily, and what it accepts as sub-commands.
  • Mix-ins contributed and matched by type, and overriding commands by subclassing or by declaration.
  • The runtime's own commands, shell, distributions and launcher.

Commands placed by what they need form pipelines that read as sentences: load a diagram, turn it into a model, generate a site, each word from a module that knows nothing of the others. The last part shows the pipelines being rebuilt on this foundation.

Built on picocli, not beside it

picocli does argument parsing, help and completion superbly, and the runtime does not redo any of it. Commands are written with picocli's annotations; what this module adds is assembly by type.

Who it is for

  • Java developers who build command line tools that grow by modules.
  • Developers contributing commands to a modular platform.
  • Architects who want a command line as the first user interface of a platform, for people, build pipelines and AI agents. The first part needs no code.

How it keeps you honest

Every listing is included from the module's sources or tests and runs when the book is built. Status labels mark what is PLANNED and what is a SKETCH.

This is a Nasdanika Zephyr Book, an in-depth manual for one module of the Nasdanika SDK Runtime, and it stands on its own. The code needs Java 25, and some familiarity with picocli helps. The text is licensed under CC BY 4.0 and the code under EPL-2.0.

Nasdanika SDK Runtime - Groovy DSL

Nasdanika SDK Runtime - Groovy DSL

Models as Scripts, with a DSL for Every EMF Metamodel

A model has to be written down somewhere, and every way of writing it down has a cost. XMI is exact and written for machines. YAML and JSON are friendlier, but they are data: no variables, no loops, no computation. Diagrams suit some models and not a model of four hundred rules. Generated editors are good for changing one element and poor for seeing the whole or reviewing a change.

A Groovy script that builds a model reads like a structured document, braces for containment and a call for each feature, and it is also a program. It can name things and refer to them with variables, repeat and compute, derive a model from a diagram, a spreadsheet or another model, and decide what saving the model means. It is text, so it is diffed, reviewed and merged like code.

One DSL for every metamodel

This book describes the Groovy module of the Nasdanika SDK Runtime, which loads a file such as library.ecore.groovy as an EMF resource. The language is derived from the metamodel by reflection when the script loads: every concrete class is a keyword, every feature is a call, and containment is nesting. Bind it to Ecore and you write metamodels; bind it to a rules or architecture metamodel and you write rule sets or architectures. Change the metamodel and the language follows on the next load, with no grammar, parser or code generator.

  • The language: entry points, three ways to set a feature, variables and what a script produces.
  • References by path, closure or variable, with names of classifiers and global objects.
  • Deriving models from other resources, iterating them and copying prototypes.
  • Saving: scripts that write themselves back, and the truncation trap to avoid.
  • Errors and telemetry that point to the line of the script.
  • A DSL for your own metamodel in two classes, with rule sets, handlers, capability factories and resolvers.

Who it is for

  • Modelers who would rather write a model than click it together or read it as XMI.
  • Developers who derive models from other models, diagrams, spreadsheets or systems, and want the derivation to be a file next to the model.
  • Tool builders who want a textual surface for their metamodel without writing a language.

How it keeps you honest

Every listing is included from the module's sources, tests or test scripts and runs when the book is built. The book says plainly that a script model is a program that runs when it loads, so load scripts only from sources you trust. Status labels mark what is PLANNED.

This is a Nasdanika Zephyr Book, an in-depth manual for one module of the Nasdanika SDK Runtime, and it stands on its own. The code needs Java 25 and brings Apache Groovy 5; some familiarity with EMF helps. The text is licensed under CC BY 4.0 and the code under EPL-2.0.

Nasdanika SDK Runtime - Harness

Nasdanika SDK Runtime - Harness

Tests That Leave a Trace

An integration test of a web application sends requests and checks responses. When it passes, it leaves nothing behind but a green mark. When it fails, it leaves an assertion message on one side and the server's logs somewhere else, and someone has to put the two together.

The thread that ties them together already exists. OpenTelemetry carries a trace from client to server in a request header, so the server's work becomes a child of the client's request. Production systems use it across dozens of services; tests rarely do, because of the setup: a collector, a backend, agents on both sides, and a way to find one test's trace among everything else.

In one JVM it is free

A test that starts the server it tests, in the same JVM, needs none of that. This book describes the harness module of the Nasdanika SDK Runtime, with one method at its heart: Harness.inServer starts a server whose every handler is instrumented, runs your code in a span, gives it a client whose requests carry the trace, and stops the server when your code is done. Every request of the test and everything the server did for it are in the test's trace, and nothing else is.

  • A server for the length of a test, on the JDK's own HTTP server, serving handlers or files.
  • One trace, with the request, the server span it caused, the server's log records and any exception in one tree.
  • Recording, with the runtime's telemetry model: the trace saved as a model in YAML, JSON or XMI that you can query and compare.

The last part shows what is built on it: browser walk-throughs with screenshots in the same trace, which are available in the Zephyr Book Walk-throughs with Playwright, and documents, slide decks, sequence diagrams and narrated videos generated from recorded traces, which are planned.

Who it is for

  • Java developers who test web applications and services and want a failed test to say what the server did, not only what the client got.
  • Developers who build demos and walk-throughs and want them reproducible.
  • Architects who want end-to-end traceability from a test to the code that served it. The first part needs no code.

How it keeps you honest

Every listing is included from the module's sources or tests and runs when the book is built. Status labels mark what is PLANNED.

This is a short Nasdanika Zephyr Book, an in-depth manual for one small module of the Nasdanika SDK Runtime, and it stands on its own. The code needs Java 25; recording traces as models adds the runtime's telemetry model exporters. The text is licensed under CC BY 4.0 and the code under EPL-2.0.

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Earn $8 on a $10 Purchase, and $16 on a $20 Purchase

We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub