The APL file extension is a data format associated to Monkey's Audio. APL files were developed by Matthew T. These files contain metadata for an audio track, including the start and end location of the track within a source.APE file.

The release of the final set of videos from the Dyalog ’19 user meeting in Elsinore slipped into 2020, thus providing me with a perfect opportunity to wish you all a Happy New Year from all of us at Dyalog! We are wrapping up with recordings from the Prize Ceremony for the 11th annual Problem Solving Competition and the the Young APLers’ Panel.

The young APLer’s panel. From left: Stephen Taylor, Alve Björk, Yuliia Serhiienko, James Heslip and Josh David

I can’t think of a better way to kick off the new year than watching newcomers to APL talk about how they got started! With Stephen Taylor as host, our panellists Alve Björk (Uppsala University, Sweden), James Heslip (Optima Systems Ltd, UK), Josh David (Dyalog Ltd, USA) and Yuliia Serhiienko (SimCorp, Ukraine) discuss how they first encountered APL, their perception/experience of the language and what they would like to see APL vendors and the APL community working on in the future.

Every year, the annual APL Problem Solving Competition entices students to learn APL and try to win significant cash prizes and a trip to the Dyalog user meeting. This year, Dyalog brought the entire contest “in house” rather than using an external company to host it. We developed our own interactive contest site, which allowed contestants to get immediate feedback on potential solutions to Phase 1 problems. In addition to making it more fun – and a lot easier – to submit solutions, the new site saved Dyalog a lot of time by pre-verifying Phase 1 solutions. As Brian Becker explains in his talk leading up to the prize ceremony, the project gave us an opportunity to test a lot of our own components by building a fully operational application entirely in Dyalog APL. Gitte Christensen, CEO of Dyalog Ltd, awards the prize for the best professional entrant to Torsten Grust and the grand prize to Jamin Wu.

I never cease to be amazed by the quality of presentations by winners of the contest. The youngsters of today seem able to learn to write APL code that many professionals would be proud to have written, in a few weeks – sometimes only days.

Jamin Wu is a medical student at Monash University in Australia, but also a keen programmer. His presentation on how he won the 11th annual APL Problem Solving Competition was one of the clearest and most impressive acceptance speeches by a winner of the competition that I have had the privilege to attend. In a very short amount of time, Jamin has been able to get an astonishing grip on the benefits of APL, and write some of the most elegant APL code I have ever seen. We’re sad that he won’t be joining the community as a full-time APL programmer any time soon; the good news is that the medical community in Australia will soon have a very competent young doctor, able to use computers very effectively to assist him in research and analysis of data!

Summary of this week’s videos:

That is (almost) the end of the Dyalog ’19 videos; at Tomas Gustafsson’s request, we are holding back the release of his exciting yarn about how APL was used to locate the wreck of the M/S Irma until the upcoming documentary has been aired on Finnish TV.

It is already time to think about Dyalog ’20, which will be held in Olhão, Portugal, from 11th-15th October. Follow us on social media (Facebook, Twitter, LinkedIn) to be kept informed about this and all things related to Dyalog!

I was asked to talk about 'the role of Logo-like learning of programming incomputer science education.' The trouble is that I'm not sure I know what'Logo-like' means. It's an interesting word; as soon as we hear it, we allfeel as if we know more or less what the person who says it means. We don'thave the same urge to interrupt that we would if someone said, for example,'recursion-like.' But do we really understand each other? It gets a littlefuzzy, for me, when I think about it in more detail.

What is a Logo-Like Language?

Let me give a couple of examples. First, I notice that in the conferenceannouncement, the programming language ISETL is considered to be Logo-like.But in 1976, Seymour Papert dismissed APL, which is in many ways similar inspirit to ISETL, by referring to 'languages of the BASIC/APL/FORTRAN family'[Pap76]. Logo, APL, and ISETL are all interactive languages that supportrecursive functions and are designed around mathematical ideas rather thanaround computer hardware capabilities. Logo is different from the other twoin that its mathematics is meant to appeal to young kids, while both APL andISETL present a more conventional, adult mathematics. What has changed tomake APL non-Logo-like in 1976 but ISETL Logo-like in 1993?

