Dyalog Ltd's CEO opens the user meeting.

Morten presents his view of the currents that APL users will need to navigate in the years to come, and the steps that Dyalog is taking to make the journey a pleasant experience.

Jay discusses technical achievements in the latest version of Dyalog APL, new projects targetting the next release, and priorities for the engineering team for the next few years.

The procedural and denotative mindsets are quite different. John hopes to highlight those differences by stepping through the translation of one style into the other.

Most new work on APL code distributed with Dyalog APL is now based on open-source repositories, and version 16.0 includes the source for many new tools as text files which have been copied from these repositories. Morten talks about why we are doing this, how to find and load – and contribute to – the new code, and finally discusses ideas that Dyalog is working on which will allow you to easily build and test applications based on text source.

Python is a popular programming language with some similarities to APL. An interface between the two would enable APL programmers to benefit from being able to call libraries written in Python, and Python users could take advantage of APL to do analyses that are difficult to code or perform poorly in Python. Marinus, one of the winners of the 2016 Dyalog Problem Solving Competition, was an intern at Dyalog in July and August of 2017, and spent this time developing a Python-APL interface – Py 'n' APL.

Roger presents an efficient computation for x⍳y. The solution makes key use of the new interval index (⍸) primitive, and the relatively new key operator (⌸) elucidates the classical hashing algorithm.

Dyalog version 16.0 features some big improvements to functions that move Boolean values around, like Reverse, Rotate, Catenate, Expand/Compress and Transpose. Marshall shares some of the secrets that make Dyalog's new versions of these primitives so fast, in particular the many tricks needed to make transposing a Boolean matrix efficient for every possible shape.

The HTMLRenderer is a new tool for building user interfaces that can be displayed by Dyalog version 16.0 under Microsoft Windows, Linux and macOS. In a series of brief demos, Brian shows how it can be used to build a confirmation prompt, a simple data entry form, display some graphics – or run an existing MiServer application.

Unique (∪) with non-zero ⎕CT is incorrectly implemented in all but one of the APLs and APL dialects that has the primitive. Roger analyses how the error came about and describes a solution (and a speed-up). He also proposes that unique be extended to higher-ranked arrays.

New primitives and system functions are frequently added to Dyalog APL, but extensions to the syntax of the language are rare. Adám proposes a notation for arrays and namespaces that allows definitions to be spread over multiple lines.

How do you make it easy to introduce people to APL?

Adám and Brian talk about two websites, TryAPL.org and tio.run, that allow a user with no more than a browser to use Dyalog APL online.

New native file functions were introduced in Dyalog version 15.0 to allow simple and portable access to the host file system. More are coming, and Richard will attempt to predict what they will be.

Andy once again takes a look at some of the less-well announced features of Dyalog APL. He mainly concentrates on features within Dyalog version 16.0, but might mention other versions (past and future!).

The extension to ⍳ makes it possible to "find anything". Roger proposes that ⍋ (and ⍒) should be extended so that it can be used to "sort anything". The extension also enhances the usefulness of the new interval index (⍸) primitive.

Dyalog's user command system is under constant development. Michael and Adám demonstrate the latest additions and show how they can simplify your work. They also describe what they are currently working on to make your APL development experience even better.

The right operand of the @ operator can be a Boolean-returning selection function. In this case, the shape of the resulting mask must match that of @'s right argument. This extension investigates allowing lower-rank masks to conform, for example, a Boolean vector result could select rows of a matrix.

Writing good, efficient, maintainable APL code that maximises the value of APL's design elements does not appear to coincide with traditional best practices of software engineering commonly taught at the University level of Computer Science education. This is readily apparent in the early competency plateau that new array programmers experience after they "get the basics". While learning to write good code is the journey of a lifetime no matter what language you write in, escaping a beginner’s competency in order to really understand, manipulate, and work with advanced APL programs that exhibit all the classic qualities of "beauty" ascribed to famous APL one-liners can be better understood and facilitated by addressing the disparity between best practices in APL code and best practices as they are understood in traditional Computer Science curricula.

Understanding what makes good APL code, why this matters and how it differs from writing good code in other languages can have wide-ranging benefits. Code reviews can become more targeted, coding styles can be written in a more APL-friendly way, on-boarding beginner APL developers can be accelerated and explaining APL code to sceptical non-APLers can rely less on hand waving and appeals to nebulous, ill-defined concepts.

RIDE 4.0 was released simultaneously with Dyalog version 16.0. Gil and Callum review the most important features of the new version, and speculate about what might be in RIDE 4.1.

Kostas describes his experience of using APL to produce a research paper on "model making and numerical computing".

(Work done in conjunction with Troels Henriksen and Cosmin E. Oancea)

Martin presents a status report of the APL→TAIL→Futhark compiler, which compiles a subset of APL into code executable on GPUs. The compiler handles quite a number of APL functions and operators and is, for the subset of APL it supports, highly compatible with code written for Dyalog APL. As well as reporting on the performance of a number of APL benchmarks, he demonstrates, by example, how the APL compiler tool chain can be used to efficiently teach a neural network to recognise handwritten digits.

The Co-dfns compiler has made significant strides to improve usability, reliability and the feature completeness of the compiler – in this talk Aaron focuses on the status of feature-completeness and improvements to the installation, configuration and usage. He gives specific instruction on understanding errors and debugging issues with the compiler as well as providing a set of guidelines for writing high-performance APL code with Co-dfns, explaining how the performance model of parallel computation differs from the performance model of the interpreter when writing code. This will help anyone who is writing Co-dfns programs to understand how to optimise code to best run on the compiler.

