Dyalog Ltd's CEO opens the user meeting.

Morten presents his vision of the future, including: challenges facing customers, new platforms and ways of deploying applications, and the future of user interfaces.

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 APL Tools Group has been busy developing tools that make it easier for Dyalog users to build and deploy their applications. In this presentation, members of the Tools Group will present the latest developments, including MiServer 3.0 and tools to provide and consume RESTful web services. Brian, Dan and Adám will discuss the availability of APL tools on GitHub and how you can contribute to the tools libraries and will then take a look at the tools work planned for the coming months. During the question and answer segment at the end of the presentation, you are encouraged to share your thoughts on the tools you need.

vecdb is a simple "columnar database": each column in the database is stored in a single memory-mapped file. It is written in (and for) Dyalog APL as a tool on which to base new applications that need to generate and query very large amounts of data and do a large number of high performance reads, but do not need a full set of RDBMS features.

New operators:

• at – another attempt at a merge/fusion operator
• tile – AKA tessellation, moving window, stencil code

New functions:

• where – ⍸⍵ are indices where Boolean array ⍵ are 1
• interval index – sorted ⍺ partitions the domain into intervals; ⍺⍸⍵ are the indices of the interval for each cell of ⍵.

It is very satisfying when one is able to reuse existing fragments of code. John has taken fragments of varying size from the Dyalog "kit of parts" and combined them into something new and exciting...

Roger and Jay will recap the most important performance work that went into Dyalog version 15.0, and then lift the veil on work that is targeting Dyalog version 16.0. This is a condensed version of the SA4 workshop on Compiler and Performance Features.

Bjørn and Morten introduce version 3 of the Web API known as Conga. In addition to improved performance and scalability driven by clients with thousands of simultaneous users, very significant new functionality is on the way. Keywords: UDP, direct HTTP support, Web Sockets.

Morten and Nick review the state of the RIDE project and examine the consequences of its new status as an open source project.

Andy will yet again dip his toes into the pool of lesser-known and less well advertised features of Dyalog...and he might even mention one or two that are coming along in 16.0. Unlike last year, he hopes this year to start and end with dry feet!

There are three grand prize winners in the eighth annual International APL Programming Contest, one in each category. All three are here to describe their experiences with APL/Dyalog and tell us how they managed to win.

There are a growing number of Open Source platforms for building Artificial Neural Networks (ANNs), but few really support the exploratory programming style that APLers love so well.

In this brief overview Romilly takes a look at the core algorithms used in ANNs and explains why he believes that Dyalog APL is an ideal environment for exploration.

Tomas demonstrates the multi-player version of the boating simulator Stormwind. This version is intended to behave like an MMO game, bringing together a multitude of participants from diverse geographical locations into a common virtual world. The solution involves a root server, game servers and peer-to-peer communication. Currently, an integration of Windows sockets and APL is used to manage the data transmission. He will explain the architecture and cover some practical issues, starting with synchronizing computer time and internet time servers, before introducing the Hexapod motion platform. Can you take on the challenge and the angry elements?!

In the beginning there was a young gullible student at a technical university, and a course with an inviting topic "A Programming Language". That was over 35 years ago.

Instead of a bright future in the nuclear industry, the chain reaction ignited by the explosion in Chernobyl brought another secure looking career – mainframes and banking. Then something unexpected happened…the Soviet Union collapsed, Finland's team started winning (some) ice hockey tournaments and mainframe APL2 changed to workstation Dyalog APL. The bank vanished, though.

Veli-Matti relates his story, that of an APL2 person slowly adapting to Dyalog APL, and highlights the features that he has found to be crucial, interesting or just annoying during and since his transition.

With the advent of a XAML/C# compiler to HTML5/CSS/JavaScript, it is now possible to build client/app side GUIs using pure XAML and automatically link them to groups of namespaces in APL using a user command. All the APLer needs to think about is some XAML; behind the scenes, pure APL data using Web Sockets gives it a responsive feel.

In this presentation Michael outlines the philosophy and shows a prototype of a simple working example.