As a second example, I'm not sure that my own work, even when I use Logo,is really 'Logo-like.' In Seymour's new book he characterizes the spiritof Logo as a promotion of Concrete Operational thinking from an interimstage of development, one that should be discarded as soon as possible, to amode of thinking that is at least as valuable as Formal or abstractreasoning, even in adulthood. [Pap93]

When I read that, I was reminded of the history of the Logo IF notation.The early dialects of Logo, up to the MIT Logo for the Apple and itsTerrapin descendents, use a BASIC-like IF-THEN notation:

IF :X < 0 THEN PRINT 'NEGATIVE

I was part of the design team for Apple Logo, the first LCSI product, and Iwas, as much as anyone, responsible for the shift to the notation in whichIF is a procedure with two arguments, a true-or-false value and a list ofinstructions:

IF :X < 0 [PRINT 'NEGATIVE]

Our argument was that Logo should have a single, uniform rule for evaluatingexpressions: Every expression consists of the name of a procedure, followedby some number of expressions that provide the arguments. Logo evaluatesthose subexpressions, then invokes the named procedure with their values asits argument values. The advantage of the uniform notation is that it pavesthe way to user-defined control structures like

WHILE [:X < 0] [PRINT :X MAKE 'X :X+5]

But there's no question that the LCSI syntax requires some explanationfor beginning Logo programmers. By making this change, have we put generalrules -- abstract thinking -- above the concrete specificity of IF/THEN?Was this a non-Logo-like change? LCSI is Seymour's company, and they stilluse the newer IF syntax.

What is Logo-Like Learning?

Both of these examples raise the question of what constitutes a Logo-likelanguage. I was asked to address a somewhat different question, aboutLogo-like learning. But I'm just as confused about what that means. Let medescribe two of my own experiences as a teacher, and let's ask to whatextent each of them is 'Logo-like.'

The experience I enjoyed most, and of which I'm proudest, was running acomputer lab at the Lincoln-Sudbury Regional High School, in Massachusetts,from 1979 to 1982. It was never completely clear what I was supposed toteach. The principal, who came from a business background, talked about'data processing.' Some of the other teachers had picked up on the recentlyinvented phrase 'computer literacy.' Computer science as a high schoolsubject didn't really exist yet; I was myself most interested in computerprogramming, especially systems programming. The students, too, had a broadrange of interests and expectations when they signed up for a computercourse.

At first I tried offering different courses for students with differentlevels of interest, but I soon learned that most students didn't really knowwhat they wanted until they had some experience within the courses.(Remember that personal computers had just barely been invented, and moststudents had no idea what it meant to use a computer, or to program one.)I ended up using a self-paced structure, in which there was one course foreveryone, but each student could design his or her own curriculum withinbroad limits. Logo programming was one of the options. Every beginner wasrequired to learn a little Logo and a little word processing; beyond that,anything was allowed.

We had a Unix-based timesharing system. At that time, Unix providedprogramming languages and application software far in advance of anythingavailable on personal computers, such as the Apple II and the Atari 800.Partly because of Unix, and partly because I was spending much of my owntime on system software development, the kids soon got the idea that theadult programming language was C, and so that's what all of the reallyinterested students used. C is about as far from a Logo-like language asyou can get! The C programmer deals very directly with issues of datarepresentation within a computer, such as word length and memory allocation.

On the other hand, what felt 'Logo-like' about this situation was that thekids were engaged entirely in real work, using the computer for their owngoals and not jumping through assigned hoops. (Some students took on thetask of helping with the school's administrative computing; this work wassomewhat less self-directed, but even more real, than the student-initiatedprojects.) A lot of effort went into video games, using the limitedcharacter-based graphics of the VT-100 terminals. One student wrote anEMACS-like text editor, called JOVE, that's still widely used at Unix sites.Not all students took to programming, but many more learned to use the wordprocessing facility for their papers for other classes. (One year I hadthree or four students who were also taking a chemistry class, in which theteacher had said they could bring one page of notes into the final exam.These students collaborated on designing and printing a page, using thesmallest available font, to cram in all their notes!)

One reason that Logo itself wasn't popular among these students was thetechnical limitations of the facility. Graphics terminals were veryexpensive in those days. We did have a few Atari 800 computers that we usedas graphics terminals (Atari Logo hadn't been invented yet), but they couldonly handle 40-column text, so they weren't good for much other thangraphics. The Logo interpreter we cobbled together for Unix was very slow.There was no hardcopy graphics capability. We did also have some Terrapinfloor turtles, but they were unreliable.

Another Logo-like aspect, however, was the social interaction in the lab.There was no formal class time; people would come and go to use the machineor just to hang out. An organization of students took responsibility forrunning the lab, and its members were given keys to the room so that theycould use the machine without supervision evenings and weekends. (Nothingwas ever stolen, and there was very little breakage.) Kids set up their ownworking partnerships; more experienced kids taught newcomers. Most of myeffort went into this meta-curriculum rather than into teaching programming.It didn't always go smoothly; there were fights, violations of privacy, andthe like. But we all saw these problems as community problems, not just assomething for me, the teacher, to deal with.

(To make this focus on community sound a bit more serious, and perhaps more'Logo-like,' let me discuss it in Piagetian terms for one paragraph. Byhigh school age, kids are supposed to be at the highest stage of cognitivedevelopment, the Formal Operational stage. In a certain sense, there isnothing more for them to learn, cognitively. On the other hand, high schoolkids are still far from the top of the scale in moral development. So itmakes sense that issues of community and responsibility should be central totheir education.)

To sum up, my high school computer lab felt to me very much a Logo-likelearning environment, although Logo itself was a minor component, andalthough many of its characteristics are ones that Seymour Papert listsas non-Logo-like: the equipment was concentrated in one room, thecurricular focus was on computing rather than on math or other areas,and the style of work was primarily the formal, abstract, goal-directedstyle that Seymour criticizes as male-oriented.

I currently teach undergraduates at the University of California atBerkeley. Our introductory computer science course was developed at MIT[Abe85]; one of the developers is Hal Abelson, a Logo old-timer who led thefirst microcomputer Logo development projects for the TI 99/4 and the AppleII. The course uses Scheme, a dialect of Lisp that's similar to Logo in manyways. (At Berkeley we've even modified Scheme to add the Logo word andsentence primitives, so that our students can write Logo-like languageprocessing programs.)

Is this course Logo-like? How I feel about that question depends on mystandard of comparison. In a recent paper [Har91] I compare the Abelson andSussman course with more traditional, Pascal-based, software engineeringcourses; by that standard, our course feels very Logo-like indeed. Thetraditional course is full of commandments about programming style, tellingstudents what they should and shouldn't do. The traditional course mustspend a lot of time on programming language syntax; our (dare I say)Logo-like language has a simple syntax that takes hardly any instructionaltime. Students work on programming projects that are designed to illuminatebig ideas in computer science: ideas that help the students write programs,rather than abstract theoretical ones.

But compared to my high school experience, this course doesn't feelLogo-like at all. The style is very different, first of all. I givelectures to groups of 300 students. Then the students go to the computerlab to do their assigned projects, but I'm generally not in the lab withthem. (We do have teaching assistants in the lab at scheduled hours.)The projects are assigned, rather than student-initiated.

In the six years I've been at Berkeley, I've taken some small steps towarda learning environment that feels slightly more Logo-like. For example,we used to assign weekly homework with exercises from the textbook. Now Iassign the exercises, but don't collect them, so that it's clear to thestudents that the exercises are for their own benefit and not for evaluationpurposes. I've instituted cooperative learning, redesigning the programmingprojects to be done by groups rather than by individual students. These arevery tiny steps to be discussing at a Logo conference! But they go verymuch against the grain of the context within which I teach. The introductorycourse is part of a curriculum ladder, and later courses depend on'covering' the curriculum. The students, in these bad economic times, tendto be much more worried about competing for jobs than about learning.

The irony in all this, as we'd expect from our Logo experience, is that thestudents who end up doing best, even in the job market, are the ones who canfind the courage to forget about jobs and grades and jumping through hoops,and treat my course as if it were a more Logo-like environment, gettingexcited about the new ideas and pushing beyond the required work toinvent and explore new programming techniques.

When I was an undergraduate myself, I was lucky enough to fall in withthe gang at the MIT Artificial Intelligence Lab, which was for me theperfect prototype of a Logo-like environment even before there was Logo.On the one hand, everyone was engaged in real work, pushing the state of theart in computing, but on the other hand, nobody felt any pressure about it.It was all for fun; you could try anything, and if it didn't work out, youjust tried something else. (But don't forget that the hacker spirit at thatlab is also the prototype of the style of work that Papert and Turkle callandrocentric.)

