Re: Vector themed issue: How to wear sheepskin

Polivka@xxxxxxx <Polivka@xxxxxxx> wrote:
On point one, what sort of applications are of interest to the ?main
stream? programmer?

A HUGE one is games of any and all kinds. Understanding that this is a
large topic, let's take a look at some popular open source repositories
and see popular projects people are working on.

Ten most popular projects from Fresh Meat (http://freshmeat.net/),
a well-known place where open source authors distribute their work:
-------------------------------------------------------------------

1. MPlayer
MPlayer is a movie and animation player that supports a wide
range of codecs and file formats, including MPEG 1/2/4, DivX
3/4/5, Windows Media 7/8/9, RealAudio/Video up to 9, Quicktime
5/6, and Vivo 1/2. It has many MMX/SSE(2)/3Dnow(Ex) optimized
native audio and video codecs, but allows using XAnim's and
RealPlayer's binary codec plugins, and Win32 codec DLLs. It has
basic VCD/DVD playback functionality, including DVD subtitles,
but supports many text-based subtitle formats too. For video
output, nearly every existing interface is supported. It's
also able to convert any supported files to raw/divx/mpeg4 AVI
(pcm/mp3 audio), and even video grabbing from V4L devices.

2. Linux
Everyone should know what this is.

3. cdrtools
cdrtools (formerly cdrecord) creates home-burned CDs/DVDs with
a CDR/CDRW/DVD recorder. It works as a burn engine for several
applications. It supports CD/DVD recorders from many different
vendors; all SCSI-3/mmc- and ATAPI/mmc-compliant drives should
also work. Supported features include IDE/ATAPI, parallel
port, and SCSI drives, audio CDs, data CDs, and mixed CDs, full
multi-session support, CDRWs (rewritable), DVD-R/-RW, DVD+R/+RW,
TAO, DAO, RAW, and human-readable error messages. cdrtools
includes remote SCSI support and can access local or remote
CD/DVD writers.

4. Apache
An extremely popular web server.

5. gcc
The GNU C compiler suite.

6. VLC media player
VideoLAN Client (VLC) is a media player, streamer, and encoder for
Unix, Windows, Mac OS X, BeOS, QNX, and PocketPC. It can play most
audio and video codecs (MPEG 1/2/4, DivX, WMV, Vorbis, AC3, AAC,
etc.), has support for VCD, SVCD, and DVD (with menus), and can
read or dump streams from a network source (HTTP, UDP, DVB, MMS,
etc.). It can also act as a server and send streams through the
network, with optional support for audio and video transcoding.

7. PHP
PHP is a widely-used Open Source general-purpose scripting
language that is especially suited for Web development and can
be embedded into HTML. Its syntax draws upon C, Java, and Perl,
and is easy to learn. PHP runs on many different platforms and
can be used as a standalone executable or as a module under a
variety of Web servers. It has excellent support for databases,
XML, LDAP, IMAP, Java, various Internet protocols, and general
data manipulation, and is extensible via its powerful API. It
is actively developed and supported by a talented and energetic
international team. Numerous Open Source and commercial PHP-based
application packages are available.

8. TightVNC
TightVNC is a VNC distribution with many new features,
improvements, and bugfixes over VNC. It is optimized for faster
operation on slow network links such as modem connections,
provides more configuration options in the server, features
automatic SSH tunneling in the Unix vncviewer, and more. The
modified servers and viewers are fully compatible with the
original VNC software.

9. PostgreSQL
A very popular database engine.

10. MySQL
The other very popular database engine.

In my tounge in cheek opinion, it looks like the most popular things
at freshmeat concern themselves with watching/recording media, telling
people and writing about it (web servers, PHP), keeping track of
things, and tools which allow them to develop the aformentioned things. :)

