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

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

APL's array-orientation means that is it 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 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

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

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, that is, 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

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

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

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

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

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

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

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