How are the Two Related?

After this long preamble, I think I'm ready to talk about the question inthe title of this paper. There are two different ways of looking at acomputer science lab that both seem connected somehow to the Logo-like scale.The more obvious one is about style of work; as I've been saying, from thatperspective, my high school lab felt extremely Logo-like, and my universitycourse doesn't. This is the question that I've inadequately represented as'Fun vs. Professionalism' in my title.

The other is the more technical question about curriculumand programming language. There is a very sharp distinction between thesoftware engineering approach and what I think of as the artificialintelligence approach. In the software engineering approach, students arebeing trained primarily to be disciplined in their programming style, sothat their code can easily fit in with other people's code. The curriculumis full of rules; the programming language used is always one with strongtyping and similar restrictive rules. Software engineers talk about objectoriented programming, for example, primarily as an advance in informationhiding: An OOP language is one in which procedures as well as data havevery tightly limited scopes. The AI approach replaces this moralistic tonewith the cultivation of a sense of wonder at the ways in which thinkingharder about programming can pay off in increased expressiveness. In thisapproach, there isn't one correct way to program, but rather a world full ofprogramming styles and structures, each one appropriate for certain kinds ofproblems. On this view, for example, object oriented programming is about ametaphor, expressing a kind of parallelism in which each datum has its ownintelligence, rather than about discipline.

