Dyalog ’12

APL's vector-oriented programming model appears well suited for execution on SIMD-style parallel hardware, such as GPGPUs. However, some cross-element operations, such as scan or compress, appear inherently sequential because of cumulative data dependencies and even nominally independent computations, such as applying a complex (perhaps even recursive) function to each element of a vector, appear to require general MIMD-style parallelism, precluding efficient implementation on throughput-oriented, data-parallel hardware. This talk will sketch how a simple but non-trivial data-parallel algorithm for computing (nested) scans of associative functions can serve as the cornerstone of efficient, data-parallel implementations of a wide variety of seemingly non-uniform computations in array-oriented languages – obviously including, but not limited to APL.

Dyalog version 13.2 will include an Array Editor that supports editing character, numeric and nested arrays. The Array Editor display of arrays is similar to the output of the DISPLAY function. However, unlike DISPLAY, the Array Editor supports modifying the data. Data can be over-typed and items can also be rearranged using copy, paste and APL primitives. This presentation will include demonstrations of the Array Editor and some discussion of future enhancements.

FiRe stands for "Find and Replace". FiRe offers plenty of useful features making it easy to refine a search until you get exactly what you want. FiRe's main feature, however, is the "Replace" part, which offers precise control over what is going to be replaced. FiRe is certainly helpful for any kind of programming task but is particularly useful when dealing with legacy code: improving code quality in a legacy system almost always implies search and replace, and FiRe makes this significantly easier.

Fighting the growing chaos in a growing company.

Two naïve and simple questions...The national education curriculum of the nursing education prescribes 210 ECTS points (European Credit Transfer System) over 3.5 years of full time study. As the newly employed Director of Nursing Studies at The Deaconess University College I asked myself the questions:

1. Do we actually provide each student with 12 lessons a week in the specified subjects?
2. 2. How much does each lecturer lecture?

This was indeed more difficult to investigate than I ever imagined, but Dyalog APL was a great help and I got great insight into data and information needs.

This presentation will illustrate some techniques used in SimCorp Dimension for representing sparse data, including the motivation for not using native Dyalog structures. The presentation will focus on storage methods, typical operations and performance and space impact for the application using sparse data.

Actuarial applications in the field of life insurances cover several business problems such as tariff and rate calculation, preparation of balance sheets or product development. In this presentation we would like to give an overview about applications and solutions in this area which are based on APL programming or include APL parts. We will provide a short introduction into the maths of a life insurance company along with the implementation of the basic functions in APL. We will highlight APL's strength and best fitness for those kind of tasks.

In commercial APL applications, we frequently encounter I/O functions that slow down the business applications in ways that are not obvious to the casual programmer. Similarly, many programmers do not know that they are not using the advanced computational functions properly, causing WS FULL, LIMIT ERROR and stopping or slowing down the entire business application. In this presentation, for the I/O optimization, we will take a look at how to optimize the initialization of a component file that has numeric data and how to simplify the contents of a native file that contains numeric data in character format. For the computational optimization, we will examine how to use (or avoid) the outer product, the inner product and the match functions to speed up APL application functions.

This will be a remote presentation from Jersey City, NJ.

I coined the term "Forensic mathematics" for the application of mathematical principles to evidence, in practice to problems and ideas in DNA identification. Inventing a term like this comes with certain prerogatives, including specifying the principles – the Likelihood Ratio is thereby the central concept of forensic mathematics – and of course product endorsements. Of all the tools of forensic evidence, DNA is most suited and perhaps uniquely suited to mathematical treatment. Unlike fingerprinting, its behavior nearly conforms to a tractable model and is quantifiable. Like fingerprinting it is individualistic, but in addition the inherited nature of DNA makes it useful for identification – solving crimes – via relationships.

APL has been my tool for 30 years of forensic genetic programming, mostly my software product DNA-VIEW which is internationally widely used by crime and some other laboratories. I'll review some basics of DNA genetics, a fascinating and surprisingly digital (not statistical, not analog) subject, and discuss a couple of program features. The kinship module generalizes the paternity testing question and has found wide application including in disaster zones for body identification, for inheritance and immigration, and for generating stories, some of which I would like to share.

The forensic mathematician perspective on human nature may fall short of bartender's and prostitute's, but still has a few offerings over the years. Potential illegitimate heirs and their attitudes – a common story. Suspiciousness about DNA results based on opaque science – another.

And an ambivalent story of greed: Larry Hillblom, the wealthy "H" of DHL, disappeared leaving several potential heirs and no available reference DNA. Nonetheless with a slightly novel way of thinking, DNA was able to prove the childrens' case.

In software implementations of double-key cryptography one needs to be able to perform arithmetic computations quickly on multi-digit numbers whose length exceeds that of traditional floating point numbers; numbers with 150-200 decimal places.

Multiplication (including modular multiplication) takes most of the computational time in operations of asymmetric cryptography such as generation and distribution of a secret key, encryption and decryption of information, stacking and verifying a digital signature, etc.

