Dyalog Ltd's CEO opens the user meeting.

How might Dyalog evolve in the years to come, and which technologies should you be trying to keep an eye on yourself? Morten attempts to answer these questions, and sets the scene for the technical presentations being given at Dyalog '22.

John has been noodling with some interesting things. In the first part of this series, he demonstrates some improvements to Dyalog's Session log.

Frustrated by function trains? Stymied by single line dfns? In the second part of this series, John demonstrates some new features that will take away some of your pain.

Morten expressed his opinion that the growth of APL is hampered by a lack of widely-used libraries in an article he wrote for Vector in July 2003 (vol 20 issue 1), and his opinion has not changed since then. Has the tooling finally reached a point where off-the-shelf sample projects and shared libraries have become viable?

Peter is the most recent addition to the Dyalog interpreter development team. While he was still at Aalborg University, Peter implemented his own APL interpreter for the Plan9 operating system, a UNIX-like "distributed operating system" developed at Bell Labs in the 1980s. In this presentation, Peter demonstrates some of the more interesting features of APL9 and explains the presentation title...he might also mention a couple of the things he has been working on since joining Dyalog Ltd.

Testing APL Functions is sometimes seen as optional, as the functions are so small and self describing. Michael challenges that view, demonstrating some essential tools that are used internally within Dyalog Ltd (and are available to all users) to enhance the level of testing and, therefore, improve the quality of delivered code.

The U-Net is an architecture of a convolutional neural network that is well-known in the machine learning literature. Rodrigo worked with Aaron Hsu on a paper about using APL to implement this architecture and experiment with it; in this presentation he explores the code base that they used.

Dyalog version 18.0 introduced many useful performance enhancements, including some within the set-related primitives. Karta outlines the ongoing work that is being performed to understand what the performance profile of key primitives look like (beginning with the set-related primitives), discusses where performance gains can still be made, and describes how future evaluation of performance enhancements will be conducted by examining some of the shortcomings of the v18.0 performance work.

In the final part of this series, John explores some ideas for asynchronous programming in Dyalog.

Aaron reviews the current state of Co-dfns (a high performance compiler for a parallel extension of the dfns language), developments since the last update (at Dyalog '19), and what the future might look like. He also explores how the Co-dfns compiler has been received in the broader computing communities and its impact on other projects.

Jarvis is Dyalog's framework for the easy development of APL-based Web Services. Once your APL code running as a Web Service you might need to address additional considerations:

• Security – protecting your and your users' private information
• Availability – keeping your service running at all times
• Scalability – managing increases in demand

Brian introduces Jarvis, and discusses some options for running a secure, high-availability, scalable Web Service.

The 14th annual International APL Problem Solving Competition took place earlier this year. Brian summarises this year's contest and introduces the grand prize winner, culminating in the award ceremony.

APL has a reputation for being very good at numerical and financial types of calculations, but much of what modern data processing entails requires working with textual data of various sorts. Aaron discusses APL in the context of text processing, with an emphasis on parsing, architecture, and handling text-oriented applications.

Adám presents three proposed new primitives, and explains how their addition makes the language more complete. One complements the existing set of function composition operators, one generalises each in a manner similar to the powerful rank operator, and one supplies a functional form of the last remaining uses for square bracket indexing.

Rich describes the need for (and ways to achieve) increasing and improving the resources that are available to help new users learn the basics of the language, utilise the many features of Dyalog, and develop their skills. He also discusses some of his experiences over the last year in training new and existing APLers.

Numerical integration is a computer task that arises in many practical problems. It is a key step in the evaluation of forensic DNA evidence that requires integrating a function likely of two to five variables corresponding to the number of people whose DNA comprises the evidential sample. Integrating a function of one variable¹ by computer is familiar ground. For several variables² there is some deep and technical literature, based on a superficially obvious extrapolation of one-variable integration. Charles will discuss an evidently elusive though simple and natural alternative extrapolation that overcomes multiple shortcomings of the published methods.

Referenced equations:

1: and 2:

This is the story of an ongoing project to move a large APL2 mainframe system to Dyalog on a modern platform. Gilgamesh presents the obstacles encountered and the milestones achieved in this ambitious endeavour.

BIG is a company in the jewellery industry that integrates with dozens of systems to import data from 1,000 retailers. The data is used to provide inventory analysis and merchandising consulting for the retailers, to provide sell-through data to manufacturers, and to integrate to several industry service companies. The end-user tools, and the integration applet, are written in C#, ASP.Net, JavaScript, MSSQL, and KendoUI.

APL was chosen to handle all data-related tasks, from processing the incoming data to infinite customisations of the data for customer use. Using the data manipulation capabilities, modular design, and rapid development capabilities of APL, BIG can respond quickly to user requests and changing data streams and configurations. The data comes in to BIG's servers in dozens of configurations, different numbers of files, different file formats, and inconsistent content. APL is used to transform this data to a standard upload into the production MSSQL database, normalising the formats and often converting the jumble of information into usable data.

For 15 years, BIG have used an organically-grown IBM APL2 environment that uses Microsoft Windows scheduled tasks to call .bat files to invoke APL2 to process the data at the time it is expected to come in. Over the past year, Mark has created an entirely new production environment using Dyalog that uses:

• Windows Service to monitor incoming data and call the appropriate processes when it arrives.
• SQAPL to communicate directly with the production database.
• ⎕CSV, ⎕XML, and ⎕JSON to read from files of those types.
• .NET integration to connect to DLL libraries for utilities including ClosedXML for reading/writing Microsoft Excel files.
• HTTP calls to read from external APIs.
• ]Link to read/write to text files containing the APL code.
• source control for production code.

