Dyalog Ltd's Managing Director opens the user meeting.

In accordance with tradition, Morten looks briefly back over his shoulder before turning his gaze to the future, presenting his view of the road that lies before Dyalog Ltd and users of Dyalog. How many times will he mention Large Language Models?

John's never been 100% convinced about the proposed Array Notation. He's been on a voyage of discovery...find out where he ended up.

At Dyalog '23, Adám proposed an approach to assignment and using the value of variables with dynamic names, to replace the current solutions that suffer from poor readability, performance, and safety. The design has now evolved to be both more intuitive and more versatile. Adám presents an update and demonstrates usage.

John demonstrates extensions (and some simplifications) to the DWA interface that allow the creation of external ⎕WC objects. Dyalog Ltd intends to use this mechanism to re-implement the HTMLRenderer object.

APL as an interpreted language provides unique challenges for verifying correctness. Recently, Brandon has started work on static analysis of APL code using the Co-dfns interpreter as a back end; the aim of this work is to provide an ergonomic tool to statically specify desired properties of APL codebases. Brandon reports on the initial steps of his proof-of-concept.

Many existing applications are written for the Microsoft Windows desktop using the ⎕WC family of system functions (WC stands for Window Create). EWC is a project that aims to allow many – maybe, eventually, most – GUI forms written in this style to be moved to the web, or to non-Windows desktops, using the HTMLRenderer, with minimal changes to application code.

In addition to reproducing capabilities of ⎕WC, the EWC project adds a handful of JavaScript-based objects that do not exist in the Microsoft Windows implementation; these include a ribbon control, an ApexCharts widget, and experimental use of "Flex" to position controls as an alternative to setting position and size.

EWC is an open-source project, and one design goal is to allow users to add additional widgets as required.

What is The APL Forge? How do you compete, and who won the 2024 round? Stine introduces this new competition, which has replaced the International APL Problem Solving Competition (Phase 2) that ran for the last 15 years, culminating in the award ceremony for the winner.

Dyalog Ltd has been engaged to port an APL+Win application to Dyalog. An important part of the project is the creation of open-source tools that will be made available free-of-charge for similar migrations. These include tools to:

• move APL+Win source code to text files, and use Git to share the same source code between the APL+Win and Dyalog versions of a code base.
• automatically rewrite code to handle many language differences.
• emulate ⎕WI GUI and other system functions.
• continue to use APL+Win component files during the migration process.

Morten and Karl introduce these tools and explore future development in this area.

With the release of Dyalog version 19.0, it is now possible to both initialise your session and start your application straight from text files, without any involvement of binary files such as session files and saved workspaces. Adám demonstrates how you can make your favourite development tools available and launch your code — all directly from text sources.

Tatin is a package manager for Dyalog. Brian introduces some of the new Tatin packages introduced in the last year:

• NuGet simplifies loading and incorporating .NET packages in your applications.
• APLProcess makes it easy to launch additional APL processes to distribute workload or run in code in an isolated environment.
• OpenAI implements an interface from Dyalog to OpenAI's API, which enables the integration of AI capabilities in your applications. OpenAI can also serve as a template for how to use HttpCommand to implement interfaces to other AI frameworks.

(For more information on Tatin, see Morten's Dyalog '22 presentation "The P words…Projects and Packages")

At Dyalog '23, Peter identified some issues in monadic ⎕SH/⎕CMD and proposed a design for a new system function, ⎕SHELL, that fixes those issues. Since then, the design has been refined and improved based on feedback. Peter demonstrates the revised ⎕SHELL system function that will appear in Dyalog version 20.0.

Aaron presents work that has been done in the Co-dfns compiler to improve integration and support for traditional APL code, as well as a roadmap for these features into the future. He discusses the performance and features of present releases together with caveats, recommendations for using the compiler, and some unique things that Co-dfns can help you to do with APL.

Formal proof verification of large mathematical databases requires a lot of processing power. Metamath is a simple and flexible computer-processable language that supports rigorously verifying, archiving, and presenting mathematical proofs, and is particularly efficient when processing data in a data-parallel manner. APL provides opportunities to perform verification in a data-parallel manner. Brandon shows how APL can be used to perform data-parallel proof verification of Metamath, something that is not offered by existing Metamath systems.

ullu is a new testing framework for Dyalog APL that rigorously tests the functionality of each of the primitives. One of the central aims is to get close to 100% source code coverage, to verify the accuracy and reliability of Dyalog APL.

Aarush introduces this new framework, and demonstrates how he has achieved almost 100% code coverage for the primitives that have been incorporated so far.