Time permitting, a bit of flashy demo time might also be in the works!

Assuming that you have all the time in the world and no customers then you would probably be able to get your application designed to run in parallel fashion with well-defined components and clear interfaces between components – but what do you do when this assumption does not hold?

Lars gives an introduction to the way in which SimCorp tries to utilise the power of the modern PC HW and use more than one CPU and still work within the boundaries set by a 25-year-old application.

Over a few decades, our application (SOFIA) has run on different operating systems, moved from one APL interpreter to another, and experienced dramatic changes in user input/output technologies. We have worked hard to abstract our designs from hardware contexts, to free screen design from rigid bonds, and to dream up adaptive screens using a dynamic approach.

Banking in Southern Africa has a heavy focus on regulatory reporting. Reading substantial amounts of data, doing a little bucketing and some simple sums is the game. After writing three import routines in three months or manually exporting 100 .dlls in a day it becomes apparent that there must be a better way.

Having generalised tools to handle common tasks allows for more time spent on the interesting side of coding. Furthermore, having access to open source tools and libraries has become the norm for most popular languages but is not as readily available in APL. Zack discusses the motivation for, and application behind, several open source tools that he has developed.

In the last decade, low cost devices capable of receiving raw data in a wide range of frequencies have become commonly available on the market. Software Defined Radios (SDR) are now widespread, replacing components that are traditionally implemented in hardware with software. Moris explains how it is possible to connect the Dyalog APL interpreter to those devices and to receive and convert the radio signals using APL.

For many years, we were a small team with deep insight into subjects we had worked on together for a very long time, and minimal internal communication requirements. As we added less experienced team members and the number of parallel projects grew, we realised that we needed tools to help us manage our work – but "traditional" project management tools didn't feel very comfortable.

This is the story of how Alexey discovered the JIRA framework from Atlassian and came to understand that Agile project management was exactly what he was looking for.

In 2 dimensions, a polyomino is a plane geometric figure formed by joining one or more congruent squares edge to edge; in 3 dimensions, cubes are used instead of squares and joined side by side. In this talk, John discusses multi-dimensional polyominoes, and why APL is a good tool for not only enumerating and visualising polyominoes, but also for creating and solving puzzles in 0-4 dimensions, where polyominoes are used as pieces.

Nature is beautiful and complex, so it is not surprising to see so many attempts at mimicking nature when looking for a solution to a problem. Artificial neural networks have been successfully implemented to interpret images and other signals.

Evolutionary and Genetic Programming is using the principals of biological evolution to find a solution to a problem. A population of genetic code evolves through generations of reproduction and mutation until an individual is produced that is particularly fit for the problem at hand.

Gilgamesh presents a study of Evolutionary Programming using function trains as chromosomes and isolates to parallelise the evolution of the perfect train.

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

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

In this workshop we will import and export various forms of data encoded in text files and process their content; along the way there'll be tips and tricks and a few interesting diversions. Then we will look in-depth at importing and exporting data in native Excel (.xls and .xlsx) files

In this workshop you will learn about tools for starting and managing multiple processes.

Keywords: Conga, APLProcess, RPCServer, Futures and Isolates, Windows Services and UNIX daemons.

The gurus are back with another round of tips and tricks aimed at making your code run faster – with special focus on features recently added to Dyalog.

Bring your own data to an introduction to SharpPlot and SharpLeaf, the graphics and publication tools that are included with Dyalog on all platforms.

A review of the new primitive language features of Dyalog version 16.0 by the people who designed and implemented many of them.

This workshop will take you from zero to a completely working Co-dfns compiler installation, show you how to use the compiler, how to optimise your own programs, how to debug Co-dfns performance and execution errors, how to understand the process of running APL programs on the GPU and how to get some extra flash out of your code.

Bring your own code to the workshop if you would like to experiment with running it on the GPU – we'll have a number of example programs to work with, but we also want to provide space for anyone who wants to make their own code run fast.

How do you build an APL-based web application?

In this workshop, Brian and Michael present the design and implementation of two production MiServer applications – TryAPL.org and the Dyalog Event Registration System.

Topics that will be covered include (but are not limited to):

• Scalability using distributed processing
• Using N-tiered architecture separating user interface, business logic, and database access
• Interfacing with 3rd party web services (for example, payment processors)
• Managing user state and sessions
• Consistent and Responsive Look and Feel
• Deployment and Continuous Integration for High Availability

NOTE: This workshop focuses on high level design and implementation. Brian and Michael do not plan to cover the basics of MiServer – members of the APL Tools Group will be available through the week to discuss MiServer and any other APL Tools related questions.

Bring your own small application and at the end of this workshop you should have it up and running under Amazon Web Services and/or Microsoft Azure. Includes an introduction to running under Linux for Windows users, RIDE, and a few words about service authentication using certificates.

Join us for a light-hearted but deadly serious session of code golf – the art of writing the shortest code possible. Our problems are chosen to encourage use of recently added language features. You will exercise your own skills and collaborate with the entire group on the challenges posed. After an introduction to the code golf community, you may find yourself spending more time in it than your manager might like!

An informal discussion about how mobile development with Dyalog could be done. Starting from last year's "Airfix" model, John leads a conversation around what's good, what's bad, and where we want to be.