The Wiert Corner – irregular stream of stuff

Jeroen W. Pluimers on .NET, C#, Delphi, databases, and personal interests

  • My badges

  • Twitter Updates

  • My Flickr Stream

  • Pages

  • All categories

  • Email Subscription

    Enter your email address to subscribe to this blog and receive notifications of new posts by email.

    Join 717 other subscribers

Curious to this: Sonde — Arriving soon

Posted by jpluimers on 2026/10/08

A friend is starting a new business, so I am curious to what [Wayback/Archive] Sonde — Arriving soon will bring (or brought if this post scheduling arrives later than their release).

Looking at the taglines below, I think is that this is an intelligent (unlike LLM “intelligent”) source analysis/probing tool.

The Arrival animation sequence at [Wayback/Archive] Sonde — Arrival attributes the software development past in 29 stages, all the way back from FORTRAN till the more recent Swift until finally showing the moon, hopefully indicating a release before the Artemis IV will land people on the moon:

Languages covered by Sonde
Language Year Short Long Pronunciation Animation diagram
Fortran 1957 Fortran arrives, inventing the compiler. Fortran. Nineteen fifty-seven. John Backus and his team at IBM invent the compiler, turning mathematical formulas into machine code Goldstine & von Neumann flowchart
COBOL 1959 COBOL arrives for business data. COBOL. Nineteen fifty-nine. Grace Hopper’s vision for natural-language programming brings structure to business data processing with its four divisions. DIVISION hierarchy boxes
Pascal 1970 Pascal arrives to teach structured programming. Pascal. Nineteen seventy. Niklaus Wirth designs a language to enforce structured programming with clear blocks and subroutines. Nassi-Shneiderman structured diagram
C 1972 C arrives from Bell Labs. C. Nineteen seventy-two. Dennis Ritchie creates a systems language that maps elegantly to bare metal, defining pointers, memory layouts, and the Unix philosophy. Memory layout with address column & pointer arrows
C++ 1979 C++ brings objects to C. C Plus Plus. Nineteen seventy-nine. Bjarne Stroustrup adds classes and object-oriented paradigms to C, powering decades of performance-critical software. Booch class diagram (Shape hierarchy)
Turbo Pascal 1983 Turbo Pascal arrives, revolutionizing compilation speed. Turbo Pascal. Nineteen eighty-three. Borland introduces a lightning-fast compiler and integrated development environment that redefines developer expectations. Borland blue-screen IDE mock
Objective-C 1984 Objective-C arrives from NeXT. Objective-C. Nineteen eighty-four. Brackets send messages between objects: open bracket, receiver, method name, close bracket. Apple’s lingua franca for twenty-five years.” Objective-C nested [receiver message:arg] bracket dispatch
XBase 1984 XBase arrives. XBase. Nineteen eighty-four. The foundation of early PC database systems, and the target of the award-winning TechWriter documentation tool. TechWriter cover art Easter egg
Bash 1989 Bash arrives, cementing the Unix shell. Bash. Nineteen eighty-nine. The Bourne Again Shell provides the definitive command-line experience, composing small tools through robust pipe chains. Unix pipe chain (cat | grep | awk | sort)
Haskell 1990 Haskell arrives with pure functionality. Haskell. Nineteen ninety. Purely functional programming with lazy evaluation and an advanced type system drives academic and industrial rigor. Type inference tree with signatures
VB6 1991 Visual Basic democratizes Windows programming. Visual Basic 6. Nineteen ninety-one. Rapid application development becomes accessible to millions through drag-and-drop form design and event-driven code.” Form designer with controls & selection handles
Python 1991 Python arrives, emphasizing readability. Python. Nineteen ninety-one. Guido van Rossum designs a highly readable language with significant whitespace that eventually powers the AI revolution. Import dependency graph with module edges
R 1993 R arrives for statistical computing. R. Nineteen ninety-three. A language dedicated to data analysis, making statistical plots, regressions, and data frames standard. Scatter plot with regression line
HTML 1993 HTML arrives, giving the web its structure. HTML. Nineteen ninety-three. Tim Berners-Lee invents the markup language that models documents as a tree of elements, launching the World Wide Web.” H T M L DOM tree with element nodes
PHP 1995 PHP arrives to build dynamic web pages. PHP. Nineteen ninety-five. A server-side scripting language deeply embedded within HTML that establishes the modern request-response web lifecycle.” P H P Request/response lifecycle
Delphi 1995 Delphi perfects Rapid Application Development. Delphi. Nineteen ninety-five. Borland’s successor to Object Pascal introduces a flawless Visual Component Library and native Windows compilation. VCL TComponent hierarchy
Java 1995 Java arrives — write once, run anywhere. Java. Nineteen ninety-five. Sun Microsystems launches a ubiquitous object-oriented language running on a virtual machine, defining enterprise architecture. UML class diagram (IService/Controller/Repository)
JavaScript 1995 JavaScript brings the browser to life. JavaScript. Nineteen ninety-five. Brendan Eich creates a prototype-based scripting language in ten days that will eventually run everywhere. Prototype chain with dashed arrows
Ruby 1995 Ruby arrives, prioritizing developer happiness. Ruby. Nineteen ninety-five. Yukihiro Matsumoto creates an elegant object-oriented language that popularized mixins and expressive domain-specific languages. Module mixin inclusion (Enumerable/Comparable)
OCaml 1996 OCaml arrives with algebraic types. OCaml. Nineteen ninety-six. A robust functional logic language known for expressive pattern matching and absolute type safety. Pattern match tree with branching arms
CSS 1996 CSS arrives to style the web. CSS. Nineteen ninety-six. Cascading Style Sheets separate visual presentation from document structure, defining layout through specificity weights and inheritance.” C S S Specificity cascade with weight boxes
C# 2000 C-Sharp arrives for enterprise. C-Sharp. Two thousand. Microsoft introduces a modern, type-safe language built for the dot-NET framework, structuring enterprise services and repositories.” C-Sharp 3-tier service architecture (vertical stack)
VB.NET 2002 Visual Basic dot-NET arrives. VB dot NET. Two thousand two. Microsoft rewrites Visual Basic on the Common Language Runtime, bringing forms, properties, and events into managed code.” VB dot NET WinForms PropertyGrid (Name/Value table)
Groovy 2003 Groovy brings scripting to the JVM. Groovy. Two thousand three. An agile dynamic language targeting the Java Virtual Machine, powering build systems with its elegant nested closures. Gradle DSL nested closure blocks
Markdown 2004 Markdown arrives to untangle text formatting. Markdown. Two thousand four. John Gruber creates a lightweight plain-text syntax that maps perfectly to structured document hierarchies. Header hierarchy as indented tree
Scala 2004 Scala bridges functions and objects. Scala. Two thousand four. A scalable language that unifies functional programming and object-oriented design on the Java Virtual Machine. Trait linearization MRO chain
F# 2005 F-Sharp brings functional pipelines to dot-NET. F-Sharp. Two thousand five. A pragmatic functional-first language that processes data through elegant forward pipe operators.” F-Sharp Pipeline chain with |> operator arrows
SCSS 2006 SCSS brings programming to stylesheets. SCSS. Two thousand six. SASS introduces variables, nesting, and mixins into CSS, transforming web styling into modular code.” S C S S Nested selectors as nested boxes
Clojure 2007 Clojure modernizes Lisp. Clojure. Two thousand seven. Rich Hickey brings the power of S-expressions, immutable data, and concurrent paradigms to modern runtimes. S-expression tree parsed into nodes
Less 2009 Less arrives setting new styling standards. Less. Two thousand nine. A backward-compatible preprocessor that extends CSS with dynamic behaviors and mixin dependency graphs. Mixin dependency graph with @variable edges
Go 2009 Go speeds up the cloud. Go. Two thousand nine. Google builds a fast, statically typed language featuring green threads and channels, shaping the infrastructure of modern distributed systems. Goroutine fan with channel & select
Rust 2010 Rust arrives for memory safety without garbage collection. Rust. Twenty ten. A systems programming language that guarantees thread and memory safety through an uncompromising borrow checker Ownership diagram with borrow arrows & lifetimes
Kotlin 2011 Kotlin arrives and modernizes Android. Kotlin. Twenty eleven. JetBrains designs a pragmatic language that eliminates null-pointer exceptions and gradually takes over Android development. Null safety flow (?. / ?: / !!)
Dart 2011 Dart arrives for fast cross-platform UIs. Dart. Twenty eleven. A client-optimized language by Google that powers Flutter, expressing complex interfaces through reactive widget trees. Widget tree (MaterialApp → Scaffold → Column → [Text, Button])
Elixir 2012 Elixir brings scalability to the Erlang VM. Elixir. Twenty twelve. José Valim crafts a dynamic, functional language for building highly available systems via resilient supervision trees. Supervision tree with :one_for_one strategy
TypeScript 2012 TypeScript brings static types to JavaScript. TypeScript. Twenty twelve. Microsoft creates a syntactic superset of JavaScript, preventing errors at scale through flow-based type narrowing. Type narrowing flow (union → typeof → narrowed)
Swift 2014 Swift arrives to replace Objective-C. Swift. Twenty fourteen. Apple’s modern replacement for Objective-C. Optional chaining safely threads nil through expressions with a question-mark dot. optional chaining with ? diamonds and ?? default
Moon null The probe passes the Moon, approaching its destination. Three hundred and eighty thousand kilometers from home, the probe streaks past the Moon, carrying humanity’s legacy to its final destination. no debris diagram

