From: David A. <dav...@gm...> - 2010-01-09 17:43:34
|
All - I am working on an ooRexx interface to something that is normally programmed in C. Of course, C uses zero-based indexes for thing like memory, array positions, etc. My code could be architected to either carry this forward to the ooRexx interface when it calls the C functions or it could translate the zero-based numbers to the more user friendly (and Rexx default) one-based numbering system. I have mixed emotions on this. On the one hand I much prefer the one-based system that Rexx uses. On the other hand, C programmers who have programmed to this interface in the past will be more comfortable with the zero-based numbering system. But I also want to bring in those C and Perl programmers into the Rexx arena and that means having them get used to a one-based system. Also, all the documentation and examples for the system I am interfacing to ooRexx is for C and Perl programmers. Thus all those docs and examples are zero-based meaning that translating the examples to Rexx involves some updating of the source program number constants. So I really am of two minds about this. In the past I have always leaned to making things easiest for the Rexx programmer but this case has made me rethink that idea. I am now questioning my assumptions and I want some other opinions before I proceed too far. Thank, David Ashley |
From: Jack W. <ja...@we...> - 2010-01-09 18:10:44
|
David Ashley wrote: > C uses zero-based indexes for thing like > memory, array positions, etc. My code could be architected to either > carry this forward to the ooRexx interface when it calls the C functions > or it could translate the zero-based numbers to the more user friendly > (and Rexx default) one-based numbering system. I have no specific suggestion, but I do have a vivid recollection of the era when Language Wars ruled the virtual world and the 1-basers and 0-basers were locked in conflict. During that time I sat on the X3J14 committee for ANS Forth. One of our discussions (on whether the Forth word NOT was to be logical or bitwise inversion) grew so ridiculously heated that one member wrote to then- President George H. W. Bush to ask him to intervene to save the purity of the Forth programming language! The conclusion I draw from this: It doesn't make a bit of difference. /None whatsoever/. Isn't worth the time it takes to think about it. Consult your own convenience, and if the users don't like it, they roll their own. -- Jack J. Woehr # Reality is unpredictable, and no amount of computer technology http://www.well.com/~jax # is going to change that. - David Brooks, conservative pundit, http://www.softwoehr.com # "The God That Fails", 2009-12-31 New York Times |
From: Mark M. <mie...@gm...> - 2010-01-09 18:24:23
|
On Sat, Jan 9, 2010 at 9:43 AM, David Ashley <dav...@gm...> wrote: > I am working on an ooRexx interface to something that is normally > programmed in C. Of course, C uses zero-based indexes for thing like > memory, array positions, etc. My code could be architected to either > carry this forward to the ooRexx interface when it calls the C functions > or it could translate the zero-based numbers to the more user friendly > (and Rexx default) one-based numbering system. This is a good topic and one I have thought about, but I am also of two minds here. In ooDialog, it looks to me that they started out converting the zero-based indexes to one-based, but then did not carry through with that consistently with later code. Some of the earliest basic controls, (combo box, edit, etc.) convert the underlying 0-based indexes to 1-based indexes. Then 'newer' controls (list-view, etc.,) retain the underlying 0-based indexes. That of course is the worst possible approach. Obviously you would want one package to be consistent through out. So, I've thought about, if I could redo the entire package, would it be best to retain the underlying 0-based indexes, or use 1-based indexes through out. The main con to using 1-based indexes for ooDialog, as I see it, is that the MSDN documentation is so much more complete. There is no way that the ooDialog documentation can reproduce all that. So, it would be ideal, I think, for the ooDialog doc to say this is a brief overview, the ultimate documentation is MSDN. Especially with Google and other search tools, it would be much easier for ooDialog programmers to figure out how to use the dialogs and dialog controls from doc and examples on the Internet. Which of course will always use 0-based indexes. The pro of course is that Rexx uses 1-based indexes, so converting the indexes would make things more consistent with Rexx itself. Another problem with converting to 1-based indexes, (which comes back to documentation) in ooDialog is how to be consistent with special values. Often a index of -1 indicates an error, but sometimes not. Do you convert -1 to 0? Do you leave it at -1? There are places where it is hard to be completely consistent, because the Windows API is not always consistent. But, the MSDN documentation, usually documents what is what with respect to indexes. So, in the this area, it would nice to be able to say, whatever MSDN says is correct. You can't do that if you are converting indexes. All in all, I'm not sure which would be best. But, for external packages that provide a way to access and use a well known API, such as the Win32 API, I'm learning towards it would be better to be able to say the well known documentation on the API is the authority. -- Mark Miesfeld |
From: Chip D. <ch...@av...> - 2010-01-09 20:41:27
|
David, Unlike the respondents so far, I do have a strong opinion (to the surprise of no one, I'm sure). My conviction is based on philosophical grounds because all the other reasons are ephemeral, and you are about to cast something in stone. If you are creating something to be used by a Rexx programmer, it should adhere to the Rexx Philosophy, if at all possible. The counter-arguments are good ones (or you wouldn't have a dilemma) but none of them justify abandoning a core principal of the language's design. Programmers of C (and all its derivatives) are the only people on the face of the Earth who see no reason for cardinal numbers to match their ordinals. Go into a fast-food restaurant and ask for a cheeseburger, a fish sandwich, fries, and an iced tea. Then tell them to add bacon to the first item and cancel the third. I doubt you'll be happy with your meal. Zero-based indices are an impediment to learning programming, a continual source of errors, and provide no value to the programmer. The fact that the compiler avoids one subtraction operation per index lookup is of no benefit to the programmer on whose behalf the tool is being created. As for the specific questions that have been posed: > C programmers who > have programmed to this interface in the past will be more comfortable > with the zero-based numbering system. But I also want to bring in those > C and Perl programmers into the Rexx arena and that means having them > get used to a one-based system. I fail to see how any human, surrounded by one-based lists in real life, would have to "get used to a one-based system", unless C and Perl programmers fail to fall into that category. It's a minor conceptual adjustment for them, versus the significant cognitive dissonance created by going the other direction. > Also, all the documentation and examples for the system I am interfacing > to ooRexx is for C and Perl programmers. Thus all those docs and > examples are zero-based meaning that translating the examples to Rexx > involves some updating of the source program number constants. This is a situation that could easily change. We have 'way too many examples of design constraints that were implemented due to temporary resource limitations that continue to constrain long after the limitations are lifted. Yes, it will take effort to "correct" the documentation for the Rexx implementation, but that is just a SMoEditing. The delta effort to change to one-based indices will probably be lost in the larger documentation effort anyway. At some point, the C/Perl programmers will still have their docs, the Rexx programmers will have theirs. The same thing applies to ooDialog, indeed the poster child for the way NOT to implement a C-based package in the Rexx environment. Again, such a fundamental design decision should not be based to the current (and mutable) condition of the documentation. At some point, there will be ample and sufficient ooDialog documentation for ooRexx. No doubt it will still differ from the Microsoft documentation in many ways other than the base of indices. The situation will be no different from converting OLE recorder generated VB code to the equivalent ooRexx. The other "pro" is that now ooDialog will do exactly what the human programmer expects. Special cases such as the meaning of a -1 index are already inconsistent and will need to be addressed and documented as the special cases they are. That is not a reason to abandon the sensibility of using human indices. You'll notice that I've consistently referred to "Rexx", not "ooRexx". It is important that there not be an ooRexx philosophy that differs from the Rexx Philosophy. It is that novel approach to program language design that allowed Rexx to be so widely accepted and still in use thirty years later. The further ooRexx strays from it, the less it has to offer programmers over other (non-human-oriented) programming languages like Perl (which is obviously oriented towards non-humans :-) or Python. Unfortunately, this raises the fundamental question of what does ooRexx offer the object-oriented programmer? It's easy to rattle off the benefits of Rexx, just read them from Mike's manifesto from the first chapter of TRL. Why exactly would a C(++), Perl, Python, Ruby, or Java programmer be interested in yet-another-OO language? What does ooRexx give you that is compelling? It does not appear that simply being "object oriented extensions to Rexx" has been the path to wide acceptance. Thank you for raising this issue. We seem to have long ago abandoned the Rexx principle of document, discuss, _then_ code. -Chip- On 1/9/10 18:24 Mark Miesfeld said: > On Sat, Jan 9, 2010 at 9:43 AM, David Ashley <dav...@gm...> wrote: > >> I am working on an ooRexx interface to something that is normally >> programmed in C. Of course, C uses zero-based indexes for thing like >> memory, array positions, etc. My code could be architected to either >> carry this forward to the ooRexx interface when it calls the C functions >> or it could translate the zero-based numbers to the more user friendly >> (and Rexx default) one-based numbering system. > > This is a good topic and one I have thought about, but I am also of > two minds here. > > In ooDialog, it looks to me that they started out converting the > zero-based indexes to one-based, but then did not carry through with > that consistently with later code. Some of the earliest basic > controls, (combo box, edit, etc.) convert the underlying 0-based > indexes to 1-based indexes. Then 'newer' controls (list-view, etc.,) > retain the underlying 0-based indexes. > > That of course is the worst possible approach. Obviously you would > want one package to be consistent through out. So, I've thought > about, if I could redo the entire package, would it be best to retain > the underlying 0-based indexes, or use 1-based indexes through out. > > The main con to using 1-based indexes for ooDialog, as I see it, is > that the MSDN documentation is so much more complete. There is no way > that the ooDialog documentation can reproduce all that. So, it would > be ideal, I think, for the ooDialog doc to say this is a brief > overview, the ultimate documentation is MSDN. Especially with Google > and other search tools, it would be much easier for ooDialog > programmers to figure out how to use the dialogs and dialog controls > from doc and examples on the Internet. Which of course will always > use 0-based indexes. > > The pro of course is that Rexx uses 1-based indexes, so converting the > indexes would make things more consistent with Rexx itself. > > Another problem with converting to 1-based indexes, (which comes back > to documentation) in ooDialog is how to be consistent with special > values. Often a index of -1 indicates an error, but sometimes not. > Do you convert -1 to 0? Do you leave it at -1? There are places > where it is hard to be completely consistent, because the Windows API > is not always consistent. But, the MSDN documentation, usually > documents what is what with respect to indexes. So, in the this area, > it would nice to be able to say, whatever MSDN says is correct. You > can't do that if you are converting indexes. > > All in all, I'm not sure which would be best. But, for external > packages that provide a way to access and use a well known API, such > as the Win32 API, I'm learning towards it would be better to be able > to say the well known documentation on the API is the authority. On 1/9/10 17:43 David Ashley said: > > I am working on an ooRexx interface to something that is normally > programmed in C. Of course, C uses zero-based indexes for thing like > memory, array positions, etc. My code could be architected to either > carry this forward to the ooRexx interface when it calls the C functions > or it could translate the zero-based numbers to the more user friendly > (and Rexx default) one-based numbering system. > > I have mixed emotions on this. On the one hand I much prefer the > one-based system that Rexx uses. On the other hand, C programmers who > have programmed to this interface in the past will be more comfortable > with the zero-based numbering system. But I also want to bring in those > C and Perl programmers into the Rexx arena and that means having them > get used to a one-based system. > > Also, all the documentation and examples for the system I am interfacing > to ooRexx is for C and Perl programmers. Thus all those docs and > examples are zero-based meaning that translating the examples to Rexx > involves some updating of the source program number constants. > > So I really am of two minds about this. In the past I have always leaned > to making things easiest for the Rexx programmer but this case has made > me rethink that idea. I am now questioning my assumptions and I want > some other opinions before I proceed too far. |
From: Dan C. <gwc...@ez...> - 2010-01-09 23:01:24
|
IMNSHO, if the scope of the use of the interface is limited to one application or one shop then the conventions of the shop or product should be observed; however, if this interface is for Rexx or ooRexx users only and will be made available to the community at large, then use the Rexx convention. My own rule in cases like this is to use the users' conventions, not the called code's conventions. It is generally easier to adjust indexes and subscripts in the target interface code. I am doing a lot of COBOL-to-C stuff and I have the C code adjust the values. C programmers can take care of themselves (and their code). -----Original Message----- From: David Ashley [mailto:dav...@gm...] Sent: Saturday, January 09, 2010 10:43 To: ooRexxDevel Subject: [Oorexx-devel] Opinions Wanted All - I am working on an ooRexx interface to something that is normally programmed in C. Of course, C uses zero-based indexes for thing like memory, array positions, etc. My code could be architected to either carry this forward to the ooRexx interface when it calls the C functions or it could translate the zero-based numbers to the more user friendly (and Rexx default) one-based numbering system. I have mixed emotions on this. On the one hand I much prefer the one-based system that Rexx uses. On the other hand, C programmers who have programmed to this interface in the past will be more comfortable with the zero-based numbering system. But I also want to bring in those C and Perl programmers into the Rexx arena and that means having them get used to a one-based system. Also, all the documentation and examples for the system I am interfacing to ooRexx is for C and Perl programmers. Thus all those docs and examples are zero-based meaning that translating the examples to Rexx involves some updating of the source program number constants. So I really am of two minds about this. In the past I have always leaned to making things easiest for the Rexx programmer but this case has made me rethink that idea. I am now questioning my assumptions and I want some other opinions before I proceed too far. Thank, David Ashley ------------------------------------------------------------------------ ------ This SF.Net email is sponsored by the Verizon Developer Community Take advantage of Verizon's best-in-class app development support A streamlined, 14 day to market process makes app distribution fast and easy Join now and get one step closer to millions of Verizon customers http://p.sf.net/sfu/verizon-dev2dev _______________________________________________ Oorexx-devel mailing list Oor...@li... https://lists.sourceforge.net/lists/listinfo/oorexx-devel |
From: Mike C. <MF...@uk...> - 2010-01-11 07:39:57
|
> I am working on an ooRexx interface to something that is normally > programmed in C. Of course, C uses zero-based indexes for thing like > memory, array positions, etc. My code could be architected to either > carry this forward to the ooRexx interface when it calls the C functions > or it could translate the zero-based numbers to the more user friendly > (and Rexx default) one-based numbering system. There is a third path that one might consider, if it makes sense (in particular, the package needs to have some kind of persistent state, or able to get at some from the Rexx implementation), and that is: let the user choose. APL (I think it was) does this: essentially when starting to write a program using the package, you set a flag (to 0 or 1, perhaps) saying whether to use 0-based or 1-based indexing, according to preference. The package then adjusts all indexes as requested. You still have to decide what the default should be (unless not specifying is an error), but that's a much easier (read: less stressful) decision if there's a way to override it. (I'd agree with Chip on what the default should be :-).) Mike Unless stated otherwise above: IBM United Kingdom Limited - Registered in England and Wales with number 741598. Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU |
From: Mike C. <MF...@uk...> - 2010-01-11 07:49:08
|
[retry] > I am working on an ooRexx interface to something that is normally > programmed in C. Of course, C uses zero-based indexes for thing like > memory, array positions, etc. My code could be architected to either > carry this forward to the ooRexx interface when it calls the C functions > or it could translate the zero-based numbers to the more user friendly > (and Rexx default) one-based numbering system. There is a third path that one might consider, if it makes sense (in particular, the package needs to have some kind of persistent state, or able to get at some from the Rexx implementation), and that is: let the user choose. APL (I think it was) does this: essentially when starting to write a program using the package, you set a flag (to 0 or 1, perhaps) saying whether to use 0-based or 1-based indexing, according to preference. The package then adjusts all indexes as requested. You still have to decide what the default should be (unless not specifying is an error), but that's a much easier (read: less stressful) decision if there's a way to override it. (I'd agree with Chip on what the default should be :-).) Mike Unless stated otherwise above: IBM United Kingdom Limited - Registered in England and Wales with number 741598. Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU |
From: Tony H. <to...@ha...> - 2010-01-13 01:23:49
|
2010-01-11 Mike Cowlishaw <MF...@uk...>: > There is a third path that one might consider, if it makes sense (in > particular, the package needs to have some kind of persistent state, or > able to get at some from the Rexx implementation), and that is: let the > user choose. > > APL (I think it was) does this: essentially when starting to write a > program using the package, you set a flag (to 0 or 1, perhaps) saying > whether to use 0-based or 1-based indexing, according to preference. The > package then adjusts all indexes as requested. > > You still have to decide what the default should be (unless not specifying > is an error), but that's a much easier (read: less stressful) decision if > there's a way to override it. (I'd agree with Chip on what the default > should be :-).) When I started reading this thread, APL's "index origin" came immediately to mind. But in this case I find a REXX "astonishment factor" -- not in its behaviour, but in that its author would agree with and even propose something I imagined would be shot down in moments. Instead, everyone seems to like it! APL started with a global index origin, settable only as an overall and external attribute of a workspace, and not capable of being set or interrogated by the running program. This soon changed, but I believe in most implementations it was/is still a global value not related to any concept of package, or at least not to any package smaller than the entire workspace. There is an interesting _APL in the New Millennium_ article by Ken Iverson at http://www.vector.org.uk/archive/v223/newmill.htm in which he talked about some topics that will be familiar to the REXX community - multiple dialects, community size, and index origin only some of them. (But I see that APL has a movie in the works - can REXX say that? http://aprogramminglanguage.wordpress.com/film-synopsis/ .) Hmmm... KEI - IBM Fellow 1970 MFC - IBM Fellow 1990 Now if someone can tell me why the array class doesn't like indexes less than 1... Tony H. |
From: Mike C. <MF...@uk...> - 2010-01-13 11:17:41
|
> > There is a third path that one might consider, if it makes sense (in > > particular, the package needs to have some kind of persistent state, or > > able to get at some from the Rexx implementation), and that is: let the > > user choose. > > > > APL (I think it was) does this: essentially when starting to write a > > program using the package, you set a flag (to 0 or 1, perhaps) saying > > whether to use 0-based or 1-based indexing, according to preference. The > > package then adjusts all indexes as requested. > > > > You still have to decide what the default should be (unless not specifying > > is an error), but that's a much easier (read: less stressful) decision if > > there's a way to override it. (I'd agree with Chip on what the default > > should be :-).) > > When I started reading this thread, APL's "index origin" came > immediately to mind. But in this case I find a REXX "astonishment > factor" -- not in its behaviour, but in that its author would agree > with and even propose something I imagined would be shot down in > moments. Instead, everyone seems to like it! > > APL started with a global index origin, settable only as an overall > and external attribute of a workspace, and not capable of being set or > interrogated by the running program. This soon changed, but I believe > in most implementations it was/is still a global value not related to > any concept of package, or at least not to any package smaller than > the entire workspace. That's the difference in what I was proposing ... the changeable index would be relate to and affect only to the particular package (for which the documentation, we are told, uses 0-indexing). Definitely not a global setting, and definitely not changing Rexx's inherent indexing (in, for example, the built-in functions such as POS or WORD). I agree the latter would be disasterous ... Mike Unless stated otherwise above: IBM United Kingdom Limited - Registered in England and Wales with number 741598. Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU |
From: Rony G. F. <Ron...@wu...> - 2010-01-13 17:25:53
|
Mike Cowlishaw wrote: > > > There is a third path that one might consider, if it makes sense (in > > > particular, the package needs to have some kind of persistent > state, or > > > able to get at some from the Rexx implementation), and that is: > let the > > > user choose. > > > > > > APL (I think it was) does this: essentially when starting to write a > > > program using the package, you set a flag (to 0 or 1, perhaps) saying > > > whether to use 0-based or 1-based indexing, according to > preference. The > > > package then adjusts all indexes as requested. > > > > > > You still have to decide what the default should be (unless not > specifying > > > is an error), but that's a much easier (read: less stressful) > decision if > > > there's a way to override it. (I'd agree with Chip on what the > default > > > should be :-).) > > > > When I started reading this thread, APL's "index origin" came > > immediately to mind. But in this case I find a REXX "astonishment > > factor" -- not in its behaviour, but in that its author would agree > > with and even propose something I imagined would be shot down in > > moments. Instead, everyone seems to like it! > > > > APL started with a global index origin, settable only as an overall > > and external attribute of a workspace, and not capable of being set or > > interrogated by the running program. This soon changed, but I believe > > in most implementations it was/is still a global value not related to > > any concept of package, or at least not to any package smaller than > > the entire workspace. > > That's the difference in what I was proposing ... the changeable index > would be relate to and affect only to the particular package (for > which the documentation, we are told, uses 0-indexing). Definitely > not a global setting, and definitely not changing Rexx's inherent > indexing (in, for example, the built-in functions such as POS or WORD). > > I agree the latter would be disasterous ... In BSF4[oo]Rexx the addressing of Java arrays (0-based) is done 1-based by wrapping up Java array objects in ooRexx proxy array objects (which also gained a few of the ooRexx array methods like items, dimension etc.). This way Java array objects are in effect camouflaged as ooRexx arrays, which makes addressing Java array objects straightforward/easy for ooRexx programmers. Otherwise no re-basing was necessary, such that the documentation of the Java methods can be applied 1:1 if excercised from ooRexx. (And if the documentation states that some argument to a method is 0-based, so be it.) ---rony |
From: David A. <dav...@gm...> - 2010-01-11 17:40:45
|
I REALLY like this idea. It is the best of both worlds and easy to implement with a small set of C macros. Allowing the user to change the behaviour gives the user the feeling of control and enhances their level of comfort whatever their choice might be. Thanks for the idea, Mike. David Ashley On 01/11/2010 01:48 AM, Mike Cowlishaw wrote: > [retry] > > > I am working on an ooRexx interface to something that is normally > > programmed in C. Of course, C uses zero-based indexes for thing like > > memory, array positions, etc. My code could be architected to either > > carry this forward to the ooRexx interface when it calls the C > functions > > or it could translate the zero-based numbers to the more user friendly > > (and Rexx default) one-based numbering system. > > There is a third path that one might consider, if it makes sense (in > particular, the package needs to have some kind of persistent state, or > able to get at some from the Rexx implementation), and that is: let the > user choose. > > APL (I think it was) does this: essentially when starting to write a > program using the package, you set a flag (to 0 or 1, perhaps) saying > whether to use 0-based or 1-based indexing, according to preference. The > > package then adjusts all indexes as requested. > > You still have to decide what the default should be (unless not > specifying > is an error), but that's a much easier (read: less stressful) decision if > > there's a way to override it. (I'd agree with Chip on what the default > should be :-).) > > Mike > > > > > > > Unless stated otherwise above: > IBM United Kingdom Limited - Registered in England and Wales with number > 741598. > Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU > > > > > > > > ------------------------------------------------------------------------------ > This SF.Net email is sponsored by the Verizon Developer Community > Take advantage of Verizon's best-in-class app development support > A streamlined, 14 day to market process makes app distribution fast and easy > Join now and get one step closer to millions of Verizon customers > http://p.sf.net/sfu/verizon-dev2dev > _______________________________________________ > Oorexx-devel mailing list > Oor...@li... > https://lists.sourceforge.net/lists/listinfo/oorexx-devel > > |
From: Rick M. <obj...@gm...> - 2010-01-11 17:44:58
|
You need to be careful that this is not a global setting. I can easily envision reusable libraries of code being written that uses these facility. Any dialogs should be work without messing up unrelated code pieces where the author prefers a different style. Rick On Mon, Jan 11, 2010 at 12:40 PM, David Ashley <dav...@gm...> wrote: > I REALLY like this idea. It is the best of both worlds and easy to > implement with a small set of C macros. Allowing the user to change the > behaviour gives the user the feeling of control and enhances their level > of comfort whatever their choice might be. > > Thanks for the idea, Mike. > > David Ashley > > On 01/11/2010 01:48 AM, Mike Cowlishaw wrote: >> [retry] >> >> > I am working on an ooRexx interface to something that is normally >> > programmed in C. Of course, C uses zero-based indexes for thing like >> > memory, array positions, etc. My code could be architected to either >> > carry this forward to the ooRexx interface when it calls the C >> functions >> > or it could translate the zero-based numbers to the more user friendly >> > (and Rexx default) one-based numbering system. >> >> There is a third path that one might consider, if it makes sense (in >> particular, the package needs to have some kind of persistent state, or >> able to get at some from the Rexx implementation), and that is: let the >> user choose. >> >> APL (I think it was) does this: essentially when starting to write a >> program using the package, you set a flag (to 0 or 1, perhaps) saying >> whether to use 0-based or 1-based indexing, according to preference. The >> >> package then adjusts all indexes as requested. >> >> You still have to decide what the default should be (unless not >> specifying >> is an error), but that's a much easier (read: less stressful) decision if >> >> there's a way to override it. (I'd agree with Chip on what the default >> should be :-).) >> >> Mike >> >> >> >> >> >> >> Unless stated otherwise above: >> IBM United Kingdom Limited - Registered in England and Wales with number >> 741598. >> Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU >> >> >> >> >> >> >> >> ------------------------------------------------------------------------------ >> This SF.Net email is sponsored by the Verizon Developer Community >> Take advantage of Verizon's best-in-class app development support >> A streamlined, 14 day to market process makes app distribution fast and easy >> Join now and get one step closer to millions of Verizon customers >> http://p.sf.net/sfu/verizon-dev2dev >> _______________________________________________ >> Oorexx-devel mailing list >> Oor...@li... >> https://lists.sourceforge.net/lists/listinfo/oorexx-devel >> >> > > > ------------------------------------------------------------------------------ > This SF.Net email is sponsored by the Verizon Developer Community > Take advantage of Verizon's best-in-class app development support > A streamlined, 14 day to market process makes app distribution fast and easy > Join now and get one step closer to millions of Verizon customers > http://p.sf.net/sfu/verizon-dev2dev > _______________________________________________ > Oorexx-devel mailing list > Oor...@li... > https://lists.sourceforge.net/lists/listinfo/oorexx-devel > |
From: John B. <joh...@in...> - 2010-01-12 02:16:01
|
I agree with Mike. It sounds like a lot of people are divided on this issue. I would think that there some C programmers out there that do programming for other that REXX and I bet they would not enjoy having to switch their mental processing based on whether or not they are programming for REXX. And if they have been programming if C for a while, they don't want to switch their thinking just because REXX. Is a programmer thinking zero based or one base when they are programming for REXX? jOHN -----Original Message----- From: David Ashley [mailto:dav...@gm...] Sent: Saturday, January 09, 2010 12:43 PM To: ooRexxDevel Subject: [Oorexx-devel] Opinions Wanted All - I am working on an ooRexx interface to something that is normally programmed in C. Of course, C uses zero-based indexes for thing like memory, array positions, etc. My code could be architected to either carry this forward to the ooRexx interface when it calls the C functions or it could translate the zero-based numbers to the more user friendly (and Rexx default) one-based numbering system. I have mixed emotions on this. On the one hand I much prefer the one-based system that Rexx uses. On the other hand, C programmers who have programmed to this interface in the past will be more comfortable with the zero-based numbering system. But I also want to bring in those C and Perl programmers into the Rexx arena and that means having them get used to a one-based system. Also, all the documentation and examples for the system I am interfacing to ooRexx is for C and Perl programmers. Thus all those docs and examples are zero-based meaning that translating the examples to Rexx involves some updating of the source program number constants. So I really am of two minds about this. In the past I have always leaned to making things easiest for the Rexx programmer but this case has made me rethink that idea. I am now questioning my assumptions and I want some other opinions before I proceed too far. Thank, David Ashley ---------------------------------------------------------------------------- -- This SF.Net email is sponsored by the Verizon Developer Community Take advantage of Verizon's best-in-class app development support A streamlined, 14 day to market process makes app distribution fast and easy Join now and get one step closer to millions of Verizon customers http://p.sf.net/sfu/verizon-dev2dev _______________________________________________ Oorexx-devel mailing list Oor...@li... https://lists.sourceforge.net/lists/listinfo/oorexx-devel |
From: Chip D. <ch...@av...> - 2010-01-12 04:48:44
|
On 1/11/10 20:29 John Bodoh asked: > Is a programmer thinking zero based or one base when they are programming > for REXX? All _people_ start lists with '1'. All _programmers_ (before the mid-seventies) started lists with '1'. _Only_C_programmers_ adjust their thinking to start lists with '0'. Their bike handlebars were misaligned ten degrees to the left since they got it. When they get on a bike with the handlebars aligned with the axis of the wheel, they will quickly accommodate because that's what _people_ do. While there are many issues of program language design that are matters of taste, style, peculiar environment, and such, this is one where Ritchie simply got it wrong. He had his reason, but that is exactly one of those cases where a short-term impediment should not be allowed to drive design. If a C programmer uses Rexx (in any flavor) he will have to adjust his thinking on quotes, strings, operators, and quite a few other matters besides the first index of a list. I, too, agree that Mike has the best approach. A flag will indicate 0- or 1-based indices with the latter the default. You could use the same mechanism for other differences such as the treatment of the double-quote if you wish. -Chip- |
From: Jack W. <ja...@we...> - 2010-01-12 04:51:38
|
Chip Davis wrote: > _Only_C_programmers_ adjust their thinking to start lists with '0'. > > Nah, we did that in Forth too. -- Jack J. Woehr # Reality is unpredictable, and no amount of computer technology http://www.well.com/~jax # is going to change that. - David Brooks, conservative pundit, http://www.softwoehr.com # "The God That Fails", 2009-12-31 New York Times |
From: Chip D. <ch...@av...> - 2010-01-12 08:09:45
|
That's interesting. I played around with Forth back in the mid-70's and, while I have never been a fan of RPN, I remember being impressed with its flexibility. What I don't remember is there being any sort of list construct that took an index. None of the stacks did. Then again, there were a number of variants of Forth over the years. Perhaps mine was a minimal implementation. Is it possible that your Forth had self-created a 0-based list word? I know exactly where my Forth textbook is on my bookshelves, but they are three states away right now, so I'll just have to take your word for it. Regardless, in the pantheon of quirky non-human-oriented programming languages, Forth has to rank fairly high. Not bad for an astronomer in the late 50, tho... -Chip- On 1/12/10 04:33 Jack Woehr said: > Chip Davis wrote: >> _Only_C_programmers_ adjust their thinking to start lists with '0'. >> >> > Nah, we did that in Forth too. > |
From: Jack W. <ja...@we...> - 2010-01-12 15:44:39
|
Chip Davis wrote: > That's interesting. I played around with Forth back in the mid-70's and, while > I have never been a fan of RPN, I remember being impressed with its flexibility. > > What I don't remember is there being any sort of list construct that took an > index. : regards ( --) 2 0 do S" GARDS " type loop cr ; ok regards GARDS GARDS ok -- Jack J. Woehr # Reality is unpredictable, and no amount of computer technology http://www.well.com/~jax # is going to change that. - David Brooks, conservative pundit, http://www.softwoehr.com # "The God That Fails", 2009-12-31 New York Times |
From: Robert G. <ro...@ga...> - 2010-01-12 16:38:45
|
>Nah, we did that in Forth too. ...and Assembler, but my opinion on the matter is that everything in Rexx ought to act like Rexx. It should be consistent. I can't imagine anything uglier than having some parts of the language be 1-based and other parts be 0-based. That situation would cause far more programming errors than having to make a mental adjustment ever would. Programmers don't choose to work in a particular language based on how similar it is to something they already know, do they? They choose to work in a language because in their opinion its the best-fit tool for their current needs, or maybe because they want to learn something new. Rob |