From Source Forge (http://sourceforge.net/):
--------------------------------------------

Hrm, there is a vast amount of software in there. I'll give a sample
of popular stuff I find in various catagories. Most of these are written
in Java or C/C++.

[Game platform simulator for very popular older games]
1. ScummVM is a cross-platform interpreter for several point-and-click
adventure engines. This includes all SCUMM-based adventures by LucasArts,
Simon the Sorcerer 1&2 by AdventureSoft, Beneath a Steel Sky and Broken
Sword 1&2 by Revolution, and many more.

[Budget planing and forecasting]
2. Adaptive Planning express is an open source solution that allows midsized
companies and departments of large corporations to move beyond Excel
and automate budgeting and forecasting. Too busy? Try the free, hosted
version to get started in 2 minutes at http://www.adaptiveplanning.com

[Living quarter layout software]
3. Sweet Home 3D is an interior design Java application for quickly
choosing and placing furniture on a house 2D plan drawn by the end-user,
with a final 3D preview.

[Wow, this was written in LISP! A math package.]
4. Maxima is a fairly complete computer algebra system written in lisp
with an emphasis on symbolic computation. It is based on DOE-MACSYMA
and licensed under the GPL. Its abilities include symbolic integration,
3D plotting, and an ODE solver.

[Physics is always cool.]
5. Open Dynamics Engine is a free, industrial quality library for
simulating articulated rigid body dynamics - for example ground vehicles,
legged creatures, and moving objects in VR environments. It's fast,
flexible & robust. Built-in collision detection.

[Geneology]
6. PhpGedView is a revolutionary genealogy program which allows you
to view and edit your genealogy on your website. It has full privacy
functions, can import from GEDCOM files, and supports multimedia. It
also simplifies family collaboration.

[Security bookeeping]
7. Password Safe is a password database utility. Users can keep their
passwords securely encrypted on their computers. A single Safe Combination
unlocks them all.

[A popular thing due to the rise of social networking sites like Facebook,
LinkedIn, MySpace, etc]
8. Social Networks Visualiser (SocNetV) is an SNA tool for Linux. With
it you can draw a network or load an existing one (Pajek, Sociomatrix
or dot-formatted). It computes social network properties, centralities
and implements some layout algorithms.

[Analyzing webserver logs]
9. AWStats is a free powerful and featureful server logfile analyzer
that shows you all your Web/Mail/FTP statistics including visits, unique
visitors, pages, hits, rush hours, os, browsers, search engines, keywords,
robots visits, broken links and more...

[For the armchair astronomer]
10. Stellarium renders 3D photo-realistic skies in real time with
OpenGL. It displays stars, constellations, planets, nebulas and others
things like ground, landscape, atmosphere, etc.

Perhaps you had in mind inquisitive type programming. It is basically
personal problem solving. It is a fine way to learn what a programming
language can do. I believe that is what you were doing creating a
tic-tac-toe programming.

Sure, I use this method to learn a new programming language, but once
I learn it, I want to then develop software with it. Much like the
yin/yang symbol, you can't have one without the other. Scheme, like APL,
also has a workspace (called toplevel) and you can interactively type
in your stuff to check to see if it works and build up the solution.
In general though, you can't save your toplevel, you just store the
code into a file and load it later if you want to use it again. The two
languages really do share a lot in user experience.

Perhaps you are not aware that the APL community
produces two quarterly APL publications: Vector ? the excellent
publication out of England, and Quote Quad from the ACM?s Special
Interest Group on APL. Unfortunately the ACM shut down SIGAPL so I
don?t know the future of Quote Quad. I mention Quote Quad since in
the last three issues I posted a problem for the readership to solve.
If you wish to try some APL problem solving look at them and their
solutions. I believe those Quote Quads are online. If they are not,
I can provide you copies.

I was slightly aware of Vector and Quote Quad, but I never realized
their importance until much later. While the information there is
highly valuable and pertinent, it is also not enough. I can go to the
web and find thousands of pages from unrelated people on how to do all
manner of things in C, and maybe three dozen for APL from Vector and
the vendor's sites. More users will produce more pages. They will
create content for free!

Think about it. Humanity writes encyclopedias (Wikipedia) for free and
for fun!

On point two, yes APL is dense, but that is the nature of APL. It is
no different than reading a *** of Mozart?s music or a Chinese
newspaper. You have to learn the language. How do you introduce APL?
Actually there are two parts to that question. They are ?how do you
introduce APL for those who wish to learn about it?? verses ?How do
you introduce APL for those who wish to use it?? .Over the years, I
have had the opportunity to coauthor three books on APL. They are
focused on those learning to use APL. I am still looking for the
?Holy Grail? of introducing APL to those who wish to know more about
it.

On point three, can you give me an example on what would draw folks to
APL? You mention ?little pieces of cookbook-y software?. Each of the
vendors of APL provides public libraries full of interesting
functions. Also because of the conciseness of APL, there are
collections of idioms. For example IBM produced a 75 page document of
idioms. The Finnish APL community also produced an extensive list of
APL idioms. You speak of using APL+ I believe it is in a quiescent
form right now with no further development. At least three major APL
vendors make available ?complete? trial versions. You should look
into them.

[rearrange]
I have taught APL for many years. As a result I have
been collecting problems and exercises. The original purpose of them
was to offer the student who had finished an introductory APL course
additional APL practice. Would problems and their solutions like this
be of interest to programmers like yourself?

You bet that would be of interest! You are in a special position with
your combined APL and teaching knowledge. Most APL tutorials I see
basically just explain the language, but without much context as to why
the language and idiomatic constructions of it have meaning beyond naive
examples.

What I think is sorely needed is a book similar to this for APL:
http://mitpress.mit.edu/sicp/

Read the full text of it for a while from the beginning to see how it
introduces the Scheme language, and most importantly, what it means
to think in a functional manner. APL needs an analagous book to
teach the "way of thinking" of APL plus some of the common idiomatic
constructions. You said so yourself in this quoted portion from another
part of this thread:

You wrote:
But let me raise a word of caution. I have seen some of the APL
code written by ?other field ? folk who were exposed to the rudiments
of APL. It was not good APL. It often consisted of hundreds of lines
of branching/looping code buried in niladic functions. Not that I am
faulting them, after all, many of them came from a Fortran, Basic, or
other sequential programming language background. Yes some came with no
programming background at all. This is what often happened when these
very competent people were told to go read up, self study, and learn APL.
Maybe it doesn?t matter if the result gets the job done.

If you write the imperative style in a functional language, you get the
exact same horribly written code.... The SICP book adresses this issue
directly by not even showing you how to do it imperatively--the nature
of the book is to say "Here's how it is perfectly done." and to show the
annotated implementations of sizable and real problems. People aren't
going to deduce how to think in APL, given the general method of Computer
Science schooling in a mainstream object oriented or imperative language,
just by being shown the operators and basic syntax--they need to be shown
the _correct method of thought_. The failure you mentioned happened when
the users "read up" in APL, they weren't reading the right things because
the right thing wasn't there! "Reading up" in scheme means reading SICP.

The Finnish APL idiom library is awesome (and I didn't even know about it
until right now since it didn't even occur to me APL would have so many
common idioms), but it is too condensed. The idioms need to be placed
into a graded and meaningful context, into a "story of implementations
of realistic problems" where the idiom shows the power of its use. You
could leverage your large set of problems/solutions to provide a graded
movement of the user through APL's expressive nature and provide example
for the appropriate use of idioms.

Standardization here would be a *fantastic* win especially if most or
all of the APL idiomatic constructions already worked in all the various
vendor implementations. If this is already the case, the vendors do
no work other than a few people writing the document, and everyone can
immediately claim comformity.

APL isn't alone with its idioms, perl has such a thing too:
http://dave.org.uk/perlwhirl/idiomatic.pdf

In thinking about it, it looks like there would be 3 parts to an APL
standards document:
1. Core Language
A. Rationale
B. Description
C. Available Operators
D. Functions
E. Interacting with the outside world, file i/o, etc
2. Standard library
3. Standard idioms
A. Dialog on appropriate use.
B. Big list of idioms

I will let others comment on point four.
[snip]
If you really don?t understand the language why bother to bridge anywhere.

In my experience, this viewpoint is not correct. The reason is that
suppose a really good C programmer already knows OpenGL and a few other
languages. They might come to APL and think, "Wow, I could totally
figure out all of those gradients to this crazy implicit surface
problem in 100 characters of APL instead of thousands of lines of C,
now, how do I graph the ones of interest to me?" and immediately want to
know how to use the bindings to OpenGL--like he had in other languages.
The hypothetical developer is pretty smart and could figure out any kind
of binding in a few hours or so. This is pretty common, really. Often
people want to bind against some well known GUI toolkit, or some other
kind of well-known library.

On point five, why would you want to write a hash table if only to
illustrate it educationally. Then just implement the algorithm just
like you would with any another programming language. APL is more
than linear algebra. Again look in the vendor?s public libraries and
Vector for starters.

The problem here is that I have to look in the vendor's libraries and the
archives of an online magazine. The information is in the wrong place.

Typing in "C Hash Table" into google brings me to a first link here:
[Hrm, some of that is idiomatic C++ rendered into C, strange]
http://www.cl.cam.ac.uk/~cwc22/hashtable/

Noone cares about what vendor that code will work on, it'll work
everywhere. Also, notice it isn't hosted at a vendor site and is off some
random guy's website--ranked FIRST by google for such an important topic!

This "ask google for the answer" is so prelevant in modern geek culture
that it might as well be as second nature as breathing.

The real problem is that why do I have to look at a specific vendor's
public libraries when there should already be plenty of pages which
describes an idiomatic implementation of a hash table in a vendor
independent APL? That would be like searching through GCC's archives for
how to implement a linked list traversal in idiomatic C. The truth is
you look in the K&R ANSI C book, IIRC, book for how to do that, or any
random non-vendor specific textbook for C.

Basic Computer Science algorithms should not be buried in public libraries
of vendor implementations. They should be prominently displayed with
code that works everywhere because this is what people are going to need
to use right when they start coding something important in APL. The
idiomatic expression of those algorithms should be near to the first
thing a potential user finds as it relates the experience of APL to the
rest of the languages they already know.

On point six, all APL vendors support ?core? APL language. If you
choose to program in core APL it will run on any of the vendors? APL.

Then this Core APL, barring the arguments about conflicts operators,
should be the premise of a standardization document. The work is already
done--the commonality exists. Just write it down, stick your names on
it, and think about the next revision of Core APL which increases the
standard set of APL.

If there are conflicting operators, then the vendors pick one, causing
work for some vendors, not for others, and a command line flag implements
the standard. It seems natural to me that eventually all vendors would
have to put some work into being in conformance. The load is ultimately
shared.

On your seventh point, there is movement in that direction. Dyalog
APL is holding a student contest in conjunction with its forthcoming
Dyalog APL conference. Of course, money is a fine incentive, but so
is the pride of winning. That can lead to another more important
incentive; a job interview and a job. There are programming contests
about. I find it frustrating that they often restrict the programming
languages that can be used. I?m sure that the APL community could
judge any APL entries. I am still smarting from a past event. I
offered to work with a local high school computer club provided I
didn?t use or teach them APL. Why, it was too easy!

Directly, this comes to the topic of the conciseness of APL. You can
say a lot in a few characters. This isn't a problem or a bug in the
language at all, but a very great feature. The trick is to describe
how to write more and more complicated APL without having to resort to
powerful statistics or mathematics to pull examples from. Usually, this
is resolved by doing symbolic processing--example, reading entries of
CD titles from a flat file "database", sorting/displaying them, and
allowing the user to ask questions about what is in the "database",
and adding/deleteing from the database which can then be saved to disk.

There are a lot of things in that tiny project which don't require
powerful mathematics for the user to understand, yet they can still write
a fair amount of APL to do the job. These types of problems is what
easily introduces APL to people that are non-mathmeticians. However,
doing in the "APL method of thought" teaches them how to think like
mathmeticians, even if they don't realize it....

Now let me ask you, how did you come onto APL? What attracted you?
Peter I have been involved with APL for many years coming from a
background of programming in binary (for Illiac), assembler and
Fortran. Therefore I can?t speak for the vast assortment of other
programming languages. But I can say APL continues to be an
intellectual challenge and fun to use.

Actually, the thing that attracted me was the character set itself. As a
hobby I research programming language theory, design, and implementation.
This leads me to experiment with many languages and learn them enough to
understand why they happen to be so useful.

(A consequence of my hobby is I'm writing a scheme compiler, which is
why I happen to understand some of the general problems with APL since
the two langauges are in a reasonably similar position and I had to
understand Scheme's point of view before devoting 5 years of my life to
writing a compiler for it).

I wanted to see just how concisely I could write an algorithm and
thought of the Chinese, etc languages where symbolic (fixed width if you
squint) characters stood for entire concepts. How wonderful it would be,
I thought, if I could convert the reasoning of thousands of lines of
C into executable characters on a single *** of paper--sort of like
compressing the representation of thought itself. I was going to try and
mix functional programming concepts (especially map, filter, reduce,
lexical closures, recursion, etc) with APL's array based processing
(possibly implementing a new dialect) because I thought it would make
for something very interesting--especially if one could design their own
glyphs representing functions and integrate them into the language. It
always bothered me that I had to write ascii function names for new
functions in APL--why throw away the one really special feature of the
language as soon as you try to extend it? I imagined a custom glyph
associated with the ascii name and you'd see the ascii name as a tooltip
with the mouse. I wanted sweet, sweet code density.

Of course, this is all pie in the sky nonsense which will probably go
nowhere, but it is the direct reason why I came to APL, and not to
something like J.

Hrm, this post is too long. I'm stopping the writing of it....

Thank you.

-pete









.