All languages also come with a great graphical representation (collectively called “encounters”) described in the table above. Be sure to follow the animation to watch them all. Similarly, some of the logos ar vectorised. You can find the code for it referenced below.

The animations end with a fitting Trek salute wish: “Code well and prosper.”

There are also some taglines:

  1. For 70 years, humanity has searched for better ways to understand code. Every era invented new diagrams, new abstractions, new ways of seeing. Sonde is what happens when the probe comes home\u2009\u2014\u2009carrying ALL of it.
  2. Code responsibly.
  3. The entire software system as a queryable, provenance-tracked graph.
  4. Exploring the expanding universe of software development.
  5. 30+ languages. One universal analysis.
  6. Every function. Every dependency. Every risk. Everywhere.
  7. The code already knows its secrets. Sonde listens.
  8. What if your codebase could explain itself?
  9. If you need it, Sonde can read it.
  10. Flowcharts. Class diagrams. Dependency graphs. Migrations. What comes next?
  11. Infinite Diversity in Infinite Combinations.

These appear above the help text, with below the tagline a “See Daylight” button with this text: “accessibility health checks for real sites” which I think will be the first product of Sonde. It will be available from [Wayback/Archive] Daylight by Sonde — Arriving soon.

The above tables are from the quick analysis of the Arrival source source code which of which I archived the most important bits at [Wayback/Archive] https://sonde.life/arrival.html?paused=1&t=6 bits (the paused and t parameters are not functioning during page load, only after the page has been loaded and the page becomes paused) · GitHub.

There you can see more keys are being processed than in the help screen (shown with ?):

Supported keys
Key When Description
Home Always Jumps to start
End Always Jumps to finale
Escape Paused Toggles pause
Left arrow Paused Previous pause tag line
Right arrow Paused Next pause tag line
D Paused Clicks on Daylight
Tab Paused Puts focus to Daylight or Resume button (shift moves backwards, no shift uses regular order)
Shift Right Pre-roll is active Skips pre-roll
Shift Left Pre-roll is active Restarts pre-roll
Shift Right Animation sequence Start animation sequence
Shift Left Animation sequence Skip animation sequence until moon encounter
Shift Left Moon encounter Skip to animation sequence at 3 seconds before mon encounter
Left Animation sequence Scroll 10 seconds to the past in the animation sequence
Right Animation sequence Scroll 10 seconds to the future in the animation sequence

If you want to know why the TechWriter diagram is in the encounters, then read [Wayback/Archive] The scenic route to a developing career.

Note I did the analysis as for new tools I encounter, I always look at their web site to see the coding style. Usually that says a lot about the culture of a company, and this time I was pleasantly surprised by the cleanness of it.

--jeroen

Leave a Comment