There are many limits in the Interpreter, some of which you might know about (for example, a maximum rank of 15) and some of which you might not (for example, a depth limit of 256 parentheses in a function). Some limits are easy for us to change, others less so. John discusses the whats, whys, and hows of these limits, how we might change them, and the impacts of doing so.

Dyalog Ltd's Managing Director closes the user meeting.

Dyalog has a firm place in the heart of SimCorp Dimension, which is the backbone of more than 50% of the top investment management firms worldwide; it manages over €35 trillion combined. Oliver offers some insights into why SimCorp like Dyalog, the position it has within their architecture, and their plans for positioning it better in relation to increased demands for security and cost of ownership. He gives a high level view on the architecture of the SimCorp Dimension product, and discusses SimCorp’s position on concepts such as shared code files, the .NET bridge, multi-threading, type checking, code signing, and more.

Monitoring your software's performance and behaviour by collecting telemetry data is nothing new. The open source project OpenTelemetry aims to standardise how this is done. Gilgamesh presents how OpenTelemetry can be used from Dyalog and demonstrates a sample application that emits telemetry data.

Telemetry data can, optionally, be emitted using Protobuf (Protocol Buffers), a mechanism for serialising structured data. Sandra presents an APL implementation of Protobuf and a plugin that generates APL code from schema files.

raylib-apl makes the C library raylib available to the APL programmer on all platforms. Like APL, raylib was originally used for teaching, in its case, games programming. However, raylib has expanded to include 2D, 3D, and VR graphics, with custom fonts, animated 3D models, shaders, images, textures, mathematical functions, sound, and more. It has also evolved its own vibrant ecosystem.

Brian describes how you can take advantage of this functionality, and when it is appropriate to do so.

There is a natural progression in mathematics from arithmetic to algebra to linear regression. Define a linear function f(x)=mx+b and let y=f(x). Using simple arithmetic, one can determine the y-value given x. We can use high-school algebra to find x given y. In linear regression we know both x and y; we want to find the function f. Dyalog allows us to create this function under program control using namespaces and defined operators. Stephen also demonstrates extensions to this concept including multiple and non-linear regression.

Jesús explains how Dyalog can be used in the field of data science. He starts by solving several typical introductory problems using only the APL primitives, to prove that they offer a powerful toolset for data analysis, before exploring the use of more advanced features in Dyalog for the development of libraries. Finally, he investigates how APL is applied to the solution of real data oriented problems in the field of materials science.

A few brave APLers have forged a path forward for working with trees in APL, and Asher wants to bring their findings to the masses. He presents his tutorial for working with trees (represented with parent vectors), describing both its content and the tools he used to combine illustrations, APL code, and prose.

APL is not well known among the younger generation – it's time to make a change! For the past year, Sergey and his team have been developing an online APL MOOC (Massive Open Online Course) for the University of Helsinki. He demonstrates its progress, and shows the impact it can have on how we teach a new generation of APL thinkers.

Automatic Dependent Surveillance–Broadcast (ADS-B) is an aviation surveillance technology that allows an aircraft to determine its position using GPS or other methods and continuously broadcast its position and status over a radio signal. These raw signals can be received by ground antennas and transmitted to a central server for parsing and aggregation. Holden demonstrates how he won the 2024 APL Forge with his Radar Ingest System. This APL application is designed to connect multiple antennas and feed real-time raw data from aircraft into the system, where the data is then parsed, stored, and distributed using a web API.

Markos describes the migration of a sheaf of APL+Win workspaces to Dyalog, a project that he has undertaken using the Link framework. "Migration" in this context encompasses restructuring into namespaces, using multiline headers, taking advantage of new primitives, and so on. He also took the opportunity to make further changes to the code, such as improving error handling and enhancing modularisation.

In connection with a migration project from APL+Win to Dyalog, DPC developed a solution for integrating the Dyalog interpreter in the form of an OLEServer object. The ActiveX server for APL+Win was the model for the solution.

The main requirement for the development of the interface was not only the pure interface to the interpreter for code execution, but also the necessity for access to the development environment in its entirety, with editors and tracer for debugging. In concrete application scenarios, the interface is used for programming and maintaining heterogeneous applications in which different code sources and development environments are used. Jürgen explains the development undertaken by DPC.

Kai demonstrates how he develops with Dyalog using the latest tools and technologies; he opens a project using Cider, investigates a bug report, fixes the issue and reduces the technical debt, produces a new version, runs tests, and publishes the updated version as a Tatin package.

