KEY:

Writers comments look like this.
References to my earlier comments look like this.
References to my current comments look like this.

Mail: 1/10/02

$$--------------------
I expect the rudimentary documentation to be complete by the end of February. If your need is sooner, please contact me and I'll make adjustments. GLEE is useless until people learn to use it

. Sounds great! - End of feb is fine with me however if you have anything however rough which you have knocked up already, I would be intetrested in seeing it (however rough) - but please don't go altering your plans - it is far more important that Glee develops at a robust rate, that satisfying one users needs.

I think you'll see something from me sooner than later. It's in my best interest to get this work done.

I am a doing my PhD @ University into design methods when developing in Functional Vector Oriented Languages, and have been considering K, J, A+ and QNial so far.

Is there a reason APL is not in this list?

My background is in K, which I have developed substantually in for the last few years. QNial was recommended due to it aledgedly being very usable, although almost exclusively unused by anyone ;-). J was recomended to me as being very developed (in terms of ideoms, etc) and from my basic development work in it seems very strong. It also has the advantage of being free (as opposed to k). A friend of mine is a heavyweight consultant in the Genomic/Proteomics sector who used J and has offered me some help and case analysis opportunities. A+ was a questionable language (my thinking being that K is a later evolute of A+ from the Whitney factory). As of yet I have done very little (virtually none) on A+ though. APL would probably afford my work wider readership though, however I have been advised that it it is a little stayed in terms of its development and thus may just give me the 'lowest common denominator' of the FVOLs (although I do not know how reliable that is though!). Are you aware of existing APL design method research? What is your opinion?

I don't know what design method research is. My last experience with APL was with APL 2000 (formerly APL Plus) and just before that with Dyalog APL from Dyadic Systems. That was back in 1995. I worked with APL from 1970 up to 1995 and haven't touched it since. APL is the father of all these languages being born by Ken Iverson back in the 60's. He is also the designer of J.

I need to get my head round GLEE's semantics (hopefully duing Jan, but I have a couple of jobs on the go so my research deadlines may fluctuate somewhat ;-) ), which I will do in the form of a prelim comparative study with the other FVOLs. When that is done, I will be back in touch.

Fine. What does the F stand for in FVOL? I hope I don't disappoint you with the triviality of Glee's semantics. I'm not a computer scientist and I didn't lay out formal semantics for Glee. Rather, it was born out of my software sculpture techniques. The computer itself has told me much about how Glee should be put together. Fundamentally, it's just left to right parsing for data and operators. Dyadic operators take precidence over monadic operators which take precidence over Niladic operators. It has short right scope. It uses parenthesis to override execution order; uses [ ] for indexing and function calls; and uses { } for namespace control. It uses the $ as a special escape character for debugging features. It uses # as a special escape character for non-symbolic program (operator) names like #SIN, #COS, #LN, etc. It uses : as the special escape character for control structures like (:IF( ){ } :ELSEIF( ){ } :ELSE ( ) { }; and :FOR( ){ }; and :SELECT ( ) { :CASE( ) { } }; etc. Re. Getting your head around all this ... you can be a big help to me having been formally trained. You can help me ligitimize GLEE (or at least know what is illegitimate about it).