The Co-dfns compiler is now showing improved performance on GPUs for a variety of test applications. Aaron reports on the performance improvements available through using the compiler and demonstrates the workflow for migrating applications to utilize the compiler. He also provides information on the current features supported in the compiler and how to track future releases.

Martin presents a compiler infrastructure for compiling a subset of APL, written in the style of co-dfns, into performance efficient GPU programs. He demonstrates that, for a number of benchmarks, the generated GPU programs runs in the order of 100x faster than compiled generated C code running on similarly-priced CPU hardware. He will reflect on the programmer's experience with programming in the supported, statically typeable, subset of APL and the fact that the compiler infrastructure does not necessarily embrace the use of idioms before inviting APL programmers to reproduce the obtained results; he will also invite experienced APL programmers to improve on the implementation of the Dyalog versions of the benchmarks and to provide feedback about which additional APL features should be considered indispensable.

The compiler infrastructure compiles APL programs into programs written in a typed array intermediate language (called TAIL), which are then recompiled into programs written in the functional array programming language, Futhark. The Futhark compiler performs a number of GPU-critical optimisations before outputting GPU-optimised OpenCL code, which will be shown to integrate well with host-executed implementations of high-level languages, such as Python or even an APL interpreter.

Computation on large Boolean arrays is becoming more prevalent, due to applications such as cryptography, data compression and imaging. The advent of GPUs and bit-oriented vector extensions for microprocessors presents opportunities for significant performance improvements in such Boolean-dominated applications.

Since APL is one of the few computer languages that supports dense (one bit per element) Boolean arrays as first-class objects, it has naturally attracted interest in optimizations for improving the performance of Boolean array operations.

Robert presents some of the SIMD Boolean-related optimizations that have appeared in APL implementations, and suggests ways in which those optimizations might be exploited using contemporary hardware.

Given the new tools that have appeared in recent years, how these days do you set about building an application from scratch? Do workspaces even come into it? Kai and Stephen attempt to answer these questions in a new book, The Dyalog Cookbook, an open-source project on GitHub, using their combined experience as developers and the tools in the APLTree library. The book is particularly written for domain-expert developers looking to turn useful software into a shippable maintained product.

In recent years Markdown has become ubiquitous: Stackflow, Git, Sourgeforge, Trello…all the big boys are using it as a writing format, often unnoticed. This is a short introduction to Markdown itself, whether there is a standard, what its pitfalls are and why it is great.

MarkAPL is a class written in Dyalog that converts Markdown into HTML5. Examples include automated documentation generation (ADOC), how to use MarkAPL in MiServer and how a Markdown file can be converted into an HTML document with a Dyalog user command.

They say that a picture is worth a thousand words. Certainly, most human beings find an interactive chart more intuitive than a table with a thousand numeric rows. Sofia, our portfolio management system for institutional investors, is capable of producing large quantities of numbers. A short while ago we decided that the time was ripe for it to start drawing pictures to better show the beauty of those numbers. Instead of trying to compete with dedicated reporting tools, we thought we would play to our strengths if we concentrated on a handful of tailored charts. We identified a few areas where the introduction of charts would improve significantly the user experience and set off on their implementation. The first step was the choice of the tools and so we went fishing and caught in our net D3.js, a very versatile open source JavaScript library for manipulating web documents based on data. All that remained was to learn how to use it and how to seamlessly integrate it in a traditional Windows-based APL application. I will show how that was done.

Over the past academic school year, Stephen has used TamStat in his Statistics and Management Science classes at the University of Scranton. He will discuss some of the issues that came up during the past year and demonstrate some of the new features that were developed as a result of student input. These include expression builders for probability distributions, hypothesis testing and regression.

Alex discusses the current (2016) APL scene and shares the things he encountered as a beginner while developing an application first in J and then in APL. He answers the following questions, all of which he asked when learning APL:

