Abstracts for Dyalog Sessions Monday 13th September

P01 Monday 13 September 15:30 – 16:30

Morten Kromberg, Jonathan Manktelow, John Scholes (Dyalog Ltd.): APL# - An APL for Microsoft.Net, Mono, SilverLight and MoonLight

Microsoft.Net is a software platform which is based on a component that Microsoft has named the Common Language Runtime (CLR). As the name suggests, the CLR was designed in co-operation with a diverse group of language implementers, and the services that it provides are intended to be “language agnostic”. The CLR provides an application virtual machine with memory management, exception handling and other services which significantly simplify the task of implementing new programming languages. It also facilitates communication between modules written in different languages by forcing everyone to use a single memory manager and type system.

The services provided by the CLR make it easy to implement a new programming language, and the ability to inter-operate with solutions written in other languages is very attractive to application developers. However, taking full advantage of the shared type system and related services which not only allows data to be exchanged between programming languages, but also allows the application stack to consist of functions written in different programming languages, forces us to abandon some of the most central dogma of “classic” APL interpreters:

• The notion that APL only has two data types: numbers and characters,
• That arguments are always passed “by value”, and that
• User-defined names are global by default, and local variables are visible to all sub-functions

The paper discusses the design of APL# (pronounced APL Sharp), a new dialect of APL designed with object oriented / language-agnostic platforms in mind, using Microsoft.NET as the initial target platform. Although portability of old APL code to APL# is an important consideration, the fact that complete upwards compatibility with “classic” APL is not achievable allowed us to make an attempt to “tidy up” a few other aspects of APL. The goal has been to produce a language which is as powerful a “Tool of Thought” as classic APL and APL2, at the same time as it should feel significantly more acceptable to a “software engineer”.

WS1 – Monday 13 September 14:30 – 16:30:

Brian Becker (Blue Dolphin Solutions): APL and Web Services
What is a Web Service?

The W3C defines a web service as “a software system designed to support interoperable machine-to-machine interaction over a network. It has an interface described in a machine-processable format (specifically Web Services Description Language WSDL). Other systems interact with the web service in a manner prescribed by its description using SOAP messages, typically conveyed using HTTP with an XML serialization in conjunction with other web-related standards.”

Web Services are modular — a Web Service is self-contained and self-describing. Everything necessary to invoke a Web Service and interpret its results is a part of the Web Service itself.
Web Services are accessed via standard protocols — Web Services can be accessed over the Internet or an intranet using a web browser or other client.

Web Services are platform independent — Web Service providers and requestors can communicate effectively without any knowledge of the platform that either is using.

Web Services share data, business logic, or processes — Web Services can deliver a wide range of function from very simple a query/response service to very complicated business processes.%
Introducing SAWS — the Stand Alone Web Service framework

SAWS is a tool developed for Dyalog APL version 12.1. SAWS makes it possible for APL programmers to integrate Web Services developed by others into their APL applications. SAWS also enables APL programmers to make the functionality of their applications available to others over the Internet. Best of all, SAWS accomplishes this without forcing the APL programmer to become an expert in the underlying protocols and technologies necessary to implement or use Web Services. SAWS can help transform your legacy APL application into a web-enabled service.

In this Workshop we will:

• Present a brief overview of Web Services and their underlying protocols.
• Learn how to call third party Web Services to use their results in an APL application.
• Develop a simple web service using SAWS which can be invoked from SAWS, a web browser, or other client.

A non-commercial license copy of Dyalog APL 12.1 will be provided for those who need it.

Dyalog Vendor Session – Monday 13 September 14:30 – 16:30:

Dyalog will run a Workshop, a Tutorial or conduct a discussion on specific issues on request.

Abstracts for Dyalog Sessions Tuesday 14th September

V11 Tuesday 14 September 09:00 -10:00:

John Daintree (Dyalog Ltd.): Taking APL for a RIDE