Any idea what the speed of execution & scalablity is like for glee? (Again - if you have not already done this, please don't go altering your schedule - I can do scalability tests at the Uni, and get you copies of the results.)

The fundamental operators (e.g. +\ ) run very fast. Glee makes no attempt to do just in time compiling so looping is a pig. However, I am able to do something like 7,500 iterations/sec. with an empty :FOR loop on a Pentium 400. This should be good enough for most work as you only loop in those cases you can't line your data up to be mowed down by vector operations. Boolean operations are slow right now because I don't work with them in 8 bit chunks. That will be one of my first optimizations. I have a axiom I try to keep in mind: Optimize Early, Arrive Late. Here's my crude timing code:

1000=>n; 1e4=>m; 1..m=>k;k=k=>b;
$* loop 1000 times on a 10,000 integer vector *$
#clock => c; $$ start the clock
:for(1..n){b&b;}; $$ do the looping
$* read clock; divide by loops; reciprocal; times boolean tests *$
c. /n / * m

On my Pentium, this comes out about 2.6 million boolean ops per second (indexing into each bit). It should be hard to time when I get done changing the algorithms.

BTW: You should be able to cut and paste this right into your GLEE interpreter to see how it works on your machine.

All the best & keep smiling (with glee),

Thanks. Life is good ...
WithGLEE,
/Todd
http://WithGLEE.com

Mail: 1/9/02

$$--------------------
I have been looking over with glee at Glee (excuse the pun) and was wondering if there are any sample applications that you have written in glee that you could make available.

First, I like the pun. As soon as I document basic GLEE fundamentals I will begin a Case Book section. My plan is to include in it coding examples for a wide range of real world computing problems. Initially I will have cases for revealing duplicate files on disks; for vulturing website logs to see browsing patterns and activities; a suite of functions for doing simple present value and mortgage calculations. Then I intend to start through my Perl5 book and illustrate the GLEE way. Finally, I'll go through my Java books and illustrate the GLEE way for Java. I expect the rudimentary documentation to be complete by the end of February. If your need is sooner, please contact me and I'll make adjustments. GLEE is useless until people learn to use it.

I am a doing my PhD @ University into design methods when developing in Functional Vector Oriented Languages, and have been considering K, J, A+ and QNial so far.

Is there a reason APL is not in this list?

I would like to add Glee into my research too, but with it being so new and the limited examples out there, it is taking a substantial effort for me to learn.

I am flattered you would consider GLEE for your study. If you know a way I can make your learning experience easier, please request it. GLEE's concepts are simple and they are few. But GLEE capabilities are broad, robust, and ever expanding.

All the best though - Glee looks pretty cool from what I have ssen so far. Keep up the good work! Cheers,

Mail: 1/4/02

$$--------------------
How does GLEE differ from other array oriented languages?
You know APL. Great! I was using it in 1981-1987 while in university. I loved it's capabilities with arrays. I disliked the missing abstraction abilities.
I first saw APL in 1969 and began using it in 1970 to produce "barometer" reports for the logistics research group I worked in at Caterpillar. In 1974 I went into APL full time doing much work for Exxon and others as a Regional Manager for Scientific Time Sharing Corp. In 1978 I became an independent consultant specializing in APL. In 1987 I abandoned APL (there were very few companies willing to use it and those that did were quitting) for C and then C++. I took a major productivity hit. In 1999 I started on the creation of GLEE to get my productivity back.
Right now I'm doing distributed air pollution data management and browsing. So far it's mainly object oriented, dealing with images, observation tables, web services, geographical information etc. and implemented with c# and python.
We need to stay in touch. One of the powers of the implementation of GLEE is my ability to create new operators in amazingly short time. These operators run at compiled code speed. For example, I introduced the *+ operator that does compound interest calculations. There is no such operator in any vector language implementation I have seen. I'm sure there are other examples of real need for new operators in many disciplines. My targets are Perl and Java. I expect to steal good ideas from Python when I expose GLEE's object oriented characteristics. In GLEE, a namespace is an object. I'm still experimenting with it but am finding it a very powerful concept. My concern is it may also be a security liability. Keeping in mind this is a work in progress, I will remain very open in my discussion of GLEE's strengths and weaknesses. If it does turn out to be a security problem, that of course is a show stopper.
Depending on my future needs, I might get more into array processing. Previously we have done it with C++ and VB, this is an ugly world you know. I have kept my eyes open on A+, J and dyadic APL.Would extending glee with c++ be easy? Sometimes I have HUGE amounts of data to process, and that means C++ with FILE_FLAG_NO_BUFFERING and FILE_FLAG_SEQUENTIAL_SCAN in frequent use for performance reasons. I'll try to encapsulate this ugly part and then call it from python, but a language with better array operators would be nice.
I don't know what the FILE_FLAG stuff is about, but Yes. The issues for GLEE and C++ are training and packaging. GLEE is in a bear hug with C++. Right now my focus is on getting GLEE to the point of doing real work by itself; saying what it does and how; and assuring that it does what I say it does. My debut of the language is admitedly premature, but the input I've gotten has been splendid. Working alone I welcome outside inputs.
$$--------------------
Todd, Looked at your web site and it looks impressive.
Thank you. Please come back often. I'm filling it out as fast as I can. I need to get the fundamentals documented before I can show how GLEE does useful work.
Remeber you sending me a note asking about the name of the program. Did not make a connection with you at that time. I have been exceptionally busy the past month and was wondering if you would like to make a presentation on Glee at this months C++ SIG. It will be on Thursday January 10th. It would give us a painless introduction to Glee and ease the pain of learning a new language. Also there is nothing like the author showing you how to use the language effectively.
I will be at the C++SIG Thursday and will be happy to make some comments. GLEE isn't ready for a formal presentation yet so anything I would have to say would be totally extemporaneous. My total focus right now is bringing the web documentation up to speed with the current interpreter functionality.
If you would like to do it suggest you send me a couple of sentances on Glee that would catch the folks attention. Wish you a very Happy New Year.
GLEE is a new vector oriented interpretive language. It's early goal is to provide functionality superior to languages like Perl and Java. As it matures, it has the potential to be a compact and efficient full service programming language. GLEEs inspiration lies in languages like APL, J, and K. It is written totally in C++ and uses no non-standard external packages. Rendering (i.e. Windowing appearance) is completely separate from the interpreter. This makes it easy to port to any platform supporting the C++ compiler and some form of display and I/O. GLEE has been in development for a little over two years. It probably has at least that much time to go before it can be expected to be taken seriously. Visit the GLEE website at http://withglee.com/ and follow the progress.
$$--------------------
Todd, Understand your reluctance to do a full presentation. However would like you make a 15 minute extemporaneous presentation. At least it will give your web site publicity.
Thanks for the opportunity.
$$--------------------

Mail: 1/3/02

$$--------------------
Your site looks great. Good luck with everything and don't work too hard.

$$--------------------
Knowing nil, null, zip, cipher, nada (allright, you get the idea) about web stuff, i don't know why the HTML is garbled.... as for this: Frames is lots of work for me. But I wanted not to bug people with a bunch of verbage if they didn't need or want it. That's why I chose the drill down style. Do you have ideas on another solution? Hmmmm....I would open up your real estate by dumping frames, doing something slick in Flash that leaves the memory of whence you navigated on the screen (not that this helps, but some very cool flash here: www.praystation.com ) and letting your users navigate it. You could, even w/o Flash, flip/flop between an 'expert' and 'verbose' mode pages..... Hope this parses,

Parses fine. I build and manage this site with HotMetal 5.0. If I go to Flash, do I add that skill on or does it replace my HotMetal skill?The expert vs verbose pages is double work. I'm looking for something that is half work yet effective.

$$--------------------------
Right you are on catenate...it *seemed* like it should be a word and....sure enough...www.m-w.com says it is. :-) hey...i can help in little ways....on the best days! LoL...

