Rosetta Code

Rosetta Code:Village Pump/Dialects

< Rosetta Code:Village Pump
Revision as of 07:41, 9 July 2012 by Rvjansen (talk | contribs) (added point of view)
Dialects
This is a particular discussion thread among many which consider Rosetta Code.

Summary

What are, or should be, the Rosetta Code conventions for dialects of programming languages - implementations on specific platforms that may have minor differences of syntax and functionality from the official distributions?

Discussion

I would rather have different dialects not count as language of their own. Otherwise we have many main languages, which are similar in many ways, and many more items to show the code for. The navigation gets cluttered up and language lists would need to be structured in a hierarchy. This is already a problem with ZX80 Basic and C64 Basic and maybe more variants.

I propose

  • have an entry page for the dialect which redirects to the main language
  • allow different, dialect specific implementations of the same problem on the page of the "main" language.

Codecop 13:33, 28 January 2012 (UTC)

My general position has been to leave the distinction to the language community. To a C++ programmer, all BASIC implementations might look alike, but to people with production code in QuickBasic, that's a nonsensical position. --Michael Mol 14:44, 28 January 2012 (UTC)
I tend to agree, it will be very specific to the language and community. Guidance and suggestions are probably welcome and this would be a good anchor page, but I would not want to weigh in on any of the languages mentioned above. --Dgamey 14:51, 28 January 2012 (UTC)
One man's dialect is another's version. To a beginner reading these pages, it gets confusing enough to have to know a priori what the differences/defaults/nuances are and what can or can't be used in their version/release/sub-release/dialect/whatever.
I'm going to read into the proposal that navigation is really the issue and not pure numbers. If we worry about pure numbers, we have about 600 tasks and 450 languages which results in a pretty big matrix. Not that we will ever see that as other than a sparse-ish matrix. When that happens we will need to solve that problem. Until then I have to fall back onto YAGNI. I suggest we put some practical examples and suggestions/ideas here. Then when a community starts to have a problem they have a place to come for ideas. --Dgamey 15:03, 28 January 2012 (UTC)

Examples

Icon and Unicon

