Dyalog Forums

The first videos of presentations from Dyalog '17 are now live. Go to http://www.dyalog.com/user-meetings/dyalog17.htm to read about Dyalog '17 and follow the links to the videos.

D01: https://dyalog.tv/Dyalog17/?v=bFxeynFBgb4
Gitte welcomes everyone to Dyalog '17 and provides her view on how the company and its products are evolving to meet the challenges posed by changes to the technical environment and evolving user requirements. She mentions the new multi-platform licence, new examples and templates to help people learn APL and talks about how the introduction of regular webinars will help provide more people with training materials and news about Dyalog. Sam Gutsell (Optima Systems) completes the presentation with an introduction to the Code Golf tournament taking place for the duration of Dyalog '17.

D02: https://dyalog.tv/Dyalog17/?v=K4V8vVgAihY
Morten's Technical Road Map starts with an emphasis on running applications in the cloud and the importance of Dyalog's commitment to enabling anyone to deploy an application on multiple platforms without changes. Morten explores the needs that must be satisfied to recruit a new generation of APL developers and managers with regards to industrial-strength solutions and industry standard tools, for example, Git for source code management. This year's live demo is of interactive Dyalog-based Jupyter notebooks.

D03: https://dyalog.tv/Dyalog17/?v=WYueMAueemM
Jay starts with a summary of the features/functionality introduced in Dyalog version 16.0 (released 2017Q2), including the new primitive functions and operators, enhancements to system functions and the HTMLRenderer GUI component for cross-platform user interfaces – before moving on to talk about likely features of Dyalog version 17.0 (scheduled for 2018Q2), such as scripting, language enhancements, performance, interfaces and packaging. Jay finishes by reviewing Dyalog's progress and plans to support GPUs and continue to increase performance on all platforms.

U01: https://dyalog.tv/Dyalog17/?v=9xCJ3BCIudI
Aaron Hsu (Indiana University) has been evangelising for APL, both with trained computer programmers and with people who have no previous programming experience. In doing so he has observed that people in the former category have found the learning wall higher than those in the latter. Curious as to what could be causing this, Aaron investigated possible reasons, starting from Ken Iverson's principles of good language design. He identified eight patterns that contrast traditional software engineering practice with the patterns of practice that appear in well written APL code, and he shares those here before touching on code readability.

We'll be releasing new Dyalog '17 presentation videos every Friday for the next few weeks so please check https://dyalog.tv/Dyalog17 regularly for updates.

Further videos from Dyalog '17 have now been released at dyalog.tv

D04: A Case Study – Recoding from Procedural to Denotative Style (John Scholes)
https://dyalog.tv/Dyalog17/?v=74xrZkVlns0
John has spent 20 years advocating the use of denotative (functional) programming styles. In this talk, he celebrates the introduction of the At operator (@) in Dyalog version 16.0, which now allows him to eliminate indexed assignments (which modify global data) from his code in the dfns workspace. John steps through the translation of one style into the other using Dijkstra's example of finding the shortest path through a network. By moving from a procedural to a denotative style of coding, the sequence of operations can be ignored and code made atemporal; the main difficulty for a developer is overcoming the change in mindset between the two styles.

D05: APL Source Code in Text Files (Morten Kromberg)
https://dyalog.tv/Dyalog17/?v=yX2AyJa375k
Storing APL source code as text files offers many advantages, for example, using third-party software for source code management (such as SubVersion or Git) to compare versions or collaborate in other ways – and the ability to share APL source code across Dyalog versions. Morten demonstrates recent features of Dyalog APL which support the process of creating, maintaining, building and testing applications based on text source.

U03: Working with APL for Physics Research (Kostas Blekos, University of Patras)
https://dyalog.tv/Dyalog17/?v=pWtvRlCdX00
Academic physicists often use languages such as FORTAN and MatLab in their research; as they are not programmers by training this can result in verbose and unmaintainable code with frustrating bugs. PhD candidate Kostas Blekos (University of Patras) sought an alternative that would allow him and his team to quickly produce prototypes and simulations. Kostas describes the positive experience of using APL, which allowed them to represent mathematical models as matrix equations efficiently and easily without needing to become professional coders.