In this presentation we consider how APL can be used to determine the most appropriate optimisation of multi-digit multiplication operations. The analysis of the complexity of the used algorithms of multiplication of such numbers shows that, with development of cryptographic methods of information protection with a public key, one must have a library of programs that implement various algorithms for fast multiplication – every one of which has its own area of effective application depending on the range of meaning of N (word length), computation model, hardware or software implementation. This increases the performance of double-key cryptography systems.

It is shown in comparison with other languages that APL is one of the best to model the multiplication algorithms of large numbers based on the fast orthogonal transforms (like fast Fourier transforms (FFT), fast Walsh transforms (FWT), etc.), which reduce the number of needed calculations by one or two orders. APL gives a clear picture to analyse the multi-digit algorithms and find reserves of optimization to increase performance of existing algorithms several times over.

It is known that the efficiency of multiplication of large numbers depends on the number of multiplication of single precision. The main attention is paid to APL as a tool to reduce the total number of multiplication operations.

It will be shown how APL can be used to describe parallel algorithms before implementing them using CUDA C on NVIDIA GPU, thereby reducing total time spent on development.

Over the past 2 or even 3 years, Optima together with Dyalog have been talking about introducing new people into the APL community, teaching them APL and solving all of the World's problems with a single line of code. As of August 2012 we are pleased to be able to say that we have 3 new apprentices, funded by both companies, who are now on that path of learning and enlightenment.

This presentation aims to give a little bit more insight into the process we have undertaken and also give you the ability to meet with all 3 apprentices and see what they think of it all.

Time permitting we will explore possible extensions to our initiative and see how other companies can also get involved.

See how they run...

We will describe two cases where we have migrated large systems from IBM mainframe APL2 to Dyalog APL Windows using two different approaches. First we will describe the systems and explain why this migration was done. We continue by describing the architecture and how we have solved the user interface (3270) and data storage. We will then describe language incompatibility problems, code and data transfer, technical components needed, tools for automatic code migration and diagnostics as well as testing. How integrations with other systems are migrated will be described. Finally we will cover the problem of migrating a living system constantly being changed and updated.

I had a problem. APL solved it. I was hooked. I showed others what I could do and my career began. I think the best way to teach students APL is:

1. Find their problem
2. Teach them how APL solves it
3. Help them share with others and their careers begin

I want to build a community of contributors that provides ideas and code to interest and teach new APLers. Creating and playing educational games are fun and facilitate learning. In the schools the maths/science/business curriculum needs a major computer upgrade. Computer graphical tools can make mathematics come alive and facilitate conceptual learning. With the help of APL real world problems can now be tackled by students. Creating educational games/tools on the internet is a fantastic way to share them and attract new users.

In a community, users at different levels learn from the level above and teach to the level below. If we help each other everyone benefits. I am here to learn and to give. How about joining me?

Now I want to share some examples of what I have been doing with you and hear your suggestions for going forward.

We are all very aware of how important it is to write efficient code and generally we write our core processing algorithms to operate as quickly as possible. What is often ignored is how applications, even well written ones, perform across a computer network.

This presentation aims to shows some of the performance pitfalls we can commonly encounter when operating across networks of unknown or unstable bandwidth.

At the end of the presentation the audience will be invited to share their experiences and strategies for avoiding some of these problems.

The execution time of computationally intensive applications is usually dominated by time spent in a few kernel functions. Naive execution, common practice in interpretive array-language environments, such as APL or J, can exacerbate the performance impact of these factors, often by orders of magnitude.

In our talk, we show that the state-of-the-art array language compilation can often bring those kernels to the same level of performance as good-quality hand-coded C. In addition, the code generated by APEX/SaC automatically preserves or increases the parallelism of APL applications, offering significantly improved performance on multi-core systems with no application modifications. Finally, SaC's automatic generation of GPU-based code provides even more dramatic performance gains for some classes of array-based applications.

The speed-ups available through use of such tools varies, depending on application characteristics such as array size and the target system. To give users an intuitive feel for how much improvement their own applications could gain from use of compiled kernels, we present several case studies of applications with different array shape characteristics, along with the speedups we have attained thus far:

• The baby bear, dominated by operations on scalars, is exemplified by the Floyd-Warshall graph theory algorithm.
• The mama bear, dominated by operations on small arrays, is typified by dynamic programming algorithms and by numerically intense computations on complex numbers.
• The papa bear, dominated by operations on large arrays, is typified by acoustic signal processing and geophysics benchmarks.

Our talk includes a brief presentation of the various methods by which we achieve those speedups on each class of array size.

Riskflow's APL software for Cashflow Management was developed with banks and major corporates as clients. These applications were developed using APL2000's version of APL. Having identified the need for a much simpler application for use by individuals and SMEs, code was extracted from this application, converted into Dyalog APL and made available in DLL format for development of a Cashflow App on Android devices. This presentation will illustrate the App as well as details of the APL development that was required to incorporate the computational engine into the App architecture.

Hayato is the winner of the fourth edition of the International APL Programming Contest. Following the prize ceremony, he will tell us how he learned APL well enough to win the competition.