This division, the one I've called 'Symbolic Programming vs. SoftwareEngineering,' is fundamentally about the philosophy of computer science.It seems quite different from the question about style of work, but I thinkI can find some similarities.

One difference between a Logo microworld and an ordinary piece ofeducational software is that in the Logo version, the program itself isavailable for inspection and modification, not a black box. In the study ofcomputer science, a programming language is itself a microworld. That's whythe Lisp tradition of introducing even beginners to the workings of the Lispinterpreter is Logo-like: By examining and modifying the interpreter, weturn the Lisp microworld into a glass box instead of a black box.

A crucial part of a Logo classroom is that the learners have permission toexplore using their own individual styles. There isn't just one right wayto program. Similarly, in the symbolic programming approach to teachingcomputer science, there is no orthodoxy about top-down structuredprogramming. Top-down is one fine approach, but so is tool-building withouta specific goal in view.

Symbolic languages, and languages with relaxed attitudes toward data types,allow for programming projects about sentence generation, carrying onconversations, the automated psychotherapist, and so on. These projects arevery much in the Logo tradition, and in contrast with the heavy emphasis onnumeric computation that's typical of the software engineering languages.

Logo-Like Languages Revisited

Finding these examples in which the technical details of a programminglanguage and a curriculum seem to be connected with working in the Logospirit gives me the courage to return to the question of languages and hopethat in so doing I'm still addressing the question that was given to me.

In my 1982 Byte article, I listed several characteristics that seemed tomake Logo special. [Har82] Let me go through the list and comment on wherewe stand in programming languages today.

Procedural. We seem to have won this battle. EvenBASIC, in its modern dialects, allows a modular program structure. In fact,procedural languages are now the right wing of language design, in contrastwith newer approaches such as functional, object-oriented, and logicprogramming. Some recent versions of Logo address the issue of parallelism,although that newer Logo technology is not yet, I think, widely understoodamong the people actually using Logo in schools.