This includes using tools such as Git, GitHub, Cider, and Tatin, performing a search-and-replace with ]Fire, using a comparison utility, and leveraging user commands like ]APL2Git and ]GitHub, among others.

A few years ago, Pete decided to port Filos (Greek for friend), a Greek/English Language system that he had developed for PocketAPL, to mainstream Dyalog. He chose to use the HTMLRenderer to replace the Microsoft Windows GUI, mainly for portability, and this choice forced him to learn HTML, JavaScript, and CSS. He decided to use an object-oriented approach, partly because the HTML DOM (Document Object Model) is object oriented and partly because an OO approach suited his application. At some point, he realised that he had developed the basis of a general framework that could be used to develop any type of Dyalog GUI application, and Noodle is the result.

The Microsoft Windows GUI objects (such as Button, Edit, and Grid) are replaced by HTML elements (such as Button, Input, and Table), but Noodle also supports jQuery user interface widgets, and now the commercial jQWidgets library. It provides a built-in layout tool, so users do not need to specify the position and size of GUI elements. Just as the Dyalog Windows GUI requires no knowledge of the basic Windows API, Noodle users need know nothing about HTML, CSS, or JavaScript. Despite the fact that Noodle uses the HTMLRenderer, it is NOT a web server application.

Pete demonstrates how to use the Noodle Framework to develop the GUI for an application and some of the widgets currently available before discussing future developments.

PxEdit started as a temporary application for just one specific purpose, but quickly gained lots of users. It has become an all-purpose tool for creating and managing Px files containing statistical tables, which is crucial for the many organisations around the world who are using PxWeb databases.

Over the years, the application has grown in an uncontrolled fashion, with new features added when needed, quick hacks, and fixes over patches. With an end goal of making PxEdit open source, Veli-Matti gives a short introduction to how the code, infested with almost every APL sin, might be rearranged so that another human being could understand it. Possibly.

When Charles graduated from university, Larry Breed invited him to join the APL group at IBM – comprising Ken Iverson et al. – in developing an APL interpreter and, to an extent, APL itself. These were inspiring people to work with, as remains the case today.

Geoff takes a historical walk through some of the key technical decisions made during the development of Dyalog APL. Expect some nostalgia, some repentance, some triumphalism, and some serendipity.

Decades ago we expected that by now computers would mostly talk APL, which would have taken over the world. Stephen asks Gitte, Geoff, and Pete how they took care of APL in the real world and kept the dream alive.

For its first two decades, APL was most new users' first encounter with programming – and an exciting plunge into personal computing. These days, most new APLers know several programming languages already. Stephen asks Gilgamesh, Martina, Josh, and Sandra what APL looked like to them at first, and why they stuck with it.

APL has a wide range of techniques that can be used to solve a given problem, and its terseness and versatility makes it feasible to try different approaches to see what works best in a particular scenario.

In this workshop, you will solve a variety of problems; we will review our solutions together to enhance our problem solving skills.

Keywords: problem solving, exercises

There are a few simple heuristics to consider when it comes to performance in Dyalog. This workshop is targeted at novice APLers, and focuses on the fundamental aspects of the array model and the interpreter that will have the most impact on performance when writing code.

You will learn how to profile functions to find especially slow parts of code, as well as how to write the same computations in a more efficient manner – this includes using flat arrays, specially optimised "spellings" (referred to as idioms), and reducing the number of computations overall where possible.

Keywords: optimisation, performance, profiling, array model, array-oriented programming

NOTE: This workshop is a re-run of workshop SP3 from Dyalog '23, but updated to cover some of the most recently-added features of both HttpCommand and Jarvis as well as using the OpenAI API with HttpCommand

A web service is a software system designed to enable communication and interoperability between different applications or systems over the internet. It provides a standardised way for different software applications to exchange data and perform various functions. Web services are commonly used for a wide range of purposes, such as integrating different systems, sharing data between applications, automating business processes, and building distributed applications. Web services provide a scalable and platform-independent way of enabling communication and data exchange between disparate software systems. These functionalities can be accessed and utilised by other software applications, irrespective of the programming languages or platforms they are built on.

In this hands-on workshop, you'll learn how to:

• consume web services using HttpCommand.
  HttpCommand is a utility used to issue HTTP requests and receive responses. It can interact with practically any web service. We will:
  • cover the most commonly used features of HttpCommand.
  • learn how to develop and debug web service requests.
  • access a variety of web services including web services that require authentication.