• What interpreters are available?
• What do you mean no control structures?
• How do you set up the keyboard?
• Do arrays start at zero or one? (spoiler alert: it doesn't matter!)
• You found out what base-value does?! And it has a practical use?
• APL...and images?

APL and Its Milieu in the 1970s: How APL developed as a computer language in its formative years, and the environment in which it thrived.

A personal view of the growth of APL through its datatypes. Some of the major datatype ideas of the last 50 years include:

• Booleans
• Nested arrays
• Unicode characters
• Arithmetic Progression Arrays (extending APVs)
• Multi-precision Integer/Rational numbers (extending 64-bit Ints)
• Multi-precision Floating Point numbers (extending 64-bit Floats)
• Hypercomplex (complex, quaternion and octonion) numbers which provide a natural extension of the real (one-dimensional) numbers to two-, four-, and eight-dimensions. The coefficients of these numbers are all either 64-bit integers or floats, or multi-precision integer/rational or float (twelve new datatypes altogether).
• Shared variables
• Namespaces
• Object oriented programming

In short, although the major leaps in the last 50 years of APL are often described in terms of language ideas (new functions and operators) and implementation improvements (smaller, faster), Bob sees the most important driving force as new datatypes.

The I.P. Sharp Associates APL timesharing system was already operational when Robert was hired at IPSA in early 1971; he tells the tale of how he became part of the APL Development Group, how the Group became known as The Zoo and relates some of the development work that was done there in the early 1970s.

It's 33 years since Dyalog version 1.0 went on sale and, as any hobbit can tell you, 33 means coming of age and reflecting on how you got to where you are now. In this spirit, Stephen interviews Geoff and John, two of the original team, about some of the challenges that faced the initial implementation of Dyalog and how some of the choices made decades ago are still reflected in the product to this day.

Kx's languages k and q have been around since the early 90s and have been continually evolving during that time. Although Arthur Whitney's early work was with APL, many choices were made over the years that took these languages further and further away from the APL world, some of them with far-reaching ramifications for the language and implementation that only really became apparent years later. Simon will highlight a few of the differences and their consequences that he finds interesting, and hopefully make you look at some of the things you take for granted in a new light. He's said that he’ll try not to be snarky about ⎕IO!

SimCorp Dimension is an integrated front-to-back system for large investment managers around the world. Dimension has been developed over more than 20 years and includes a wealth of advanced features within the front office, middle office and back office operations. Being an integrated enterprise system is a core value of Dimension. More than 400 people work on developing Dimension on a daily basis. APL has been part of the technology stack from the start. Today, other technologies have been added including C# and OCaml. Niels' presentation will illustrate the use of APL in Dimension and how APL supports product development. He will also look forward to how APL may evolve in the future to support a product like Dimension.

Dr Jaffe is a chemical engineer with a distinguished career and the co‑inventor of SOL.

Composition Based Modelling represents a significant improvement in the approach to building kinetic models of petroleum systems. The activity is divided into three areas:

• The Model of Composition (High Detail Hydrocarbon Analysis – aka HDHA)
• Describing the chemistry of petroleum mixtures (Structure Oriented Lumping – aka SOL)
• Model Delivery Technology

Composition Based Models have been built for all major petroleum conversion processes including reforming, fluid catalytic cracking, hydrocracking, catalytic hydro‑desulphurisation and lubricant manufacture. They are presented to the user through a uniform architecture on a PC platform and are in use worldwide to optimise refinery operation. In the last few years they have seen the greatest value for refinery feed crude selection.

Numerous analytical methods, collectively known as HDHA, enable the composition of petroleum to be represented as a consistent set of over 5,000 molecular species. Physical, chemical and performance properties of petroleum are calculated using composition-based correlations and are used to "property balance" the HDHA analyses.

SOL describes the reactions of hydrocarbon mixtures. Using SOL, individual hydrocarbon molecules are represented as vectors of incremental structural features. These vectors provide a convenient framework to construct rule-based reaction networks of arbitrary size and complexity. Models using SOL typically follow the conversion of molecular species through more than 100,000 elementary reaction steps.

Dyalog APL is used in every aspect of the project. The petroleum composition is analysed and organised with APL. SOL is entirely APL based, and the reactor models are in Fortran generated under program control by APL. Finally, the user interface is 100% Dyalog APL.

Building real businesses on APL platforms. Keys to success and implications for the future relevance for the next generation of software architects.

An overview of some of the key areas where APL got our research department noticed in the chocolate industry, and a particular look at the (rather hard) problem of turning a recipe into an ingredients list, where the recipe has much re-use of finished (and semi-finished) materials back in earlier stages. A simple demo version of the algorithm will be available to take away (but I still can't give you the recipe for Kit Kat – they'd have to kill all of us!).

APL notation is elegant and mathematically appealing to the considerable extent that it's consistent, general, concise, and the rules are few. Especially during the preliminary, the design, stage of my Mixture Solution program (an algorithm for an important class of forensic DNA situtions) good notation was vital. All the experts (myself included) understood that there is an essential complication to DNA mixture analysis that makes a purely analytical algorithm impractically slow. Consequently all the existing programs necessarily used Monte Carlo sampling methods. But in the course of months trying to think clearly why that had to be so, a series of insights dawned on me and eventually the realization that it is not so. The "essential complication" disappears if you pile your logs in the right order.

Each new idea had to be written down – otherwise the next day you doubt yourself, and conclude you were probably confused. APL proved to be good for taking notes. Concise and explicit notes made it easy to review the steps and be clear that the simplifying discovery was correct. Tool of thought.

Good notation though is only part of a great programming tool. Implementation is equally important, and here Dyalog APL has great strengths but in some ways it's clumsy. One example is the horrifying clunkiness of typing a function name into the session log in order to open it for editing. Of course there are plenty of delights – a simple APL defined operator implements the mathematical operator of conjugation; some bit of code that I expected to be inefficient turns out to be blindingly fast (tricky Roger); a bit of code that required special-casing the empty case in STSC's APL just plain works in Dyalog.

So I'll temper my praise with criticism – fine whining.

An introduction to the early years of APL. The different applications of APL are described in the context of changing conditions through the last 50 years. The evolution of APL is outlined and the current state established. In summary, this is a story of computing driven by end-users.

APL veteran Romilly Cocking takes a lighthearted look at how the world of IT has developed since he wrote his first program in 1958.

The APL community has discussed, deliberated, debated, conversed, cogitated, pondered, reflected and considered how we should get our word out to the various communities and raise our profile. In more recent times we have seen the emergence of a number of groups that meet regularly and prove that there are those out there who want more. These groups are now starting to market themselves properly; getting their presence known, creating a brand, an identity and publishing regularly. As a result, interest and awareness is growing.

The job of selling ourselves will never be complete and there is still much to do, but we get better.

Paul discusses what is happening with some of the groups he is familiar with; what are they doing, when are they doing it and how do they sell themselves...Oh and of course, does any of this make a difference?

Finally, he will introduce a touch of your colour for you to discuss, deliberate and cogitate...

Roberto is a maths teacher and in his view one of the best problem-solving techniques is arriving at a solution to a problem by means of images. Can a mathematical language as concise and abstract as APL help us to give an image to the problems? He discusses this with four of his students and an illustrator.

The Dyalog Cookbook sets out how to build in Dyalog an application that can be shared or sold commercially.

This workshop reviews the opening chapters, identifying issues and exploring solutions. The focus will be on understanding the problems to be solved in packaging an application for distribution, and the solutions on offer.

Topics include:

• How to structure the workspace
• Exporting a stand-alone executable
• Logging events
• Handling errors
• Writing, using, and maintaining tests
• Providing online help
• Writing an installer
• Managing source code

This workshop continues in session SP1, which focuses on getting hands on experience with the tools and scripts of the book. If you are already familiar with the topics of the book and want only to acquaint yourself with its tools, then workshop SP1 can be attended without attending workshop SA1.

In the immortal words of Pete Donnelly, "Programming with threads requires care". If all goes well, you will leave this workshop with a good idea of how to use threads safely and efficiently to make your application more responsive and increase performance. The workshop will cover the use of tokens for thread synchronisation and show how threading can be used to take full advantage of futures and isolates.

After a long gestation period, version 3.0 of MiServer has reached a level of usability where we think it is ready for the big time. This pair of workshops, split across Sunday and Thursday, will walk through implementation principles and details of one of the first commercial applications built on the new platform. In addition to demonstrating the implementation details of a sophisticated user interface with web-based reporting and graphics, you will learn how to implement a scalable and secure multi-user application with self-enrolment of new users using open source tools that are available to all Dyalog users.

This workshop spans two sessions; the second session is TP3.

Recent versions of Dyalog APL include a number of performance enhancements, both to core interpreter algorithms and the optimised byte code execution engine controlled by 400⌶. In this workshop, Roger and Jay will show how to take advantage of the new features; they will also cover some of the most important new language features that can be used to improve the performance of your application.

This workshop spans two sessions; the first session was SA1. It is recommended that attendees of this session who are not already acquainted with the topics of the Dyalog Cookbook also attend the first session.

The Dyalog Cookbook sets out how to build in Dyalog an application that can be shared or sold commercially. This workshop focuses on getting hands on experience with the tools and scripts of the book.

Artificial Neural Networks (ANNs) help to power Google, Facebook and Amazon. ANN building blocks carry out simple operations on numeric arrays, so APL is a natural language for ANN implementation. In this workshop you will learn how you can build your own Neural Networks to do tasks like image recognition and text analysis.

(If you attend this workshop, then session TP2 is also recommended.)

TamStat is a software package, written in Dyalog APL, that allows the user to perform statistical analysis by taking advantage of arrays, functions, operators and namespaces. In this tutorial we will discuss the four basic types of functions used in statistics: measurements, distributions, relational and logical functions. We will then introduce several operators which can be used with these functions to perform statistical analysis:

• Discrete and continuous probability distributions using the probability, criticalValue and theoretical operators
• Inferential statistics using the confInt, sampleSize and hypothesis operators
• Simulation using the randomVariable operator

In addition, we will discuss the following advanced topics on request: tests for goodness of fit, tests of independence, regression and ANOVA.

APL will be 50 years old in November 2016 (50 years from 1966-11-27 15.53.58, to be exact), and it remains unsurpassed in manifesting Kenneth E. Iverson's five important characteristics of notation:

• ease of expression
• suggestivity
• subordination of detail
• economy
• amenability to proof

These characteristics are demonstrated by working through 16 APL expressions. The material is approachable for beginners and yet thought-provoking for experts.

One of the 16 expressions is a fast computation of the partition function without use of the Hardy-Ramanujan (1918) results.

Version 15.0 of Dyalog APL is full of new features aimed at making you more productive, including new system functions for file and folder management (which work identically on all platforms), support for source code in Unicode text files, and numerous performance features such as "hashed" arrays for repeated fast lookups. Version 15.0 comes with RIDE 3.0, a portable development tool for all Dyalog platforms. In this workshop, Dan and Adám will examine all these new features in detail.

This workshop will use code from the ANN workshop (SP2) and additional examples to take you through accelerating your Dyalog applications using the Co-dfns compiler. All steps are covered, from initial investigation to final optimisation. Guidance on the use of the compiler will be provided and you will be shown how to get the most from it in your applications.

(You do not need to have attended session SP2 to attend this workshop.)

This workshop spans two sessions; the first session was SA3. It is recommended that attendees of this session also attend the first session.

After a long gestation period, version 3.0 of MiServer has reached a level of usability where we think it is ready for the big time. This pair of workshops, split across Sunday and Thursday, will walk through implementation principles and details of one of the first commercial applications built on the new platform. In addition to demonstrating the implementation details of a sophisticated user interface with web-based reporting and graphics, you will learn how to implement a scalable and secure multi-user application with self-enrolment of new users using open source tools that are available to all Dyalog users.

Dyalog APL and its interfaces give you access to a wide variety of visualisation tools. You can use the built-in Chart Wizard based on SharpPlot, write APL code to embed charts in publishable documents using SharpLeaf, call R or Excel to create charts, use WPF data binding to display data using tools implemented on the Microsoft.NET framework, or use MiServer to drive JavaScript based visualisation packages. In this workshop, we will show you how to use all of these techniques – and perhaps one or two more!