The issue today that corresponds to the one about procedural programminglanguages a decade ago is that many people don't want to deal with languagesat all. Instead, modern software provides a graphical user interface, withmice, buttons, menus, and so on. Even Logo has not ignored this trend;LogoWriter on the Macintosh is full of immediate-mode graphical controls forthings like moving and turning the turtle by hand. I think the battle wehave to fight is to maintain the position that immediate-mode control isn'tenough, because it doesn't allow for the abstraction of regularities andpatterns of work. There must be a way to create control structures that cancarry out the same operations that can be performed graphically.

Interactive. This is a crucial issue, and the terms ofthe debate have changed dramatically in recent years. Originally, there wasa clear-cut distinction between interactive languages such as Logo, Lisp,and BASIC, and non-interactive languages like C and Pascal. The style ofwork in the non-interactive languages was awful. Programmers had to writetheir programs in an environment entirely separate from the language itself,then go through a compilation process, and finally run the program, oftenwith no runtime support for debugging or modifying the program. Theirexcuse was that a compiled program runs much faster than an interpreted one,and indeed the Logo interpreters of that time were unpleasantly slow.

The characteristics of the underlying languages have not changed. Buttoday's Pascal or C programmer works with an integrated development system.There is a text editor that understands the syntax of the particularlanguage, so that it can check the form of a program as you write it. Thereis interactive debugging, generally using a window system effectively sothat the debugging information is visually separate from the output of theprogram itself. You still can't walk up to a C compiler and ask it to print2+2, and yet today's C programmers are likely to complain that a Logoprogrammer suffers from an insufficiently interactive working environment!For myself, I still find interaction with the actual programming languagemore powerful than these auxiliary interactive tools, but I'm not surewhether that's just because I'm accustomed to an old-fashioned style of work.It can certainly be argued that commercially available versions of Logo havemoved backward in their provisions for debugging support; Apple Logo allowedthe user to enable an automatic PAUSE in case of an error, but LogoWriterdoesn't.

Recursive. In the early Logo work, learning aboutrecursion was a crucial step in intellectual development. Ideas like thelittle person model of procedure invocation were invented mainly to help inunderstanding recursion. In one sense, this battle seems to be behind us;every modern programming language allows recursion. But the conventionalwisdom in computer science education is that recursion is too costly forordinary use; students are taught to prefer iterative language mechanisms.Meanwhile, except for drawing fractals, Logo users rarely use recursion in away that couldn't be handled by conventional iterative language constructs.(Indeed, part of my technical work has been the introduction of iterativeconstructs to Logo.) I think it's still worth remembering that recursion isa single mechanism with remarkable expressive power. For example, thesedays it's easier to draw a circle in a canned drawing program than in Logo,because the canned program has a dedicated circle feature; but the drawingprogram can't use its circle feature to draw spirals or stars.

List Processing. Logo is still out in front on thispoint. Even other dialects of Lisp don't make the manipulation of words andsentences as convenient as it is in Logo. If you want to conjugate a verbor take the plural of a noun, Logo is the language of choice. On the otherhand, I think it's still true that most actual Logo users consider listprocessing to be arcane and difficult. LogoWriter fans often prefer tomanipulate text by carrying out a sequence of text editing commands on therepresentation of the text on the screen, rather than apply recursivefunctions to the text taken as data. My hope is that a good collection ofhigher-order functions like MAP and FILTER can make list processing seemmore palatable.

Untyped. This is probably where you'll find the mostheated arguments between symbolic programming enthusiasts and softwareengineers. The lack of type declarations in Logo, and in Lisp generally,makes programming enormously easier to learn; the software engineers,though, think it's sinful. The real argument for typed variables is thatthe compiler can produce more efficient programs, but the theoreticalargument is that restricting a variable to a particular type makes for moredisciplined programming. (It also makes for ludicrous user interfaces, incases where the natural thing is to read numbers until the user sayssomething like 'DONE' to indicate the end of the numbers. Instead, thetyped languages make the user type something like '9999' or '-1' to indicatethe end.) Some computer scientists will say that the advent of objectoriented programming has settled this question in favor of strong typing,but the example of Object Logo shows that that isn't so.

