An introduction to OO in APL. Dan Baronet Sunday, 9 AM - All day

  1. OO concepts
    What the terms are and what they mean. For those who are familiar with OO this will be more of a review with emphasis on the exact terminology used here. Will be reviewed:
    • Classes
    • Instances
    • Members
    • Interfaces
    • Inheritance
    • Encapsulation
    • Polymorphism
  2. Implementation in APL
    How Dyalog APL implemented OO. What new system functions were introduced and their syntax.
    • New objects
    • constructors
    • destructors
  3. Special cases
    Array languages and functional languages are different from conventional languages and some special cases had to be covered. Those include
    • Property cases
    • Triggers
    • language extensions
    • .Net integration
Examples will be shown if time permits. Those will include .Net, GUI, OLE, Web

APL for Today
(An Introduction To APL)
Ray Polivka Sunday, 9 AM - All day [FREE of Charge]
APL is a dynamic array oriented Programming language. It is an excellent tool for interactive problem solving and prototyping. It permits its user to think more in terms of a problem solution than in terms of the computer.s behavior. It addresses the user.s needs where the push of a button will not do. This tutorial will offer an introduction to "the classic" (i.e. vendor independent) APL programming language for those unfamiliar with it.

What APL Can Teach the World
(and vice versa)
Guy Steele Monday, 9:00 AM
APL has had a long and venerable history among programming languages --- its roots go back a full fifty years---but lately it has fallen on hard times,which is a pity, because there are certain important lessons from APL that the rest of the world has still not learned. Unfortunately, the APL community, like the Ada community, has been rather insular; it's been hard to make new ideas flow either out or in. The key to the survival of APL and its ideas may be increased interaction and involvement with the rest of the computer science and computing community. In this talk I make some specific suggestions for how the APL community might use its unique skills to tackle some of tomorrow's important computing challenges.

No Experience Necessary
Hire for Aptitude - Train for Skills
Brooke Allen Monday, 11 AM
Because the half-life of technology is so short, we must constantly learn new things just to stay put. Employers persist in hiring only those with proven experience and hence even those with years in the workforce may still find themselves stuck in the
"no experience -> no work -> no experience
" loop. Mr. Allen heads a quantitative trading desk for a Canadian financial firm. He will be describing his novel approach to finding, training and hiring people who have never before seen, or even heard of, the things he will be employing them to do. He will also present suggestions that new and mid-career job seekers, entrepreneurs and computer consultants can use in finding and landing work.

Comparisons Between Array and Non-Array
Approaches to Programming Problems
Devon McCormick Monday, 1:30 PM
Array-based approaches to programming problems are widely misunderstood in the sense that they are little understood at all. There is a widespread misconception that an array language simply adds "syntactic sugar" to a conventional language and that this is only a small advantage. In fact, an array-based approach often gives us a much better handle on a problem by allowing us to approach it at a higher level. In this paper, I propose to give some examples of the needless complexity introduced by non-array languages and how this can be reduced with an array-based approach. Additionally, I will propose an alternative metric for code performance called "total time to solution".

Generic Programming on the
Nesting Structure of Arrays
Stephan Herhut
Sven-Bodo Scholz
Clemens Grelck
Monday, 2:00 PM

Multi-dimensional arrays lack expressiveness with respect to logical layers of data; they provide no means to encode that, for example, a three-dimensional array of double values is used to represent a matrix of RGB-values. Existing approaches, e.g., boxing and unboxing the inner dimensions of an array, allow the programmer to encode additional structure, but make programming on nested arrays a tedious and error-prone task: nesting and de-nesting operations have to be explicitly encoded in function applications. Apart from the additional work spent on program specification, this scattered encoding of structural information renders refactoring of widely used data structures difficult.

We propose a new means to model the structure of homogeneously nested arrays in the type system, rather than the actual data. We exploit this additional type knowledge for subtyping based function overloading, liberating the programmer from explicitly encoding nesting operations in function applications. Furthermore, we propose and demonstrate a nesting-structure generic programming extensionthat allows us to define user-defined homogeneously nested array-types without the usual boiler-plate code.