All code for the new environment is stored in text files (.aplf) and is brought into the running workspace as needed, and source control is used to share code within the team.

In addition to being an Airbus Captain at FinnAir, Kimmo prepares analyses that are used for operational optimisation and negotiation between the airline and staff. He has constructed his own workbench for data analytics, with Dyalog at the centre of a collection of modern tools: DuckDB for data storage and queries, Vega-lite for graphics, Jupyter Notebook for presentations, and Visual Studio Code and GitHub Copilot for managing the code. In this presentation, Kimmo demonstrates the workflow that he has been able to achieve with this collection of tools. All his interfaces are available as GitHub projects.

For many years, Kimmo has been searching for a modern replacement for Adrian Smith's RainPro graphics package, which is oriented towards printed output and cannot easily produce interactive web-oriented graphics. His current choice is Vega-lite, which is a "high-level grammar of interactive graphics" that can easily be driven from APL using JSON input. Kimmo describes his search for a new graphics library, and explores the mechanics of the interface.

All developers test their solutions and, if they are seasoned, they build functions that test those solutions for them – if they are "modern" they automatically run their test functions using Continuous Integration (CI). Lars demonstrates how everyone can move from the initial step to the last step using standard (free) tools for APL where the code is maintained in files.

The application build process should be automated and always use a consistently clean environment. In this high-level overview about using Amazon AWS resources for on-demand releases, Norbert covers:

• building a new VM.
• installing Dyalog and other development tooling.
• downloading source code and dependencies.
• building and compiling the application.
• uploading MSIs to a cloud provider.

30 years ago, SimCorp Sofia started as a single-threaded application, (ab)using lots of global and semi-global variables. As new technologies emerged, Sofia evolved into a multi-threaded client-server application. Adapting old code often proved difficult; Elena describes some of the issues encountered over the years, and how they approached – and (hopefully) solved – them.

Dyalog users are fortunate to be able to use APL for an entire project when it is a good fit. Traditional software engineers that are interested in APL often have to find ways to use APL on the side or incorporate APL thinking into their professional work. April* and May are two projects that allow APL to be evaluated from Common Lisp and Clojure, respectively. These projects allow APL to be incrementally employed in projects that don't currently use APL. Justin describes these projects and the ways that he uses them.

* For more on the April compiler, see APL Seeds '22 presentation U02.

Scheduling array operations has been a topical theme in the research of tensor computation. With the help of type theory, array operations are parallelised for graphics processing units and distributed computing. Juuso shares his findings in static scheduling, and how it can be used to optimise execution over different hardware and compute infrastructure settings.

Veli-Matti has been using Dyalog since 1995, and has always been interested in the performance of his APL code. In this presentation, he examines how the performance of operations that are important to his applications have evolved over almost three decades.

Mathematical programming is a technique that can be used to optimise resources. The typical mathematical notation for linear optimisation is:

max c'x subject to Ax ≤ b

where x is a vector of decision variables, b is a vector of constraints, c is a vector of unit profits, and A is a matrix of resource usage. We can create similar-looking expressions using standard APL syntax, that is:

NS ← max c x subjectTo A x ≤ b

Stephen demonstrates this using TAMPA, a linear programming system written in Dyalog. A user interface for TAMPA has been written in Abacus, an HTML framework for Dyalog.

HTMLRenderer is the most powerful addition to Dyalog in the last 10 years – there's never been greater ability to create modern interactive user interfaces. Norbert describes how The Carlisle Group are upgrading parts of their legacy Microsoft Windows application to take advantage of these new UI abilities while retaining a uniform theme. Integrating these complex environments comes with new challenges that require learning new programming environments (JS) and new ways to design application architecture… Async anyone?

Michael is the winning professional entrant of the 14th annual APL Problem Solving Competition. A newcomer to APL, he describes what led him to the competition and his experiences using it as a vehicle to learn APL/Dyalog, and explores some of the approaches and solutions behind his successful entry.

Lee is the grand prize winner of the 14th annual APL Problem Solving Competition. Following the award ceremony, he describes his experiences of APL/Dyalog and tells us how he managed to master enough of it to win the competition.

Jesús and Gitte introduce the plan for bringing Dyalog back into academia. The final objective is to position Dyalog as a useful tool for scientific research and education, and make the academic world aware of the power of APL. This work will be done in collaboration with the Materials Science department at Ghent University (in Belgium), which will serve as a real example of an academic research environment with programming problems that can be better solved with APL.

