Workshops

Workshops have significant time set aside for participants to experiment with the subject matter.

NOTE:Some of the workshops require materials that should be installed on your laptop prior to attendance – details will be added to these webpages soon.

You are very welcome to change which workshop you attend at the last moment, as long as there is space in the workshop room. However, before doing this, please check that you meet the pre-requisites for the workshop that you are joining.

Show all Summaries

Key to workshop identifiers:

MA – workshop is scheduled for Monday morning (AM)
MP – workshop is scheduled for Monday afternoon (PM)
FA – workshop is scheduled for Friday morning (AM)
FP – workshop is scheduled for Friday afternoon (PM)

MA1: Web Services in APL: An Introduction to REST and OpenAPI

Show Summary

A RESTful web service enables different applications to exchange data and functionality over the internet using a standardised request/response model. OpenAPI is a machine-readable way to describe such services, and has become the unofficial standard for doing so – from a single specification, tools can automatically generate client code, documentation, and tests. Thousands of public web services publish OpenAPI specifications; this hands-on workshop shows you how you can easily build APL clients for any of them using Dyalog's OpenAPI tool.

No prior experience with REST or OpenAPI is assumed.

In this workshop, you will:

develop an understanding of REST and OpenAPI. An explanation of what makes a web service "RESTful" and how an OpenAPI specification describes one in a form that both humans and tools can read.
consume web services from APL. Using Dyalog's OpenAPI tool, you'll automatically generate an APL client from the OpenAPI specification of a public RESTful webservice and make real requests from an APL session.
provide OpenAPI-compatible web services from APL by building your own REST service using Jarvis together with Stark (a router for Jarvis that conveniently publishes its own OpenAPI specification) then exercise the service end-to-end, reading from and writing to it from a separate APL session using an automatically generated client.

After this workshop you should feel confident consuming third-party REST APIs from APL and exposing your own APL code as a web service that other tools and languages can consume.

Keywords: Web services, REST, OpenAPI, Stark, Jarvis

MA2: Juggling Arrays and Namespaces

Show Summary

Note: This workshop is repeated on Monday afternoon – see MP3.

Dyalog v20.0 made it significantly easier and safer to work with arrays and namespaces: array notation lets you write array literals, while the new system functions ⎕VGET and ⎕VSET, together with the enhanced ⎕NS, let you read, write, and merge values by name, replacing most uses of execute (⍎).

In this hands-on workshop, you will explore the new syntactic forms and put them to work.

Keywords: array notation, namespaces, exercises

MA3: Concurrent Programming in Dyalog

Show Summary

APL's array-orientation means that it is an inherently data-parallel notation. For performing the same operation on multiple elements (SIMD), there's not much more you need. However, for expensive computations, calls to external services, or computing while your system continues to service external requests, you might want to run multiple different functions at the same time, or run functions in different CPU processes or even different machines at the same time.

This workshop looks at the two main features of Dyalog made for concurrent programming: the spawn operator (&) and its associated ⎕Txxx system functions; and the isolate.dws workspace. You will learn how to run functions in parallel, strategies for managing multiple threads, and how you can collect results.

Keywords: performance, optimisation, concurrency, parallel language features

MP1: Performance from the Bottom Up

Show Summary

Note: This workshop is repeated on Friday afternoon – see FP1.

Many APL applications have a reputation for tremendous efficiency and performance, but users might be surprised to discover that their code does not run as fast as they would like, or that it uses too much memory. Because APL isn't like other languages, it's important to understand how to get the most from APL's unique design to maximise your performance while minimising your programming efforts.

In this workshop you will gain a strong foundation in using the APL primitives fluently to write performant programs. After going through the fundamentals of how the interpreter executes APL code, you will use that knowledge to build up a library of performance techniques. You will also have the opportunity to apply your knowledge with hands-on exercises and discussion.

Keywords: performance, algorithms, optimisation, array model

MP2: Asynchronous Services: What, Why, and How

Show Summary

The traditional request-response model has a fundamental limitation: the client must always speak first. This makes it awkward (and sometimes impossible) to build applications where the server needs to push updates, multiple parties exchange messages in real time, or work continues long after the initial request. Asynchronous web services solve this problem, and they're the backbone of dashboards, stock tickers, news feeds, multiplayer games, chat rooms, and long-running computations.