Extensible. We are beginning to win this battle when itcomes to application software. Many large programs these days include a'scripting language,' such as Hypertalk as the scripting language forHypercard. But mainstream programming languages are not generally viewed asbases for building language extensions, except in the sense that you canwrite a full interpreter or compiler from scratch. This property is stillvery important in Logo practice, because it's the technical basis formicroworlds. Any Logo programmer (not just the implementors at the softwarecompanies) can develop an extended Logo with extra primitives for somemicroworld.

Interesting Applications. New applications are inventedvery fast these days. Logo is in the lead in some cases (robotics, withLego-Logo), hustling to catch up in others (MIDI support recently added toObject Logo), and not really in the running for some (real-time animation,unless you have a massively parallel computer on which to run *Logo). Theproliferation of special-purpose software tuned to each of these applicationareas raises the question of whether we can reasonably expect anygeneral-purpose programming language to be a good match in every case. Inthe old days, the appeal of Logo programming wasn't so much the act ofprogramming itself as the results you could tease out of a computer; todayyou can get more spectacular results without programming at all. This iswhy there has been a vast decrease in the amount of time spent onprogramming in schools in the past few years; students are using applicationprograms instead. Is this good or bad? In a way the issue is similar tothe one that we argued about when Sprites were introduced in TI Logo: 'It'stoo easy to get pretty pictures on the screen in immediate mode, so kidswon't learn to think procedurally.'

User-Friendly. In the old days we made a big fuss aboutthings like the text of error messages and the names of primitives. Thistradition is still alive in Logo; the switch from OUTPUT to REPORT inLogoWriter is an example. But a new generation of computer users accustomedto point-and-click interfaces would question the user-friendliness of anyLogo environment. I think we have to admit that Logo syntax, althoughbetter than Pascal, is still far from transparent. Can we develop morecompelling notations without sacrificing the essence of programming? Iguess this is what Boxer is about, in part.

No Threshold, No Ceiling. We are starting to see adivision of the Logo using community. Products like LogoWriter aredeliberately aimed at the young kids who make up most of Logo's actualaudience. Object Logo is a high-end version for more advanced programmers.I've found it necessary to implement my own version, Berkeley Logo, just sothat there will be a more or less unchanging interpreter for the languageused in my books. In principle I suppose this is a good thing, because itallows us to extend the limits of Logo usability in both directions. But Iwonder whether Logo's rather small audience can support so many separatedevelopment teams.

To sum up, some of the technical issues that seemed important a decade agoin distinguishing Logo from other languages are no longer at issue, such asprocedural organization and recursion. Others burn as brightly as ever:list processing and untyped variables. Most interestingly, others havechanged into different issues, especially the ones about user interfaces,such as the definition of interactiveness.

References

Abelson, Harold, and Gerald Jay Sussman with Julie Sussman. Structureand Interpretation of Computer Programs, MIT Press/McGraw-Hill, 1985.

Harvey, Brian. 'Why Logo?' Byte, vol. 7, no. 8, August, 1982.

Harvey, Brian. 'Symbolic Programming vs. the A.P. Curriculum,' TheComputing Teacher, vol. 18, no. 5, February, 1991.

Topaz Labs Plug-ins Bundle for Adobe Photoshop DC OverviewTopaz Labs Plug-ins Bundle for Adobe Photoshop DC is an awesome application which will enhance your photo in such a way that you will be mesmerized. Topaz labs for mac 2017 free full. Download Topaz Labs Plug-ins Bundle for Adobe Photoshop DC For Windows and Mac. Offline installer standalone setup of Topaz Labs Plug-ins Bundle.

Papert, Seymour. 'An Evaluative Study of Modern Technology inEducation,' MIT Logo Memo 26, June, 1976.

Papert, Seymour. The Children's Machine, Basic Books, 1993.