Ray is working on another APL textbook and is at the point where he needs feedback!

There exists an important group of people who should be exposed to APL – students aged 14-18 years old. Ray's book is intended for this audience. It also could benefit college students who need to be exposed to computer languages, but do not want to study computer science.

The text does not cover all aspects of APL; instead, it focuses on introducing students to the APL language. It accomplishes this through many illustrations and exercises. Ray has been working on this for several years and the text is now at a point where he believes it could benefit greatly from your views and comments.

Download the draft and send feedback

APL is famous for being used to tackle problems in a "different" way compared to more conventional programming languages. Although it is possible to convert code written in Python/Java/C#/etc. into APL by merely substituting keywords with symbols, there are better ways to take advantage of a notational, executable tool of thought. In this hands-on workshop, you will learn how to use array-oriented techniques to solve some problems "the APL way". Only a basic knowledge of APL is needed.

Keywords: problem solving, array-oriented programming, rank operator, leading axis theory

Almost all programming languages and application frameworks, on all platforms (including phones and IoT devices), include utilities tools that make it easy for them to call Web Services. This means that, if you embed your APL code in a Web Service, you can integrate your functions into almost any software system. Dyalog's framework for easily developing APL-based web services is Jarvis.

• learn how to decide whether to build a simple HTTP/JSON service or do the extra work required to implement a proper RESTful server.
• build a simple (HTTP/JSON) web service in 5 minutes.
• learn about Jarvis' configuration options.
• learn about session management and authentication.

Keywords: Web Service, Jarvis, HTTP, JSON, REST

Hopefully you are already convinced of the benefits of storing your source code in text files. In this workshop, we will show you how to make the shift from workspace to text files using Link. We will also cover source code management tools (for example, Git) that you can use to collaborate and share your code with other team members. This workshop involves extensive hands-on practice.

Keywords: Link, Git, GitHub, VS Code, Acre

This workshop focuses on features introduced in Dyalog v18.0 and v18.2 – new functions and operators as well as extensions to primitives and system functions – and includes hands-on exercises designed to show their use cases. You might find elegant solutions to problems that you are currently using workarounds for, improved ways to express algorithms, or just generally useful tools.

Keywords: function composition, primitive extensions, trains, tacit, operators, text, datetime, formatting, meta information

You've built a Jarvis web service (or some other APL-based service), now you need a way to make sure that it is up and running all the time, and able to scale to meet demand if it should grow suddenly? In this workshop we will cover some of the ways by which you can "deploy" your web service, either on your own hardware or "hosted" using one of the most widely-used systems, Amazon Web Services (AWS).

This workshop will cover:

• using Docker containers.
• using AWS.
• running a secure service.
• scalability.
• options for permanent storage.

Keywords: Web Service, scalability, security, load balancing, hosting, Docker, AWS, deployment, Jarvis

Dyalog has a rich set of tools to import, export, and process data from external sources such as files, databases, and exchanges with other applications. This workshop explores some of these, including:

• direct access to a host filesystem.
• reading and writing of text files.
• reading and writing the content of Character-Separated Variable (CSV) data.
• reading and writing JavaScript Object Notation (JSON) data.
• working with Microsoft Excel spreadsheets.
• importing data from databases.
• importing data from OData sources in the cloud.

Keywords: filesystem, text files, CSV, JSON, Microsoft Excel, databases, OData

This workshop takes a thorough, first principles, approach to understanding APL performance, with the goal of equipping you with the tools and thought processes that you need to take a piece of APL code and understand how it is likely to perform, why it performs this way, and strategies for potentially improving the speed of the expression. We will also cover not only tricks and one-off performance considerations, but the tools that will allow you to feel confident that you have written "fast APL" and haven't missed something critical. Finally (time permitting), we will discuss the use of Accelerators for GPU-based APL programming using the Co-dfns compiler and how this impacts our performance analysis.

Keywords: performance, analysis

Futures and isolates are APL language features designed to make it straightforward to harness all the cores that your computer (or cluster of computers) has available, whether you are writing a new application or need to speed up legacy code. Following a theoretical overview of Futures and Isolates and a description of how they are implemented, the workshop will consist of exercises showing you how to:

• create isolates and populate them using current workspace contents – or a saved workspace.
• monitor the state of execution.
• debug and troubleshoot.
• call back to the parent space from within an isolate.
• distribute large workloads.
• use remote isolate servers.

Keywords: parallel, asynchronous, multicore, performance, futures, isolates

A package is a versioned APL module that has been wrapped up in such a way that it can easily be installed and managed using a Package Manager such as Tatin. A package manager makes it easy to know when new versions become available, and to upgrade the packages that your application depends on. In this workshop, we demonstrate how to create APL packages either from existing code or a new project. We also look at how to load and use packages as dependencies in your application, and give an overview of the different frameworks that exist and their use cases.

Keywords: project management, package management, dependency management, DevOps, Git, GitHub, semantic versioning