U02: RIDE 4.0 and 4.1 (Gilgamesh Athoraya (Data Analytics AB) and Callum Floume (Optima Systems))
https://dyalog.tv/Dyalog17/?v=W7EaWAhQX6s
Gilgamesh Athoraya (Data Analytics AB) and Callum Floume (Optima Systems) are now doing most of the development of Dyalog's Remote IDE (RIDE), which is an open source project on GitHub. Here they present the enhancements they made for RIDE version 4.0, bringing the capabilities of RIDE significantly closer to Dyalog's IDE on Microsoft Windows. The enhancements demonstrated include the introduction of secure connections, a workspace explorer and debug window, improved search functionality and a better overall user experience.

D07: Index-Of on Multiple Floats (Roger Hui)
https://dyalog.tv/Dyalog17/?v=69ncBGN3YiI
On and off for the past two decades, Roger has been searching for a way to efficiently look sub-arrays of one floating-point array up in another. The introduction of the interval index (⍸) function at Dyalog version 16.0 inspired a critical insight, and by combining it with the key (⌸) operator introduced at Dyalog version 15.0, it became possible to "hash" the data. The end result is an efficient computation for x⍳y and an insight into how to tackle a problem with the unique (∪) function – which will be discussed in detail in session D10 Tolerant Unique