• provide web services using the Jarvis web service framework.
  Jarvis makes it easy to make many Dyalog applications available over the internet. We will:
  • develop a simple web service in 5 minutes.
  • cover the essential features of Jarvis.
  • examine and experiment with a sample web service.
  • demonstrate how to access our web service from a browser and using HttpCommand.

Keywords: web services, HttpCommand, Jarvis, OpenAI API

In tradfns, function arguments must be named in the header. In dfns, they are named for us as ⍺ and ⍵. With tacit programming, we express a function directly as a composition of other functions, without reference to the arguments – the arguments are handled implicitly (tacitly!) according to syntactic rules. This can result in terse and memorable function expressions that can be drawn upon when needed, just like other idioms.

In this hands-on workshop, you will learn how to read, write, and use function trains and compositional operators.

Keywords: function composition, function trains, tacit, operators

Dyalog has been adding primitives to APL at a steady, but careful, pace. If you would like to get a better grasp of the newest functionality, then this workshop is for you!

In this hands-on workshop you will explore functions like tally (monadic ≢), where (monadic ⍸), interval index (dyadic ⍸), unique mask (monadic ≠), and left/right/same (respectively, dyadic ⊣, dyadic ⊢, and monadic versions of both of these), in addition to operators like at (@), constant (⍨), and key (⌸). There will be lots of exercises to aid understanding.

Keywords: language enhancements, exercises

Users, IT departments, and auditors are pushing APL developers to move existing Win32 applications to the cloud, to simplify deployment, improve security, and increase accessibility.

In this workshop, you will discover how existing Microsoft Windows desktop application User Interfaces based on ⎕WC objects can be converted to web applications with a minimum of effort and with the added bonus that it becomes easier to update their appearance.

Keywords: Microsoft Windows, WinForms, Graphical User Interface, GUI

In tradfns, function arguments must be named in the header. In dfns, they are named for us as ⍺ and ⍵. With tacit programming, we express a function directly as a composition of other functions, without reference to the arguments – the arguments are handled implicitly (tacitly!) according to syntactic rules. This can result in terse and memorable function expressions that can be drawn upon when needed, just like other idioms.

In this hands-on workshop, you will learn how to read, write, and use function trains and compositional operators.

Keywords: function composition, function trains, tacit, operators

Dyalog has been adding primitives to APL at a steady, but careful, pace. If you would like to get a better grasp of the newest functionality, then this workshop is for you!

In this hands-on workshop you will explore functions like tally (monadic ≢), where (monadic ⍸), interval index (dyadic ⍸), unique mask (monadic ≠), and left/right/same (respectively, dyadic ⊣, dyadic ⊢, and monadic versions of both of these), in addition to operators like at (@), constant (⍨), and key (⌸). There will be lots of exercises to aid understanding.

Keywords: language enhancements, exercises

In Dyalog, namespaces are unusual scalar values that are often under-utilised by the APLer. They are often treated as only a convenient way to organise a workspace, but they can also be used as containers for objects and data. Even classes, whether implemented in APL, external (such as ⎕WC GUI objects), or imported from Microsoft .NET, reside in namespaces.

This workshop demonstrates the value of namespaces both as structured containers to organise code and as self-contained dictionaries of name-value pairs.

Keywords: namespaces, code organisation, dictionaries, object orientation

APL has a wide range of techniques that can be used to solve a given problem, and its terseness and versatility makes it feasible to try different approaches to see what works best in a particular scenario.

In this workshop, you will solve a variety of problems; we will review our solutions together to enhance our problem solving skills.

Keywords: problem solving, exercises

NOTE: This workshop is a re-run of workshop TP3 from Dyalog '23

The interpreter provides several built-in functions to import, export, and process data in files, and to manage the host file system. These are invaluable tools in their own right, and can be the building blocks for powerful APL applications that are largely independent of the host system on which they run. This workshop examines these functions in depth, starting with a simple introduction and then showing their Dyalog v19.0 enhancements.

Keywords: import data, export data, built-in portable file functions

The Dyalog community is transitioning from binary formats to Unicode text files as the preferred mechanism for storing the source code of APL applications. Dyalog includes a tool known as Link, which maintains the connection between the names in the active workspace and the corresponding source files.

This workshop is aimed both at users who are new to Dyalog and wondering how to start a project, and existing users who would like to transition to using text source. It covers:

• Part 1: Getting started with Link
• Part 2: Moving an existing APL application to Link
• Part 3: Project, Package and Source Code Management tools – Git, Cider, Tatin, and NuGet

Keywords: Link, Cider, Tatin, Git, NuGet