The Dyalog Remote Integrated Development Environment (RIDE) is a new graphical development environment for all versions of Dyalog APL on all platforms - from Windows Mobile to the largest AIX "midframes" (and in the future also the new APL# interpreter). The RIDE allows you to connect to Dyalog session from almost any web browser on any client platform. The RIDE is a cornerstone of a strategy which is intended to take the portability of applications written in Dyalog APL “to the next level”.

V12 Tuesday 14 September 10:00 – 11:00:

Morten Kromberg (Dyalog Ltd.): Dyalog Technical Keynote
Morten will review Dyalog APL Version 13.0, which is about to enter “Beta Test”, and talk about APL#, the RIDE, and the rest of Dyalog's "Road Map" for 2011 and beyond.

Dyalog Vendor Forum Tuesday 13:15 – 14:15:

Gitte Christensen (Dyalog Ltd.)– Challenges of an APL Vendor

P18 – Tuesday 14 September 14:30 -15:30:

Richard Smith (Dyalog Ltd.): Damage Resistant Component Files Using Journaling and Other Techniques

Dyalog component files are maintained by the interpreter using indices and other high-level structures within an underlying “native” file, which is often shared by many users on multi-user operating systems and networks. Each component file update (e.g FAPPEND or FREPLACE) requires a number of updates to different parts of this underlying file; once started, and until the process is complete, the file may be in an inconsistent state. The series of updates must appear to be atomic to other users and locks are used to ensure that files are not accessed by other users when the file state is inconsistent.

Component files have worked in this way — and generally served APL well — for many years. But many APL users have also experienced damaged component files — ones which are impossible to read or update, which crash the interpreter or, worst of all, present no ill effects but return corrupt values. Almost always the cause of such damage will have been the interruption of a file update (perhaps due to a kill signal to the application making the update, or a network failure), leaving the file state inconsistent.

Dyalog APL has addressed this problem in two stages, resulting in component files which are highly robust and resilient to damage. The first stage protected the file from damage caused by interrupting an application during an update, and introduced journaling to the process. The second stage dealt with the damage which results from the loss of file caches following a catastrophic event such as a power failure or operating system crash during an update, and extended journaling to include cache flushing and checksums.

In addition to the technical details of component file structure, the critical points during an update sequence and the methods used by Dyalog to protect and repair files, this paper will also discuss migration of existing files and compatibility between Dyalog releases, and consider the benefits of journaling versus the additional processing involved - so that the best journaling options may be selected for any particular application.

TU3 Tuesday 14:30 – 16:30:

Dan Baronet (Dyalog Ltd.): User Commands in Dyalog APL

User Commands (UCMDs) are similar to system commands, except that they are written in APL. They provide a way to make tools and utilities available at all times — without requiring them to be copied into the active workspace before use. The user command processor also provides a mechanism for on line help, and encourages developers of UCMDs to provide consistent behavior across different commands.

Dyalog introduced User Commands with version 12.1. In the Dyalog implementation, the source for a UCMD is a single Unicode text file, which means that UCMDs can very easily be shared. As soon as the text file defining a UCMD is copied into the UCMD folder, the user command can be called from the APL session — or invoked under program control. It is Dyalog’s hope that the introduction of user commands will lead to much more widespread sharing of development tools in the APL community.

This tutorial will show how to create, debug and modify user commands and how to manage them. It will show how to deal with arguments, options and results. Several examples will be shown, from the very simple to the more complex.

WS3 Tuesday 14 September 14:30 – 16:30:

John Scholes (Dyalog Ltd.): Introduction to D-Functions
Since their introduction in 1996, Dyalog's direct-definition functions (D-fns) have grown from an experimental toy to a notation used to implement large pieces of commercial software. D-fns are not only useful for expressing idioms, but also as a tool of thought for any problem that can benefit from a functional approach (and some would say that covers almost everything). Owing to their functional nature, D-fns also have greater potential for internal optimization, including compilation — and have been selected as the foundation for the new function syntax in the APL# dialect.

The workshop will start with an easy introduction; discuss where the use of D-fns is appropriate; and finish with some fireworks.

P11 – Tuesday 14 September 15:30 – 16:30:

Morten Kromberg, Michael Hughes (Dyalog Ltd.): Parallel Computation Using Peach, Prank and Pouter
One of the challenges currently facing software developers is to take advantage of the parallel hardware that is appearing not only in large data centers, but also on every desktop. APL is an inherently parallel notation, which has the potential to make this relatively easy. At the lowest level, users should be able to expect the APL interpreter to distribute computations optimally across multiple cores, when evaluating expressions like:

     1 2 3 + 4 5 6 × 7 8 9

In fact, achieving this is not as simple as it seems, as there are many bottlenecks in multi-processor machines which mean that efficient use of multiple cores by a “SIMD Interpreter” is a significant challenge. Research also shows that the average number of elements in arrays passed to primitive functions in commercial applications is less than 2, which suggests that parallelism at the level of individual primitive functions is unlikely to help typical applications very much.

At a slightly higher level, APL implementations offer a number of parallel constructs:

• The each operator (¨), which is available in virtually all modern systems
• The rank operator (ö), implemented in SHARP APL and J (and often emulated using user-defined operators in other APL systems)
• The outer product operator (°.), which is available in all systems
• The dot in Dyalog APL: When placed between an array of objects on the left and an expression on the right, dot applies the expression to its right to each of the objects on the left.

Each, rank and dot are different ways to express the application of primitive, derived or user-defined functions in parallel. Unfortunately, because user-defined functions (and some system functions) can have side-effects, APL interpreters cannot know whether it is safe to execute the multiple calls to the function f in expressions like (f¨data), (fö1 data) or (objects.f data) in parallel. The paper describes four experimental user-defined operators named PEach, PRank, POouterP and PDot, each of which allows the user to explicitly declare that an expression is parallelizable.

These models of potential extensions to an APL interpreter are implemented by forking multiple processes which communicate using TCP/IP, and allow us to experiment with the performance characteristics of parallel execution using multiple cores in one or more co-operating machines, and the tuning parameters that may be required to optimize throughput on different hardware configurations. So far, experiments suggest that, although they may require small changes to application code, the use of these operators has the potential to provide significantly more “bang for the buck” than the implementation of fine-grained parallelization in interpreters.

P19 Tuesday 14 September 15:30 – 16:30:

Geoff Streeter (Dyalog Ltd.): Supporting APL keyboards on Linux

Xkb is a keyboard extension for X windows. Linux provides a full implementation of the Xkb extension. It has been used to provide a clean and very usable APL keyboard.
The APL special characters are supplied by this keyboard over and above the characters supplied by the user's normal choice of keyboard.

The work builds on that of ISO9995 and Erik Fortune of Silicon Graphics. It enables a “latching” (active whilst pressed) shift key to access the APL characters without conflict with other uses of the keyboard.

The APL characters are available to any application running under an X server including; word processors, email, terminal emulators, shells …

The X client can be a program running either on the same machine as the X server or on a remote machine anywhere in the world. This keyboard is not Dyalog specific it can be used by any APL, or indeed, non-APL program. However, Dyalog have produced, fully engraved, APL keyboards for US, UK, and Danish users. The APL keyboard produced for Xkb provides the support necessary to use those additional engraved characters in the positions that Dyalog have chosen.

V13 Tuesday 14 September 16:45 – 17:45:

Jay Foad (Dyalog Ltd.): An interpreter for Vanilla Siteswap
Jay is the newest arrival at Dyalog. He secured the job by juggling during the job interview, while talking us through C code which interpreted a "Domain Specific Notation" for juggling known as Vanilla Siteswap (with synchronous + multiplexing extensions). Jay will be presenting his new VS/APL interpreter.

Abstracts for Dyalog Sessions Wednesday 15 September

Dyalog Vendor Session – Wednesday 15 September 09:00 – 11:00

Dyalog will run a Workshop, a Tutorial or conduct a discussion on specific issues on request.

P14 Wednesday 15 September 09:00 -10:00:

Lars Wentzel (Fujitsu Sweden): CPAM — Array Structured Product Data at Volvo Cars
The Cars from Volvo are extremely diversified products. They can be configured in billions of different variants. The reason is that Volvo has a broad international market with different needs and wishes in different countries as well as amongst individual customers.

The product information is used throughout the company, amongst partners and by customers. You need this in public product information, sales, ordering, planning, logistics, production, distribution, procurement, product development and finance. For efficient company operations it is vital that this data is easy to reach, correct and up-to-date. The problem becomes even greater when you realize that the cars change frequently so that you have to describe in detail when all the changes will take place.

The best way to accomplish the information needs is to create a common master system with this data where you can reach it by services e.g. web-services (SOA). During a ten years period we have created this and we did it with APL i.e. Dyalog APL for Windows.

The first task was to create regular translation of the complex rules of the legacy Engineering System. We did this by using some of the principles described by the Danish company Array Technology. So we take data with sequential rules, investigate all the possible combinations and create array structures that in a compact form describe all possible combinations. Such an array structure is set of several hundred connected (nested) arrays. When you have this data in array format the revolution starts. You can now use it for multiple purposes like creating new forms of presentation and to analyze data from different angles and with very good performance.

After this we created the data engine to supply other systems and users with services. This is accomplished by using a set of continually running Dyalog APL server sessions. The most frequently used product information is held as variables in working memory. The sessions are all waiting for web-service request and then create the reply. This is all in the form of web-services. There are more than 100 different services for external or internal use. The web services are all done using the build in functions for TCP/IP in Dyalog APL. Recently we have started using the Conga interface. The XML parser functions etc. are our own make.

In addition to this CPAM contains:

• Interactive analysis and updating with a browser interface using IIS, ASP, HTML etc. communicating with the Dyalog APL server engine.
• Translation services where CPAM actively sent product information to other systems
• Batch services where you get a bulk of data, processes it as a batch and then return it
• Ordering of Excel reports
• CPAM currently supply 800 users with product information and interacts with around 20 systems.

WS4 – Wednesday 15 September 09:00 – 11:00:

Michael Hughes and Morten Kromberg (Dyalog Ltd.): Windows Presentation Foundation
Windows Presentation Foundation is a graphical subsystem for rendering user interfaces, originally developed for desktop applications built using the Microsoft.Net platform - but now also available for web and mobile applications under Windows, Linux, on the Apple Macintosh - and coming to mobile platforms. The workshop will demonstrate how WPF can be used from Dyalog APL and APL# to create desktop and web applications. Participants will leave the workshop with a working WPF application that can be used as a basis for further work with WPF. The agenda consists of:

• Introduction to WPF itself - "why bother"?
• Controls/Layouts, including Methods/Properties/Attached Properties/Events/Commands
• Different models for WPF development: Pure XAML, Code+XAML, Pure Code
• Translating xaml into code, particularly for attached properties,
• Customising xaml such as adding events (xml)
• Finding and understanding Documentation
• Tips for translation/ data structures/ use of dyadic []class
• Property binding, Commands and Triggers
• Debugging WPF applications
• Some more interesting controls, Ribbon, DataGrid, FlowDocuments, etc
• Data binding
• Building your own controls - Inheritance
• Creating distribution dll for control and/or application
• Graphics / Animation
• Templates and Styles

P02 – Wednesday 15 September 14:30 -15:30:

John Scholes, Jonathan Manktelow, Morten Kromberg (Dyalog Ltd.): Unifying Traditional Functions and D-Fns in APL#

APL systems provide a definition mechanism so that expressions may be collected into non-primitive or “user-defined” functions and operators: the traditional function or “T-Fn”.

In 1996, Dyalog introduced a purer direct-definition style, now referred to as a “D-Fn”, which was designed to fit better with the functional programming paradigm.

APL#, pronounced “APL Sharp”, is a new dialect of APL, which is aimed at the Microsoft.NET and similar “virtual machine” frameworks.

This paper details an attempt, in Dyalog's APL# project, to combine both “T-Fn” and “D-Fn” definition styles into a unified whole, which supports both the procedural and functional modes of programming.

The new function definition will attempt to provide the “best of both worlds” with:

• The cleanness of the D-function style.
• A vehicle for both procedural and functional programming.
• Both named and unnamed functions (and operators).
• Optional naming of arguments.
• Both traditional control structures and D-fns' guard.
• The ability to set both local and global state.
• A number of other innovations are presented, including:
• An elegant approach to the definition of ambivalent functions.
• Control-structures and guards as value-returning expressions.
• The passing of nested argument “tuples”.

We hope to encourage feedback from the APL community during the specification stage of the APL# project.

WS5 Wednesday 15 September 14:30 -16:30:

John Daintree (Dyalog Ltd.): Using the Microsoft.Net Framework
Dyalog integrates comfortably with the Microsoft.Net Framework. This course will give an overview of, and show how you can take advantage of, the features included in the Framework itself, and in Visual Studio, Microsoft's cross-language development platform. John will show you how to find and understand documentation of the framework class libraries, and he will introduce you to some of the most useful classes. We will explore how to use the VS Form Designer to build forms which use APL code, and write APL classes which can be used from C# and VB.Net. The course will very briefly show how to call APL code from Microsoft Internet Information Services (IIS).

P03 Wednesday 15 September 15:30 -16:30:

Richard Smith (Dyalog Ltd.): Processing Text Using Regular Expressions
In so-called “scripting languages” (Perl, Ruby, Awk and Tcl, to name a few), the ability to search text using “regular expressions” is a cornerstone for the power and flexibility that these languages deliver. Although APL is (currently) mostly used to process numeric data, APL has most of the characteristics of a good scripting language, and many current and future APL applications could benefit from the availability of regular expression support tightly integrated with the language.

The support for regular expressions in Perl inspired Philip Hazel to create the Perl Compatible Regular Expression library known as PCRE, which has been incorporated into many open-source applications. Although APL vendors and tool smiths have previously implemented system or library functions which interface to PCRE and other “regex engines”, one of the typical usage patterns is to call a function to process each “match” of the regular expression within an input document, suggesting that an operator might be a more appropriate model. This paper will discuss the design decisions which led ultimately to RX, Dyalog’s first “system operator”, which can search using PCRE and make modifications to the text either by using a simple transformation syntax (similar to that used by the Unix utility “sed”), or by using an APL function to express the transformation.

The paper will illustrate some possible examples of RX in use. In doing so it will consider character classes (such as “an alphabetic character”) which may be used in regular expressions, and invite further discussion on whether there could or should be additional classes specifically included in order to support searching APL source code.

V14 Wednesday 15 September 16:45 – 17:45:

Morten Kromberg (Dyalog Ltd.): Your Application as an SQL Data Source
Dyalog has developed a prototype of a framework which allows your application to look, taste and smell like a relational database. The SQAPL Server allows reporting on live APL data and analytical output from tools like Microsoft Excel or - Access, Crystal Reports - and virtually any programming language - in fact, any client application which can use ODBC, JDBC, ADO or ADO.NET. The interface fully supports SQL, including database updates and inserts, your APL functions as “stored procedures”, and creation/modification of tables (DDL statements) - and requires very little SQL expertise to set up.

Abstracts for Dyalog Sessions Thursday 16 September

ST1 Thursday 16 September 09:00 – 10:00:

Gitte Christensen (Dyalog Ltd.): APL - why, when and where
In this presentation we look at the current trends in software development and how the rest of the software world is doing. Some areas where APL is particularly competitive are identified and a list of Selling Points for APL is presented.

ST2 Thursday 16 September 10:00 – 11:00:

Paul Grosvenor (Optima Systems Ltd.): Making Money with APL
To make APL or indeed any other technology pay we must be very clear and positive about what it is we are selling, where we are selling it and why our client needs it. If that wasn’t enough, and in the current climate, our customers are very sensitive to both cost and risk and these two hurdles must be addressed and overcome quickly and decisively.
In this part of the presentation we will explore a few simple techniques to bring your proposal to the top of the list. It all comes down to confidence, preparation and rapport with a little bit of persistence and luck.

With some audience participation I aim to get you thinking ‘out of the box’ and demonstrate how you can make your proposal stand out from the crowd, to be so intriguing in fact, that your prospective client will be calling you.

I’ll even show you how to tell someone your name in a way that stands a better chance of them remembering it.

V15 Thursday 16 September 09:00 – 10:00:

Kai Jäger (APLTeam): APL2XML
HelpAndManual (http://www.helpandmanual.com/) is by far the best software available for creating any sort of documentation. The software comes with a powerful editor that allows the user comfortably to edit all sorts of aspects of documentation, including references, a glossary, an index and a table of contents as a tree-structure. The application saves it's data in XML files. The application compiles these files not only into ordinary Windows help files but also compiled help, RTF documents, PDF documents, web sites and electronic books.

That fact that it saves its internal data in ordinary XML files means that any application could create such XML files itself and then use HelpAndManual as a compiler in order to generate the preferred output format.

This seems to be particularly useful for classes: plenty of useful information can be generated from class scripts automatically: a list of methods including their syntax as well as a list of properties and fields.

In the case where a class script contains information about itself following some simple and basic rules, these pieces of information can be used as well.

This talk demonstrates how this can be achieved by using a couple of classes which are already available as part of the APLAPL project on the APL Wiki (ADOC; see http://aplwiki.com/ADOC) or will become available shortly before the APL2010 conference: the APL2XML classes.

With these classes one can create XML files which will be accepted by HelpAndManual as input files. Before the APL2010 conference ADOC will be enhanced to make use of the APL2XML classes in order to create any of the output formats supported by HelpAndManual.

Apart from its usefulness the approach demonstrates clearly the advantage of using XML as file format. This allows applications to work together although they don't know much about each other.
The advantages of an object-oriented approach in software development also becomes apparent: Both ADOC as well as the APL2XML classes are quite complex, but the complexity is hidden: the user is expected to deal only with the public interface which is easy and clean.

V16 Thursday 16 September 10:00 – 11:00:

Stig Nielsen (SimCorp A/S): Migrating SimCorp Dimension to Dyalog APL Unicode
SimCorp Dimension is an integrated single database investment management system mainly coded in Dyalog APL, partly in C#. Due to market demands, the APL and database part of the system has been migrated to support Unicode. Stig will take you through the steps needed, and the pitfalls to be aware of, to get successful through the migration process and finally release the product. The main challenge was to get all the interfaces to e.g. external C-libraries, third party products and general native file access issues. A general introduction to what Unicode is and why it is, or is not, the answer to all problems with multilingual challenges when it comes to sharing data will start the session.

P07 Thursday 16 September 10:00 -11:00:

Roger Hui: Hashing for Tolerant Index-Of
We consider the problem of xy where x and y are real (64-bit floats) or complex (64-bit floats of the real and imaginary parts), with tolerant comparison (nonzero ct). We show how to use hashing to solve the problem.

Hashing algorithms for real and complex arguments have been implemented in Dyalog v13.0. APL models and test cases are provided. Benchmarks demonstrate the improvement over the previous implementation.

V17 Thursday 16 September 14:30 -16:30:

Ryan Tarpine and Mstislav Elagin: Winning the Dyalog Programming Contest 2010

Ryan is the winner of the Dyalog Programming Contest 2010. He is a 25-year-old PhD Candidate in Computer Science with a focus on computational biology from Brown University, in Providence, Rhode Island, USA. The runner-up in the contest is Mstislav, a 32-year old PhD student at the Humboldt-Universität zu Berlin, who is currently developing an online monitoring and early warning system for financial markets. Ryan and Mstislav will speak about their experiences in learning APL - and using it to win prizes!