D12: Try APL Online (Brian Becker and Adám Brudzewsky)
https://dyalog.tv/Dyalog17/?v=ddBjIkyebuY
Brian and Adám compare and contrast two on-line environments that allow experimentation with APL without installation of an APL interpreter: TryAPL (http://tryapl.org/) and TIO (https://tio.run/#apl-dyalog). Dyalog's goal is to lower the barrier to entry, making it easy to start learning APL and exchange ideas with others. TryAPL includes basic tutorials and input methods for APL's glyphs, allowing interactive experimentation with a subset of the Dyalog language, while TIO gives full access to the features of the interpreter, running batch processes in a sandbox.

More videos from Dyalog '17 have just been released

D10: Tolerant Unique (Roger Hui)
https://dyalog.tv/Dyalog17/?v=fPWky9IOG40
The implementation of the unique primitive (monadic ∪) can return incorrect results when applied tolerantly (⎕CT≠0) to floating-point numbers. This problem is obviously very rare, since the same bug has affected all APL interpreters that implemented it (including J) for decades. Roger presents a solution which cannot be delivered as a patch to version 16.0 because applications might be relying on the existing incorrect behaviour, but will be included in Dyalog version 17.0. Roger also discusses ideas to make unique even faster, and proposes extending the definition to work on arrays of rank greater than one.

U13a: How I Won the APL Problem Solving Contest – Introduction and Prize Ceremony (Brian Becker and Carlo Spinicci, SimCorp Italiana)
https://dyalog.tv/Dyalog17/?v=q-LiI8HHAuY
The ninth annual International APL Problem Solving Competition took place earlier this year. Brian introduces the contest and Carlo Alberto Spinicci (SimCorp Italiana) presents the prize winner, Kostas Blekos of the University of Patras, with his certificate in the Prize Ceremony.

U13b: How I Won the APL Problem Solving Contest (Kostas Blekos,University of Patras)
https://dyalog.tv/Dyalog17/?v=-jRUfmlxAw8
Kostas Blekos of the University of Patras in Greece won the 2017 International APL Problem Solving Competition – here he explains how he achieved this success. After a brief look at how he tackled phase I, Kostas introduces the phase II healthcare category that he tackled and describes the approach he took to solving the issues posed.

Another batch of videos from Dyalog '17 are now live.

U04: APL on GPUs – A Progress Report with a Touch of Machine Learning – Martin Elsman (University of Copenhagen)
https://dyalog.tv/Dyalog17/?v=iucPNyTsRt4
Martin Elsman (University of Copenhagen) presents an update on the work he first presented at Dyalog '16 (see https://video.dyalog.com/Dyalog16/?v=XwAkJbYBPZk), the aim of which is to provide high performance to domain experts using APL. Martin and his colleagues have created a compiler infrastructure that converts a subset of APL into TAIL (Typed Array Intermediate Language) before compiling that into Futhark (a functional programming language). The result is a highly-optimised reusable module that can be integrated with high-level languages. After the status update, Martin demonstrates how the APL compiler infrastructure can be used to efficiently teach a neural network to recognise handwritten digits.

U05: Co-dfns Report 2017: Ease of Use, Reliability and Features – Aaron Hsu (Indiana University)
https://dyalog.tv/Dyalog17/?v=IYh5GX9H92c
This is the fifth Dyalog user meeting at which Aaron Hsu (Indiana University) has presented a progress report on his Co-dfns compiler, a Dyalog-sponsored research project. Aaron focusses on the simplified installation process and improved reliability and explains how future enhancements will be prioritised. His benchmarking demonstration illustrates the performance benefits of compiling APL code to run on GPUs, using the Co-dfns compiler.

U06: Parallel Execution in a Monolith Application – Lars Villadsen (SimCorp)
https://dyalog.tv/Dyalog17/?v=ilq41dguHsc
Financial markets are in a constant state of upheaval and SimCorp Dimension® contains code accumulated over 25 years. In an ideal world this would be completely refactored to take advantage of advances in technology and enhanced functionality in Dyalog, but in the real world this is impractical. Lars Villadsen (SimCorp) describes a pragmatic approach that enables parallelisation of a mature product without significant refactoring, based on Dyalog’s shared code file technology and Conga.

Further videos from Dyalog'17 have now been released.

U07: Freedom Hunting: Our Search for Independence in UI Design – Annalisa Camillo (SimCorp Italiana)
https://dyalog.tv/Dyalog17/?v=xFtK-3CJVgE
Changes in operating systems and technologies over the life of SimCorp Sofia have meant that its GUI has needed to evolve. The variety of screen sizes and resolutions used with the application posed a particular challenge. Annalisa Camillo (SimCorp Italiana) explains how the team was able to separate layout from content and design a scripting mechanism that allows the available screen space to be allocated dynamically.

D09: Cross-Platform User Interfaces using the HTMLRenderer – Brian Becker
https://dyalog.tv/Dyalog17/?v=c9CK0m_LuBk
Users of Microsoft Windows have been able to use ⎕WC to build GUI front ends for applications for the last 25 years. The new HTMLRenderer object available with Dyalog version 16.0 now makes it possible for Dyalog users to build rich graphical user interfaces that will run under Microsoft Windows, Apple macOS and Linux. Brian demonstrates its use and shows how built-in components from Syncfusion, jQuery, Bootstrap, etc. can be incorporated to produce forms, display graphics – and run existing MiServer applications on the "desktop".

D11: Literal Notation for Arrays and Namespaces – Adám Brudzewsky
https://dyalog.tv/Dyalog17/?v=CRQNzL8cUQE
APL has always provided a powerful and elegant notation for the definition of simple array constants. However, the definition of arrays with 2 or more dimensions, deeply nested structures and namespaces requires expressions which are unnecessarily difficult to read and maintain. To address this need, Adám presents ideas for a simple literal notation for more complex constants.

A few more videos now available from Dyalog '17

U10: Managing Projects That Never End – Alexey Miroshnikov (InfoStroy Ltd)
https://dyalog.tv/Dyalog17/?v=nEH_5CYDItc
Rapid growth of the development team combined with the cost and difficulty of using traditional project management tools combined to inspire Alexey Miroshnikov (InfoStroy Ltd) to re-examine the way in which InfoStroy handled project management. Replacing top-down management with the scrum methodology has not only helped regain control but has also doubled productivity. Alexey relates a story of renewed motivation, problems encountered and overcome and increased customer satisfaction.

D13: ⎕NMOVE and Other Predictions for Dyalog Version 17.0 – Richard Smith
https://dyalog.tv/Dyalog17/?v=8KwO-D6fhfI
Richard starts with a brief reminder of the portable file functions introduced in Dyalog version 15.0 (and enhanced in Dyalog version 16.0) to allow simple and portable access to the host file system. He then demonstrates a number of enhancements proposed for it in Dyalog version 17.0, including ⎕FMOVE and ⎕FCOPY and a general set of extensions to the existing functions to handle multiple names in a single call. His subsequent speculations on future development also cover the incorporation of code pages and, for ⎕CSV, the escape mechanism and how to handle ragged files.

D14: Uncle Andy's Fireside Chat v4.0 – Andy Shiers
https://www.youtube.com/watch?v=ZD4LJCunLZs
Andy's now-traditional delve into some of the new and lesser-known features of Dyalog starts with a look at Dyalog version 16.0. Topics include changes in the handling of the CONTINUE workspace, the ability of certain system commands to take parameters, amendments to autocomplete and ⎕NGET and additional functionality in the Editor. Andy then describes some of the changes that are likely to be in Dyalog version 17.0.

Some more videos now available from Dyalog '17 at https://dyalog.tv/Dyalog17/?v=KO1HbUSblY8

D06: Py 'n' APL – Marinus Oosters
https://dyalog.tv/Dyalog17/?v=KO1HbUSblY8
Python is a very popular scripting language with extensions and libraries that provide a great range of functionality, for example, image processing, robotics and cross-platform UIs. Marinus Oosters (Dyalog intern, summer 2017) demonstrates the Python-APL interface – Py 'n' APL – that he has created, which allows two-way communication between an APL interpreter and Python interpreter. This enables APL programmers to call libraries written in Python, and Python users to take advantage of APL to do analyses that are difficult to code or perform poorly in Python.

U11: Polyominoes in APL – John Niss Hansen
https://dyalog.tv/Dyalog17/?v=_dfpoOIazhE
A polyomino is a geometric figure formed by joining one or more congruent squares edge to edge (in 2 dimensions) or cubes side by side (in 3 dimensions). John Niss Hansen's fascination with polyominoes started over 40 years ago; he now demonstrates the polyomino app that he has written using APL. John's app allows polyominoes to be created and examined and puzzles to be designed and then solved (either manually or automatically). The array-based nature of the polyominoes and puzzle layouts makes APL the ideal tool for enumeration and visualisation; it also enables the app to perform real-time calculations and inform a player whether a puzzle is ultimately solvable as each piece is placed.

U12: Evolutionary Programming – Gilgamesh Athoraya (Data Analytics AB)
https://dyalog.tv/Dyalog17/?v=Wff2InJn3p0
Artificial neural networks use a fixed program and variable parameters to seeking optimal variable sets. If the inputs are reversed so that the program is variable and the parameters are fixed, then a different approach is needed. Gilgamesh Athoraya (Data Analytics AB) introduces genetic programming, which is based on the principles of biological evolution. Code evolves through generations of reproduction and mutation using function trains as chromosomes and isolates to parallelise the evolution of the perfect train. Gil demonstrates a simple application of the evolution of a program from first generation to a solution that is particularly appropriate for the problem posed.

We are wrapping up the publication of recordings from Dyalog’17 with three highly entertaining presentations by three rising stars in the APL community. Until Dyalog’18, please tune in to our regular web casts (https://dyalog.tv/Webinar) to watch regular presentations from the Dyalog team!

D08 - Moving Bits Faster in Dyalog 16.0 – Marshall Lochbaum
https://dyalog.tv/Dyalog17/?v=2KnrDmZov4U
Marshall, the most recent and youngest member of Team Dyalog, has been instrumental in implementing performance improvements relating to the manipulation of Boolean arrays. Primitive functions already performed faster on Booleans than on one-byte integers, but he has managed to make further improvements. After a brief introduction to the way in which Booleans are handled in Dyalog, Marshall uses the transposition of a Boolean array of any shape to illustrate one of the mechanisms he has implemented in Dyalog version 16.0.

U08 - APL in SA: The Joys of Financial Reporting and Creating Libraries for Everyday Use – Zack Batik (RiskFlow)
https://dyalog.tv/Dyalog17/?v=7unYwhkIwdE
Zack Batik started working at RiskFlow a year ago, and has now moved from prototyping to working on production code for their CashFlow Optimiser application. In doing so, the importance of testing and the benefits of libraries have had the greatest impact on his coding practice. Zack discusses the need for a solid base of utilities so that development and testing time can be reduced while code confidence can be increased, and emphasises the difference between "accidental libraries", in which snippets of code get copied into new programs with small tweaks, and deliberately constructing generic tools to handle common tasks. He emphasises the benefits of open source tools (already common with a lot of programming languages) and shares several that he has developed (see https://github.com/Riskflow/DataExtraction, where his tools to simplify reading from databases/CSV files are available).

U09 - Exploring the RF spectrum with Dyalog APL – Moris Zucca (SimCorp Italiana)
https://dyalog.tv/Dyalog17/?v=mb8vWftbAYQ
Software-defined radio (SDR) is a radio communication system in which components such as amplifiers and modulators are implemented using software instead of the traditional hardware. In the last decade, technological advances by RealTek Labs (RTL) have made SDR viable for hobbyists. Moris Zucca (SimCorp Italiana) is one of the hobbyists who has taken up the RTL-SDR challenge; he explains how he has connected the Dyalog interpreter to various devices and converted the radio signals using APL. A little bit of reverse engineering means that he now possesses possibly the only remote control for a garage door that can be activated using APL!