This hands-on workshop covers the three dominant techniques – WebSockets, Server-Sent Events (SSE), and webhooks – and the Dyalog tools that bring them within easy reach: HttpCommand, Jarvis, WebSocketClient, and WebSocketServer.

In this workshop, you will:

develop an understanding of when to use WebSockets, SSE, and webhooks, and how they differ.
gain hands-on experience with Dyalog's asynchronous toolkit: HttpCommand, Jarvis, WebSocketClient, and WebSocketServer.
consume existing asynchronous services from APL.
build and deploy your own asynchronous service.

Keywords: webhooks, WebSockets, asynchronous, Jarvis, HttpCommand, WebSocketServer, WebSocketClient

MP3: Juggling Arrays and Namespaces

Show Summary

Note: This workshop is a repeat of the workshop on Monday morning – see MA2.

In this hands-on workshop, you will explore the new syntactic forms and put them to work.

Keywords: array notation, namespaces, exercises

FA1: Beyond the Primitives: Using Iteration and Recursion in APL

Show Summary

Traditional programming and idiomatic APL written in a data-parallel style can sometimes feel incompatible and impossible to use together. Dyalog APL provides a number of features around traditional iteration that can be used to great effect or that can greatly undermine APL's biggest advantages. Understanding how traditional concepts like iteration and recursion fit into the idiomatic APL landscape can greatly improve the architectural clarity and maintainability of your code, as well as giving you a better overview of large APL applications.

In this workshop you will explore patterns for writing iterative, recursive, and stateful code in APL. There will be a focus on how to take best advantage of the many constructs for control flow available in Dyalog, such as structured statements, labels, and recursion; you will learn how to use these features to write programs that are easy to read, debug, and maintain while avoiding the pitfalls that can undermine the quality of your code.

Keywords: control flow, recursion, loops, idioms

FA2: Introduction to Namespaces

Show Summary

In Dyalog, namespaces are a convenient way to organise a workspace (analogous to the way in which directories are a convenient way to organise a file system). Namespaces simplify application development by allowing you to give the workspace a structure; they can be used as containers for objects, data, and code modules. Whether classes are implemented in APL, or external classes like ⎕WC GUI objects and .NET classes, each object resides in a namespace.

In this workshop, you will explore the value of namespaces, which have become cornerstones of modern APL application development. You will see how they have been integrated into the APL paradigm, their power, their limitations, and the fundamental differences from nested arrays, where a change to an element of an array that has more than one name will force a copy which decouples the values from each other. You will also learn how namespaces enable APL to easily interface with most modern technologies, which are often object-oriented. There is time for you to experiment and become comfortable with the tricky bits.

Keywords: namespaces, references, data containers, code organisation

FA3: Problem Solving with APL

Show Summary

Note: This workshop is a repeat of the workshop on Friday morning – see FP3.

APL users have access to a wide range of techniques to solve any given problem; the terseness and versatility of APL means that different approaches can be tried 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

FP1: Performance from the Bottom Up

Show Summary

Note: This workshop is a repeat of the workshop on Monday afternoon – see MP1.

Keywords: performance, algorithms, optimisation, array model

FP2: Introduction to Link

Show Summary

Most actively-maintained APL systems have switched or are switching to using text files for source, rather than workspaces or component files. This allows integration with source code management systems, build and test frameworks, and of course to experiment with "agentic AI". If you have not yet experienced the benefits of text-based source, or you understand the benefits but need help to get started, this workshop is for you.

Link allows you to use Unicode text files to store APL source code, rather than "traditional" binary workspaces. The workshop includes:

how to find and use the documentation.
the types of APL objects that can be handled, and how each is represented as text.
how Link synchronises changes made inside and outside the active workspace.
migrating an existing workspace to text-based source.
using GitHub to manage "Linked" source code.

Keywords: text files, text-based source, source code management, Link

FP3: Problem Solving with APL

Show Summary

Note: This workshop is a repeat of the workshop on Friday morning – see FA3.

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

Receive Updates on Dyalog ’26

Your Name

Your email address will only be used to send you updates related to Dyalog ’26. You can unsubscribe at any time.

Workshops

Receive Updates on Dyalog ’26

Find Us Online