$$--------------------
Honestly, my opinion is that there are only two important things: 1) the "working direction" is consistent within GLEE and 2) the reading direction is roughly "western", i.e. left to right, top to bottom. 3) in case of trouble, (1) supercedes (2). Having said that...these conversations are VERY hard in email....easier to draw, point, etc. hth

I agree. Plus it should be logical. 1 2 3+3 logically yields 4 5 6. But what does 0 1 2+(3 4 5 6) logically yield. I'm inclined to view it as two vectors of sales data where I have more periods in the second vector than the first (e.g. been in business 6 quarters but grouping by year of 4 quarters). So logically this is (0 0 1 2)+(3 4 5 6). I don't know if this is how I've implemented extension throughout but it is how I intended to. This is thus doing fills with right takes (0 1 2 -> 4; aligning right sides and filling on left).

$$--------------------
btw, the HINT benchmark, doesn't really apply to GLEE, but: http://www.nswc.navy.mil/cosip/aug98/cots0898-1.shtml :-)

$$-------------------- >
I'll Google them both when I get time. If there are ideas there I should adopt, I will. GLEE is very flexible to embrace such things.
I'll put together a feature list of some of the more outstanding features of REBOL (free /Core and /View implementations for over forty platforms are available at http://www.rebol.com ). An informative SETL site can be found at: http://www-robotics.eecs.lehigh.edu/~bacon/download-setl.html
I was using the MS Windows version of SETL2 at the time, which can be downloaded here ftp://cs.nyu.edu/pub/languages/setl2/ide-2.3
(I just noticed that this is a relatively new release with an IDE which I haven't tried yet).
If Borland doesn't get C++ into Kylix soon, I'll have to do something with QT. The user interface does not strike me as being terribly complicted.
Why not use Delphi/Kylix (I haven't tried Kylix yet, so I don't know what I'm talking about. I have, however, extensive programming experience in Delphi.)
Because it's Pascal.
Or you may consider IUP as a thin-layered GUI portability library (free also for commercial purposes). That will enable you to maintain a single, shared codebase for both Linux and MS Windows systems (at least shared for the GUI) The authors write:
============
IUP/IupLua is a system for creating user interfaces. It offers a configuration API in three basic languages: C, Lua and LED. IUP's purpose is to allow a program to be executed in different systems without any modification, therefore it is highly portable. Its main advantages are: * high performance, due to the fact that the system uses native interface elements * fast learning by the user, due to the simplicity of its API.
==============
Their copyright includes the following statement:

=============
IUP is free and non-proprietary. It can be used for both academic and commercial purposes at absolutely no cost.
=============
If I recall correctly QT requires a commercial licensing agreement for commercial products (that may have changed). IUP is available here:
http://www.tecgraf.puc-rio.br/iup/
You should try to get GLEE listed on the Yahoo programming languages page at http://dir.yahoo.com/Computers_and_Internet/Programming_and_Development/Languages/
More info as soon as I have a little time.

Right now this isn't on my critical path but all is duly noted and I will return to it. Thanks for the input.

$$--------------------
Ok, it is definitely clearer...which in turn provokes another question....what happened to the earlier assertion that "We noted earlier that Glee matches up argument lengths before proceeding with an operation"? this doesn't seem to be happening here. for 1..4 2.._2, i really see 1..4 is expanded to 1234 next is catenation of 1234 and 2.._2 (catentation is dyadic, no?) since argument lengths must be matched....2.._2 must be evaluated so...2.._2 is expanded to 210_1_2 and voila, we get: 1234210_1_2 of course, if catenation as above is NOT dyadic, then the dyadic operation implied by 2.._2 has to come first anyway, yielding the same results..... ??? Yes? hope this helps (i know it helped me!) :-)

Catenation is dyadic but doesn't match argument lengths (dyadic says "two arguments" but says nothing about the arguments). It performs no element by element operation on its arguments so extension is not required. It is not catenation of 1 2 3 4 and 2.._2. It is catenation of 1 2 3 4 and 2.Glee has short right scoping. If you want long right scoping you have to use parenthesis to achieve it as in 1 2 3 4,(2.._2) which as you note produces the same result. This is more important when doing an operation like 1 2 3 4 + 2 1 0 _1. APL does long right scoping and sees the whole (2 1 0 _1) vector. Glee does not and sees only the leading 2. It was a conscious choice I made using my KISS principle. I was able to give the illusion of long scoping in this very limited case by the special way I implemented the range (..) operator. We're not dealing with the syntax of the language here ... we're dealing with the definition of the operation which is independent of syntax.

Am I consistent between characters and numbers?

$V

1 2 3 4 2.._2 Num[I424R1C9T:Int]:
1 2 3 4 2 1 0 _1 _2
1 2 3 4 ,2.._2 Num[I454R1C9T:Int]:
1 2 3 4 2 1 0 _1 _2
1 2 3 4 (2.._2) Num[I489R1C9T:Int]:
1 2 3 4 2 1 0 _1 _2
1 2 3 4 ,(2.._2) Num[I525R1C9T:Int]:
1 2 3 4 2 1 0 _1 _2
"1 2 3 4" "2.._2" [1]String[I534R1C8T:char]:1 2 3 4
[2]String[I536R1C6T:char]:2.._2
"1 2 3 4" ,"2.._2" String[I551R1C13T:char]:
1 2 3 42.._2
"1 2 3 4" ("2.._2") String[I570R1C13T:char]:
1 2 3 42.._2 Looks wrong
"1 2 3 4" ,("2.._2") String[I590R1C13T:char]:
1 2 3 42.._2

$$--------------------------
How has your response been so far?

I don't know how to gauge it yet. There have been about 650 visits and 400 downloads of the software so far. About 4,000 pages have been requested per day on average. There's been about 195MBytes of traffic. I won't know what's really going on until I get through the noise of the debut.

Mail: 1/2/02

$$--------------------------
I've sent notes to several people suggesting they check out the Glee site. Hopefully they'll give you some feedback. Good luck! P.S. Hope your ISP gets up and running, too!

$$--------------------------
i do not understand the language but looks interesting. how did you write this interactive software? we will be building a course this year this gives me some ideas. was it difficult? are you willing to share it?

I read a couple books about writing interpreters: "Writing Compilers and Interpreters" by Mac and "A Microprogrammed APL implementation" by Zaks. I discussed it with friends who are fluent in LEX and YACC. None of that was helpful. So I just started sculpting it out. I intended to keep my rules simple. Parse left to right (I always hated APL's right to left parsing). Identify operators from a table sorted longest to shortest and take the first hit (gave me total freedom in choosing symbol sequences for operators). Check for Dyadic, then Monadic, then Niladic and execute when I have enough information. Use ( ) to reorder precedence; use [ ] for indexing and program arguments; use { } for namespaces. On encountering these, recursively interpret them returning the result and move on. Control structures (e.g. #IF;#ELSEIF;#ELSE, etc). were problematic. I'm still streamlining them. But my framework allows me to give them power they never had in other languages. It also allows me to easily implement new ones I might invent. And of course, this is a work in progrss. It's not doing any useful work yet. The parser/executer is 48K of C++ source (no comments). Most of my difficulty came in getting the memory management and reference counting right. I would spend weeks chasing bad pointer problems in C++. Borland C++ Builder is a superb environment for program development. Yes, I am always willing to share./Todd

$$--------------------------
It looks great!!! I don't know if the old beaner is smart enough to give you any hints, but we sure will if we can. Congratulations and Happy New Year!! See ya

Mail: 1/1/02

$$--------------------------
Todd -- we've decided we need to wait til tomorrow when maybe we're sober to enjoy the introduction of glee. WE got to the 20 time more productive and are crashing now.................................

$$--------------------------
Hi Todd, This looks great.....do you want me to pass this on to some people I know? By the way, happy new year!

Yes, I encourage you to pass it on. Thanks. /Todd

$$--------------------------
Interesting but unable to get it to work. Received the following error message: Glee.exe - Unable To Locate Component:"This application has failed to start because BORNLNDMM>DLL was not found. Re-installing the application may fix this problem" Reinstalling from both the .exe and .zip files did not solve the problem. One question for the FAQ: include a table comparing Glee with J,K and APL on key features and limitations. Best wishes for the success of the language.

Thanks for trying the download and reporting the problem. I've added this file to the Ancillary Code and put it up separately in the downloads./Todd

$$--------------------------
Hi, The website is full of "I"s but there is no mention of who this "I" is.. don't you think it's appropriate to mention your name, background, etc. while trying to introduce a new language?

I really don't know if it's important to know who "I" is. I use "I" in the documentation because it is just me involved and because "I" is most direct. My name is Todd Marshall. My degree is in Electrical Engineering, but if it was over 10 volts, I was afraid of it. I've taken two computer courses in my life: 1620 machine language programing in 1964 and 360 Assembly language in 1969. I have been of most value to the world as an APL application developer but that value subsided. I found myself about 5% as productive using C++ and other languages. So I started creating GLEE in October of 1999. Frankly, I'm a little amazed but it's becoming exactly what I wanted./Todd

$$--------------------------
I downloaded and extracted the files from your website. Upon trying to launch Glee I get the following error: "The dynamic link library BORLNDMM.DLL could not be found in the specified path..." Your instructions don't say anything about having to have any Borland DLLs installed.

$$--------------------------
I do have a minor minor suggestion, but...LoL...as I was reading the "documentation" window, i saw that "grammar" was misspelled! Maybe this is a clever joke, or a test, eh? ;-) Anyways...minor thought: for the tutorial...would it not be easier to absorb the new minus/underbar syntax if the font size were a tick larger? Perhaps the tutorial would have to be moved out of "frames" mode, but in my gently offered and very nonprofessional opinion, this would be a benefit anyway. Happy New Year,

I purposely used frames so people could get a quick look at what I was addressing and just drill down for more information if they wanted it. I didn't want to clutter the concept with the explanation. If there's a better way to do this, I'd like to learn it./Todd

$$---------------------
A new programming language is a lovely present on the first day of the new year - I hope it goes well for you May I ask why you called it glee? Thanks again

I really don't remember. It was September 1999 that I started work on the code and I wanted a handle for it. I wanted a positive name and a catchy name. I wanted a totally generic name so it couldn't be trademarked out from under me. I personally like the name. If it has a meaning, it got there retrospectively. The farthest I got with reverse engineering the name was "General Logical Edification Engine". What a show stopper!/Todd

$$---------------------
Hi Todd. Happy New Year. I just downloaded Glee read through your tutorial. Some if it's functionality reminds me a little of SETL (with which I played around 1998), specifically the logical (or conditional) indices, which is one of the features that I really liked about SETL. Waiting for a SETL upgrade I discovered REBOL, fell in love, and wrote "REBOL: The Official Guide" (Osborne/McGraw-Hill). I've reviewed your tutorial (which I really should not have spent any time on right now, because I'm trying to get my second Palm Pilot application done by Jan 2nd including tutorial). Looks very promising. I'm sure looking forward to a) A Linux version (my main os environment, with Win95 running on top of Linux under VMWare); b) You wrote: > it's going to take a little while > before you'll be able to use Glee to > build an accounting system I am looking forward to that. > c) or a web page server for your company. > (but that is where we're going with this). And even more to that! Why not start an announcement list? Have a productive new year. I'm looking forward to see where this is going.

$$----------------------
Well Todd , you are courageous anyway . An explication of your syntax is a high priority .

Syntax is pretty trivial. Left to right precedence. Dyadic, Monadic, Niladic precedence. (), [], {} reorder precedence. Operators can do anything they like in producing their result. Left argument is always replaced by the result for continuous garbage collection. I'm not a computer scientist, so all of this could be against the law. :-)/Todd

$$----------------------
Thanks for the mail....i am checking it out with...well...."glee"....(and aiming to be your first FAQ submitter). May I know where you got my name? Thanks, and Good Luck,

I sent to a list of 1,008 addresses. All came from (were addressees of) mail I have received with the following exceptions: I sent to everyone I saw on the k newslist. I sent to everyone I saw in the [XP] Extreme Programming list. I don't intend to do another mass mailing. If Glee doesn't gain a following with that airplane drop, it's not going to gain a following./Todd (P.S. I may have broken some kind of law with my ISP for this and that's why I can't send mail anymore. :-)

$$----------------------
in vector tutorial , fix "preform" and "catenate" to perform and concatenate....

Catenate is a word with the same meaning as concatenate. In APL land we always used catenate ... and I'm an APLer./Todd.

$$----------------------
the mixed length vector stuff is confusing, both in explication and execution. Why "read backwards" (i.e. from right to left ) in this case? Is this the ONLY place/time in Glee where we parse...er..."hebrew" style? and the initial example (the one with the singleton"4" getting replicated) doesn't disambiguate this much..... not a big deal...i "figured it out" after all, from reading your explanations, but..... it is odd, this "right to left" paradigm in this one (?) case.... just a thought,

I think you're right and I'll study it. It's probably the way it is because it programmed more directly that way ... a reason I try to avoid like the plague. I'll get back on this one./Todd

$$----------------------
in "more than one range"..."kind of inconsistency" part of vector tutorial... peel should not be spelled "peals"....

$$----------------------
Yikes....man oh man i do NOT see why 1..4 2.._2 doesn't fill to 1 2 3 4 2.. _2 then, matching left vector with right scalar, take the right scalar, and extend by reverse hebrew "last character" repetition to get 1 2 3 4 2 .. _2 _2 _2 _2 _2 for a final result of 12342_2_2_2_2_2.... Is it b/c the parser stops looking at the whole expression midstream? Man, this is confusing....don't get me wrong...I think it's consistent, but it's confusing....right take, left take, peel off...etc. You know what would really help? the pseudocode for the parse and the operator precedence list including catentate range expand (i.e. " .. " ) I guess you can sum it all up by saying " .. " is evaluated before catenation .... just a thought

Range is doing exactly what I want so I'll have to go back and clear up the explanation. The GLEE parsing rules are trivially simple. Everything is left to right. Dyadic takes presidence over monadic which takes precedence over niladic. What is unknown must be parsed before it is used. Parenthesis (), Indexing [], and Blocks{} all require parsing before proceeding. Range (..) is an operator. An operator can use its arguments in any way it chooses in producing its result (which always replaces the left argument). /Todd

$$----------------------
"Indexing with Index Generator"..... commentary does NOT match (code/result) !!!

I did an unforgivable thing on New Year's Eve (and beg forgiveness). I changed Glee in a very serious way. Up until that time, Glee used index origin 0. As I wrote the tutorial, it became evident to me that that was for the convenience of the computer ... not humans. So I changed it knowing I didn't have time to think it through and knowing it was a dicision that must be made. I think origin 0 is alien to all but computer oriented humans (and maybe mathematicians). I thought I caught all the changes in what I had documented and am catching others as fast as I can. As you might suspect, the implications were huge. But if I didn't change it then, I would have had difficulty with the inertia against change later. Please help me quickly root out the places where Glee and the documentation still believe in origin 0. Glee now and forever more, believes in origin 1. I will not make it a choice as was done in APL. /Todd

$$----------------------
How best to approach learning Glee for a programmer unfamiliar with APL, J, K or C++? Which operating systems and platforms have compilers? Which are in planning stages? To which OS'es and platforms will Glee *not* be ported? What are the issues surrounding creating an optimizing compiler for Glee on, say, Win2K run by an Athlon chip? Which benchmarks would best measure Glee's unique strengths? How does Glee perform on the new "HINT" benchmark? What are the scalability issues with Glee? (e.g. array size, stack/heap usage, etc.) In what ways is Glee properly used in a multiCPU environment? That is, if Sort#1 and Sort#2 may be done independently and simultaneously prior to being consumed by code block "B", will the compiler recognize and use separate CPUs to perform the sorts prior to feeding them to "B"?

Superb questions. Short answers. Glee is totally C++ and will run anwhere there is a C++ compiler. It is two separate parts. Glee execution is separate from Glee rendering (e.g. Windows, QT, ...). Porting means recompiling the interpreter and replacing the rendering. Glee has a clock operator that I use to check for my own slow code but it's not a bench marking tool. It shouldn't be hard to add a powerful profiling feature but the clock is getting me by for now. There are no big Glee programs yet (and won't be for a while) so profiling isn't much of an issue. I've never heard of the HINT benchmark. I don't use an interpretive language if I want to be really fast. But I think Glee is faster than many interpretive languages. Glee does not do threading yet but is totally reentrant so I should be able to get there. It's high on my priority list and raises a large number of other issues as you suggest. I just love these kinds of questions and wish I could take more time for thoughtful answers. For now, documentation is on my critical path but please keep them coming./Todd

$$----------------------
The definition of indexing in the glossary uses the example " ... e.g. (1 2 3 4)[2 1] yields 3 2)." When I try it I get 2 1 which suggests it is working in origin 1, contrary to the statement in the indexing definition that "... GLEE works in origin 0 meaning indexing begins with index 0 rather than 1." Am I missing something here?

No. I did when I switched Glee to origin 1 at the last minute. Thanks for pointing it out./Todd

$$----------------------
Your unsolicited SPAM: Thank you for informing me of the availability of GLEE. Unless or until it is freely available for non MicroSoft operating systems I have no further interest. I will continue to use Ruby, Python and Perl in that order. Thanks

I know Perl. Python is high on my priority list to study and I will (in time) steal what is good from it for Glee. I've never heard of Ruby so must search it out. Linux implemention is a very high priority. Thanks for the recommendation. /Todd

$$----------------------
Todd, Took a look at your new website. I'm afraid it was all Greek (Glee) to me....I'm not at all computer friendly. But wanted you to know I support you and hope your brain child will reach the people with whom it resonates. Congratulations on the tenacity I know it takes to bring a dream into reality. Wishing you a bountiful and rewarding New Year!

Please come back and visit occasionally. Glee has the potential to be very friendly without condescending. One goal was to be able to have it help you do what you want to do without knowing more than you need or want to know. Some computer languages aren't that way. It is my intention for Glee to be appealing to people who don't want a career in computers (as well as to those who do). I know this is achievable./Todd