Hi, I did a lot of the work on Icon and Unicon which are closely related. Much of what I went through is discussed on the talk pages for Category_talk:Unicon. What you are proposing isn't far from what I did. Here's a summary, you can also see how it looks (there's over 450 examples on RC):

  • Each distinct variant gets it's own page/category. If there are minor variants, it may make sense to put them in a section of the major variant's page.
  • In tasks, I have one header with both major variant names in a single header line. Both Icon/Unicon were used because of recognition and to prevent orphaned headings (This may become more problematic as there is also a Jcon and ObjectIcon). Orphaned headings and duplicate efforts is a big problem if you have more than a few contributors. I found that having a combined header that sorts early worked best.
At one point I had thought of disambiguation pages as a possible part of the solution but I concluded I didn't really need them and they didn't add much in this case. That may not be true with a large number of true variants and also like named but unrelated languages (think Basic and VisualBasic).
  • Under the task heading there is a structure that allows different solutions where there are differences. However, where the differences are very minor I usually rely upon description text.

I tried a couple of kicks at it and found this approach practical (not necessarily perfect). It may or may not work with others. Hope this helps.

--Dgamey 14:42, 28 January 2012 (UTC)

UNIX Shell

Today:

--Kernigh 16:12, 28 January 2012 (UTC)

REXX, ooRexx, and others

Nowadays there are many implementations of Rexx.

As 'my' two Rexxes are currently TSO-Rexx (still Classic Rexx to me)
and ooRexx I shall enumerate the incompatibilities between these two.

Rexx was created some 30 years ago for VM/CMS and was later ported
to MVS/TSO. Its current grandchild for Windows and other PC-platforms
is ooRexx.

Some 'features' of the original Rexx were removed '''in this grandchild (ooRexx)'''
- Use of @#$¢ as or in symbols
- a= as a short form of a=''
- Multi-line strings (extending a string over line boundaries'
- stream I/O (present in CMS but only optional on TSO (not on 'mine')
  (on TSO I have to use EXECIO)
- Bifs: externals, find, index, justify, linesize
- the Upper instruction
- /= and /== as alternatives to \= or \== (see characters below)
I hate to interject here, but were you referring to ooRexx when stating that some 'features' were removed? If that's the case, could you add ... were removed from ooRexx (or maybe say ... not implenteded in ooRexx and/or removed from the ooRexx' standard(s). As it stands now, it sounds like the classic (original?) REXXes no longer support those 'features' listed above. [As far as I know, most classic REXXes still support a majority of those features.] Also (regarding below), what (or where) did you mean "other features were introducted..."? Were you speaking of the classic REXX standard or ooRexx? Please feel free to delete these comments as they are obtrusive and I only placed them here to clarify your point and have this in close proximity to the statements in question. -- Gerard Schildberger 22:16, 8 July 2012 (UTC)

Other features were introduced '''with the ANSII standard''' created
by a committee comprising Rexx implementers from IBM (notably the
original author, Mike Cowlishaw) and elsewhere:

- Date and Time conversion
- Parse Caseless
- Address With (not available in ooRexx)
- Bifs changestr, countstr, qualify

A feature introduced with ooRexx (and Regina unless you opt out):

- -- as line comment (instead of /* ... */)

          Regina 3.4 introduced the      single-line comment  feature, 
          Regina 3.5 wasn't configurable concerning single-line comments, 
                         and it wasn't until
          Regina 3.6 that allowed the  noSingle_line_comments  
                         environmental variable. --- Gerard Schildberger

Avoiding all of the language elements mentioned above makes a program
portable across the two Rexxes I am using and therefore interested in.
Using additional features introduced with other implementations
(notably directives in ooRexx) will also prohibit program porting.

Characters:
Originally ¬ was defines as not-character and /= was accepted for not equal.
This was later changed to the backslash and ^ on the host.

On my German TSO I cannot use | and \ due to code page differences.
My Rexx sources on TSO use therefore ! and ^, respectively.
(I avoid the ^ by using lt-gt instead of ^=)

For a Brief History of Rexx see
http://www.speleotrove.com/rexxhist/rexxhistory.html
For a rather complete list of Rexx implementations see
http://www.speleotrove.com/rexxhist/rexxplat.html
(both courtesy Mike Cowlishaw)

--Walterpachl 20:23, 8 July 2012 (UTC)

REXX and o-o REXXes

(This section was being edited at exactly the same time as the previous section.)

Classic REXX and the object-oriented REXXes have a similiar problem (with dialects, language and concept extensions, re-definitions, incompatibilities, dropped features, added features, etc) in that ooRexx, NetRexx, ROO! (and others) are somewhat of a continuation of classic REXXes (at least, those features that are still approved), with object-oriented features added, and the object-oriented REXXes aren't fully compatiable the classic REXX language. A list of incompatabilities between classic REXX and the object-oriented REXXes is apparently being developed, as some of the differences are quite subtle.

Up to very recently, people have been entering NetRexx and ooRexx solutions under NetRexx and ooREXX instead of REXX. Some of the REXX examples have been modified (and modified again) so that they can apparently execute under a particular ooRexx (but not necessarily NetRexx or others). Not everyone who enters (and tests) classic REXX has an ooRexx or NetRexx interpreter available to verify if the REXX program(s) will work on the various o-o REXXes. Putting them all under the REXX language umbrella would necessitate someone going back and entering disclaimers to virtually all of the classic REXX entries, stating that it works for classic REXX, but not necessarily ooRexx and/or NetRexx and/or ROO (since there may be a lack of test platforms), so there may not be a statement which o-o REXXes it works or not works on. This would make the REXX entries pretty bulky and make perusing unwieldly and harder to follow visually. I don't feel that moving all the ooREXX and NetRexx examples back to classic REXX would serve any useful purpose, nor entering ooRexx examples in the classic REXX section (which just clutters up entries for classic REXX), and since ooRexx has it's own section, it would behoove everyone to keep ooRexx and NetRexx examples in the ooRexx and NetRexx language section, respectively. Entering object-orientated REXX language programs in non object-orientated (classic) REXX language section would be like entering C# and other o-o C's under the C language. Each lanuage has their own syntax. I certainly don't know where the line is drawn between dialects and specific implementation differences. I know you can change Fortran programs enough so they run under REXX, but I can't see the use of that portability.

  • 387 (classic) REXX examples (with one cross-posting)
  • 120 NetRexx examples (with no classic REXX postings)
  • 120 ooRexx examples (with no classic REXX postings)

Since the above mentioned cross-entering has now occurred (with no apparent corrective possibility) and that this is continuing to happen, I would hope there would be a consensus before the pollution gets to far to be corrected easily. As an aside, I have no desire to change program syntax or variables for portability to a language that is of no interest to me, I'm trying to write the classic REXX code to ensure that it works for all classic REXX interpreters (that I can test) and I'm not interested in object-oriented languages. For classic REXX programs, it's like using a hammer to kill a fly. That is why there exists two other o-o REXX language sections (NetRexx and ooRexx). I haven't seen any effort in making ooRexx compatible to class REXX (and there shouldn't be, of course; that portability wouldn't be useful, I should think). -- Gerard Schildberger 21:01, 8 July 2012 (UTC)

My suggestion was to have Classic, or let's say plain Rexx programs under Rexx Object oriented Rexx programs under ooRexx (I hav eno idea how Roo fits with tah and NetRexx, to me is an entirely different story. I remeber having seen entries in ooRexx that said something like: the Rexx program works also under ooRexx Would you want to have either that sentence for all Rexx programs that work unchanged and the changed version (changing $# and a= as necessary) in ooRexx? I shall proceed in that direction. --Walterpachl 21:13, 8 July 2012 (UTC)

Classic REXX is not object-orientated REXX. To put them under an o-o umbrella would be a disservice to both languages. A classic REXX entered under the ooRexx language would (to me) imply that it would work using ooRexx, and I have no way of testing/verifying that. My main interest is in classic REXX and have no need for object-oriented features. Again: hammer, fly. I test all of my classic REXX program examples (unless noted otherwise) under three classic REXXes: Personnal/REXX, Regina (sometimes more than one version when there is a perculiar release-based feature), and R4. [Sometimes I say PC/REXX when I meant to say Personnal REXX --- they have the same pedigree.]

I don't know what you mean by plain REXX; the point under discussion is classic REXX vs. the o-o (object-orientated) REXXes.

And yes, some ooRexx examples have that wording: " ... the entry under REXX works with oo-REXX ..." (or NetRexx). There's nothing wrong with that, and it shows for that particular classic REXX program, it solves the task using that language. As for asking what I want, I have no interest in the o-o REXXes. I don't care if you want to enter a comment under ooRexx that it works with the program entry under REXX or not (but I think that would be a good idea). I you want to change a copy of a classic REXX program and then move that changed classic REXX program to the ooRexx language section, I think that would also be a great idea and an endeaver worth the time and effort. -- Gerard Schildberger 22:16, 8 July 2012 (UTC)

This is one of the cross postings that you deny to exist. (24 game)

Walter, I don't deny any exist. I emphatically stated that they DO exist ("... has now occurred ..."), and in any case, and I didn't specifically mention any particular REXX entry. I do wish you wouldn't accuse me of denying things to exist when I stated the opposite. Also, I have just noted that the program example that I referred to has just been moved to ooRexx. -- Gerard Schildberger 22:16, 8 July 2012 (UTC)
 * 120 ooRexx examples   (with no classic REXX postings) this is your line which I may have misunderstood.
 this I consider some existing cross-postings.
 As to the one you addressed:
 I moved the result, not the program (as to your request and against my conviction: why not have results together??)
 And again: ooRexx implements Classic Rexx (with the few exceptions listed on top of this topic)
 --Walterpachl 05:32, 9 July 2012 (UTC)

It was my start with the topic and you changed your program (thanks) 

"While the solution shown within this page at Rexx version 2 was created for Classic Rexx 
it also can be used unchanged by the ooRexx interpreter and so can be considered a solution 
for the ooRexx language too.

Incompatibilities(*) that were originally in Rexx version 1 were meanwhile "fixed",  
so it also can be used unchanged by the ooRexx interpreter and so can be considered
a solution for the ooRexx language too.

(*) Classic Rexx accepts assignment without an expression (x=;), ooRexx does not."

--Walterpachl 21:27, 8 July 2012 (UTC) --Walterpachl 21:24, 8 July 2012 (UTC)

While it is not that hard to craft Rexx source that runs with ooRexx, it is much harder and often impossible using NetRexx - there a universal source would be a rare sight. Some in the NetRexx community regard it as a different language altogether - I am not necessarily in agreement with that. When Object Oriented sourcecode is used, the program is not compatible to Classic Rexx. The previous I consider facts. These facts bring me to the opinion that most NetRexx should be in its own language category, and only procedural code can be shared by ooRexx and Classic Rexx. Conversely, when someone crafts an ooRexx sample, it should show off the oo facilities and class libraries and not be gratuitously incompatible to Classic Rexx. As an addition, a Classic Rexx sample that can be compatible with ooRexx should not use the corner cases in which it isn't. rvjansen 07:41, 9 July 2012 (UTC)

Retrieved from "https://rosettacode.org/wiki/Rosetta_Code:Village_Pump/Dialects?oldid=211820"