Richard Nabavi Arrays of objects, or objects containing arrays? Monday, 2:30 PM
The introduction of object-oriented language features into array languages such as APL presents new challenges for the design of applications. As we begin to explore and use objects and classes in APL, it is evident that the traditional design approaches used in scalar object-oriented languages (such as C++ and C#) are not well suited to array languages. This paper will discuss some of the tradeoffs, including how to decide on the granularity of user-defined classes, and how to make good use of arrays of objects.

Melding Moore and Iverson: An Open Abstracted
APL built in Forth for Intel processors.
Bob Armstrong Monday, 1:30 PM
The philosophical goal of Charles Moore's FORTH is to define the minimal vocabulary capable of extending itself; Ken Iverson's goal was to define the maximally meaningful notation . The goal of 4th.CoSy is to abstract the structures and syntax of Iverson's APL in modern Forth, free and open down to the Intel ( or future ) primitives, to create a powerful personal computing environment for the everyday business of life. Those interested in this tutorial should download the current version of 4th.CoSy and have it with them on a laptop. The tutorial will, thru example, Show Forth's very simple :
structure : ( dictionary ; dataStack , returnStack ; interpreter )
syntax : ( read a word ( delimited by whitespace ) , look it up , interpret it)
Show the APL and K informed CoSy structures and vocabulary :

Thinking in Arrays Steve Rogers, Moderator
Monday 3:30 PM
This panel will introduce some of today's array languages and discuss their relevance in today's technical and business environment. Each panelist will introduce his or her array language or dialect of choice (5 to 10 minutes each). Panelists will ask each other questions and there will be a limited period at the end for questions from the audience. For each language, discussion will include:
  • Origin
  • Why created
  • Brief Description
  • Platform(s) supported
  • Strongest and weakest aspects
  • Current development direction
  • How to get it
  • How to get more information
Bob Armstrong (4th.cosy)
Robert Bernecky (APEX)
Mike Jenkins (Nial)
Morten Kromberg (Dyalog APL)
Jon McGrew (A+)
John Randall (J)
Steve Rogers (Numeric Python)
Sven-Bodo Scholz (SAC)
Loren Shure (Matlab)

Using Objects in APLX Version 4 Richard Nabavi Tuesday, 9:00 AM
APLX Version 4 introduces object-oriented features to the language. This tutorial will show how to define and use classes and objects in APLX applications, and illustrate some of the advantages (and pitfalls) of the new facilities. Attendees should be familiar with at least one of the major APL dialects, but no prior knowledge of object-oriented programming is required.

A general introduction to SaC
(for Single Assignment C)
Stephan Herhut
Sven-Bodo Scholz
Clemens Grelck
Tuesday 9:00 AM
SaC is a functional array language with a C-like syntax. Among other things, it features:
  • APL style program specifications
  • C-style syntax
  • full customization of ALL array operations (verbs)
  • arrays of user-defined types
  • efficient interfacing to C
  • radical program optimization
  • compilation into high-performance C code
  • efficient multi-threaded execution on multicore architectures
As part of this tutorial we intend to show several SaC solutions to some array-oriented problems. For more details see The SaC Home page

Unicode Support for APL Morten Kromberg Tuesday 11:00 AM
Not only does Unicode offer users of APL the same benefits as users of other programming languages, namely the ability to consistently represent and manipulate text expressed in any of the world's writing systems: Unicode includes the APL character set, and therefore allows APL programs to be represented and manipulated using industry standards which are now widely supported "only" 16 years after the first version of the Unicode standard). The paper presents the design of Unicode support for an APL interpreter which fully supports Unicode in all phases of system development and deployment. The paper will discuss the internal representation(s) used for Unicod characters, and how the design provides a (fairly) smooth upgrade path fo users of earlier versions of the system. The presentation will include demonstration of the resulting system, including examples of how Unicod allows the use of "mainstream " software development tools to develop an maintain APL applications

Programming with Arrays
Lessons from Nial
Mike Jenkins Tuesday 11:30 AM
Nial is an array-based programming language based on Trenchard More's array theory and Mike Jenkins. ideas on programming methodology. Starting with concepts from APL, LISP and structured programming, an interactive programming environment was designed and implemented based on rigorous mathematical principles. The C-based portable implementation, Q'Nial, worked under MS-DOS on IBM PCs, UNIX on many platforms, and VMS for IBM mainframes. While of interest to academic researchers and some APL enthusiasts, it did not achieve widespread acceptance for commercial or academic use. The design is reviewed and lessons for programming language designers are discussed.

Advantages of Using an Interactive,Array-Based Language for Financial Research Devon McCormick Tuesday 12:00 AM
Array-based, interactive programming languages are often superior, compared to traditional compiled languages, for research, especially financial research, for several reasons. One is that data will always come in series, which map naturally to arrays. Another reason is that research is a process of discovery that requires methods to be invented, adapted, and changed, contingent on what is found in the data. A related reason is that this evolutionary process requires code to be modified continually and this is much simpler and more straightforward given the flexibility of an interactive environment and the compactness of array-based code.

SaC: customizing your own verbs
and data types with little effort
Stephan Herhut
Sven-Bodo Scholz
Clemens Grelck
Tuesday 11:00 AM
The idea behind this practical is to introduce the participants to the definitional power of SaC. After a brief introduction into the main syntactical constructs of SaC, we will redefine some of the basic array operations of the language. Furthermore, we will show how to specify generic array operations so that they can be applied to arrays of user-defined types with minimum programming effort. In order to give the participants a first hand experience, we intend to conduct these programming exercises jointly with the participants.

Design considerations for interfacing
APL to other object-oriented languages
Richard Nabavi Tuesday 1:30 PM
With new object-oriented facilities now available in APL, it is possible to create and use object classes written in other languages directly from APL. This paper discusses how the language features of major object-oriented languages (including C#, Visual Basic, Ruby and Java) can be mapped to APL. Topics will include memory management, garbage collect, parameter marshalling, metadata, and serialization of objects.

Competing with J John Randall Tuesday 2:00 PM
We discuss J's performance in programming contests and the implications for both language and contest design.

Arrays of objects Morten Kromberg Tuesday 2:30 PM
Arrays of objects
This paper discusses key design decisions faced by a language design team while adding Object Oriented language features to Dyalog, a modern dialect of APL. Although classes and interfaces are first-class language elements in the new language, and arrays can both contain and be contained by objects, arrays are not objects. The use of object oriented features is optional, and users can elect to remain entirely in the functional and array paradigms of traditional APL. The choice of arrays as a "higher" level of organization allows APL's elegant notation for array manipulation to extend smoothly to arrays of objects.

This paper will be presented to the Dynamic Languages Symposium on Monday morning, and will be repeated here for APL2007 attendees.

APEX: The APL Parallel Executor Robert Bernecky Tuesday 1:30 PM
APEX is an APL research compiler; it compiles flat APL (a subset of ISO N8485) into SaC, a functional array language with parallel semantics. APEX is written in relatively portable APL, and is currently running under Dyalog APL Version 10.1 under SuSE Linux version 10.1.

Made for APL - the initial foray of
An Aging Jedi Knight and light saber
into the world of Bioinformatics and Cancer Research
Ken Fordyce Tuesday 3:30 PM
The DNA alphabet contains four letters (ACGT) and combinations of these letters contain the instructions needed for the orderly running of a cell. A gene is long string of these letters approximately organized as: left, middle, right. The middle contains exons (which identify the ingredients in the cake) and introns (whose importance we are just starting to understand). An exon consists of a set of codons where each codon is three letters long. Certain codons indicate the start of an exon and others indicate the end of the exon. Part of the genetic research requires finding patterns and manipulating this sequence of letters. For example a key question is looking for the number of repeats in part of the gene. A &q.quot;repeat&q.quot; is a stretch of the gene where the same letter is repeated numerous times. In the sequence &q.quot;actacgaaaaaaaagatggtacgc&q.quot; we observe one long &q.quot;a&q.quot; repeat. This repeat starts at position 7, ends at position 14, and is 8 long. This presentation will describe some of the &q.quot;computational&q.quot; challenges and how APL easily handled them.