The Importance of Terminology's Quality

Discussion in 'Perl Misc' started by xahlee@gmail.com, May 8, 2008.

  1. Guest

    I'd like to introduce a blog post by Stephen Wolfram, on the design
    process of Mathematica. In particular, he touches on the importance of
    naming of functions.

    • Ten Thousand Hours of Design Reviews (2008 Jan 10) by Stephen
    Wolfram
    http://blog.wolfram.com/2008/01/10/ten-thousand-hours-of-design-reviews/

    The issue is fitting here today, in our discussion of “closureâ€
    terminology recently, as well the jargons “lisp 1 vs lisp2†(multi-
    meaning space vs single-meaning space), “tail recursionâ€, “curryingâ€,
    “lambdaâ€, that perennially crop up here and elsewhere in computer
    language forums in wild misunderstanding and brouhaha.

    The functions in Mathematica, are usually very well-name, in contrast
    to most other computing languages. In particular, the naming in
    Mathematica, as Stephen Wolfram implied in his blog above, takes the
    perspective of naming by capturing the essense, or mathematical
    essence, of the keyword in question. (as opposed to, naming it
    according to convention, which often came from historical happenings)
    When a thing is well-named from the perspective of what it actually
    “mathematically†is, as opposed to historical developments, it avoids
    vast amount of potential confusion.

    Let me give a few example.

    • “lambdaâ€, widely used as a keyword in functional languages, is named
    just “Function†in Mathematica. The “lambdaâ€happend to be called so
    in the field of symbolic logic, is due to use of the greek letter
    lambda “λ†by happenstance. The word does not convey what it means.
    While, the name “Functionâ€, stands for the mathematical concept of
    “function†as is.

    • Module, Block, in Mathematica is in lisp's various “let*â€. The
    lisp's keywords “letâ€, is based on the English word “letâ€. That word
    is one of the English word with multitudes of meanings. If you look up
    its definition in a dictionary, you'll see that it means many
    disparate things. One of them, as in “let's goâ€, has the meaning of
    “permit; to cause to; allowâ€. This meaning is rather vague from a
    mathematical sense. Mathematica's choice of Module, Block, is based on
    the idea that it builds a self-contained segment of code. (however,
    the choice of Block as keyword here isn't perfect, since the word also
    has meanings like “obstruct; jamâ€)

    • Functions that takes elements out of list are variously named First,
    Rest, Last, Extract, Part, Take, Select, Cases, DeleteCases... as
    opposed to “carâ€, “cdrâ€, “filterâ€, “filterâ€, “popâ€, “shiftâ€,
    “unshiftâ€, in lisps and perl and other langs.

    The above are some examples. The thing to note is that, Mathematica's
    choices are often such that the word stands for the meaning themselves
    in some logical and independent way as much as possible, without
    having dependent on a particular computer science field's context or
    history. One easy way to confirm this, is taking a keyword and ask a
    wide audience, who doesn't know about the language or even unfamiliar
    of computer programing, to guess what it means. The wide audience can
    be made up of mathematicians, scientists, engineers, programers,
    laymen. This general audience, are more likely to guess correctly what
    Mathematica's keyword is meant in the language, than the the name used
    in other computer languages who's naming choices goes by convention or
    context.

    (for example, Perl's naming heavily relies on unix culture (grep,
    pipe, hash...), while functional lang's namings are typically heavily
    based on the field of mathematical logic (e.g. lambda, currying,
    closure, monad, ...). Lisp's cons, car, cdr, are based on computer
    hardware (this particular naming, caused a major damage to the lisp
    language to this day). (Other examples: pop, shift are based on
    computer science jargon of “stackâ€. Grep is from Global Regular
    Expression Print, while Regular Expression is from theoretical
    computer science of Automata... The name regex has done major hidden
    damage to the computing industry, in the sense that if it have just
    called it “string patternsâ€, then a lot explanations, literatures,
    confusions, would have been avoided.))

    (Note: Keywords or functions in Mathematica are not necessarily always
    best named. Nor are there always one absolute choice as best, as there
    are many other considerations, such as the force of wide existing
    convention, the context where the function are used, brevity,
    limitations of English language, different scientific context (e.g.
    math, physics, engineering), or even human preferences.)

    ----------------------------

    Many of the issues regarding the importance and effects of
    terminology's quality, i've wrote about since about 2000. Here are the
    relevant essays:

    • Jargons of Info Tech Industry
    http://xahlee.org/UnixResource_dir/writ/jargons.html

    • The Jargon “Lisp1†vs “Lisp2â€
    http://xahlee.org/emacs/lisp1_vs_lisp2.html

    • The Term Curring In Computer Science
    http://xahlee.org/UnixResource_dir/writ/currying.html

    • What Is Closure In A Programing Language
    http://xahlee.org/UnixResource_dir/writ/closure.html

    • What are OOP's Jargons and Complexities
    http://xahlee.org/Periodic_dosage_dir/t2/oop.html

    • Sun Microsystem's abuse of term “API†and “Interfaceâ€
    http://xahlee.org/java-a-day/interface.html

    • Math Terminology and Naming of Things
    http://xahlee.org/cmaci/notation/math_namings.html

    Xah

    ∑ http://xahlee.org/

    ☄
     
    , May 8, 2008
    #1
    1. Advertising

  2. <> wrote in message
    news:...

    [...]

    (for example, Perl's naming heavily relies on unix culture (grep,
    pipe, hash...), ...

    "hash" + "pipe"? Ahhhhh, /no wonder/ Perl is the syntactic mishmash it is!
    ;-)
     
    Bruce C. Baker, May 8, 2008
    #2
    1. Advertising

  3. > • Module, Block, in Mathematica is in lisp's various “let*”. The
    > lisp's keywords “let”, is based on the English word “let”. That word
    > is one of the English word with multitudes of meanings. If you look up
    > its definition in a dictionary, you'll see that it means many
    > disparate things. One of them, as in “let's go”, has the meaning of
    > “permit; to cause to; allow”. This meaning is rather vague from a
    > mathematical sense. Mathematica's choice of Module, Block, is based on
    > the idea that it builds a self-contained segment of code. (however,
    > the choice of Block as keyword here isn't perfect, since the word also
    > has meanings like “obstruct; jam”)


    If the purpose of let is to introduce one or more variable bindings,
    then I don't see how changing to block or module would improve
    anything. I've always found it fairly intuitive to parse (let ((x
    5)) ...) to "let x be five". Additionally, replacing let with the
    synonyms you provided would approximately yield "permit x to be five"
    or "allow x to be five". In my mind you have constructed an argument
    in favor of let here (obviously it's better than block, because
    nobody's going to come along and be confused about whether let will
    "obstruct" or "jam" them :)

    There are many easy targets to poke at in the CL spec. let isn't one
    of those.
     
    Kyle McGivney, May 8, 2008
    #3
  4. George Neuner <gneuner2/@/comcast.net> wrote:
    >On Wed, 7 May 2008 16:13:36 -0700 (PDT), ""
    ><> wrote:


    +-------------------+ .:\:\:/:/:.
    | PLEASE DO NOT | :.:\:\:/:/:.:
    | FEED THE TROLLS | :=.' - - '.=:
    | | '=(\ 9 9 /)='
    | Thank you, | ( (_) )
    | Management | /`-vvv-'\
    +-------------------+ / \
    | | @@@ / /|,,,,,|\ \
    | | @@@ /_// /^\ \\_\
    @x@@x@ | | |/ WW( ( ) )WW
    \||||/ | | \| __\,,\ /,,/__
    \||/ | | | jgs (______Y______)
    /\/\/\/\/\/\/\/\//\/\\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\
    ==============================================================

    jue
     
    Jürgen Exner, May 8, 2008
    #4
  5. Guest


    >          |   PLEASE DO NOT   |            :.:\:\:/:/:.:
    >          |  FEED THE TROLLS  |           :=.' -   - '.=:


    I don't think Xah is trolling here (contrary to his/her habit)
    but posing an interesting matter of discussion.

    Don't know to which point it fits, but I would like to do some rather
    novel comment on operator naming:
    As a non native english speaker, the first time I ever encountered the
    word "if" was when learning to program. The same can be said of the
    other words (for, then, else...) This caused my brain to adscribe them
    meanings completely outside the context of everyday language. My point
    is that perhaps this is advantageous. So, contrary to tradition (which
    considers a desirable goal to write programs as close as possible to
    everyday english), I found convenient that programming languages use
    words different from the words of my native tongue. I suspect that is
    why car and cdr have caught on vs. first end rest.
     
    , May 8, 2008
    #5
  6. j.oke Guest

    ha scritto:

    > [bli bla blo, blu blu bum bum bam bam bim bim bim...]


    don't know Y, by your arty-phycial excerptions always seem chinese
    me...

    -JO
     
    j.oke, May 8, 2008
    #6
  7. Lew wrote:
    > wrote:
    > > > | PLEASE DO NOT | :.:\:\:/:/:.:
    > > > | FEED THE TROLLS | :=.' - - '.=:

    > >
    > > I don't think Xah is trolling here (contrary to his/her habit)
    > > but posing an interesting matter of discussion.

    >
    > Interesting is in the eye of the beholder. After you'd read the same
    > recycled crud from certain posters again and again, it because
    > trollish spam.


    Then why are you reading it? If you don't want to read his posts then
    don't. Use your killfile or just skip over his threads.

    --
    wg
     
    Waylen Gumbal, May 9, 2008
    #7
  8. Sherman Pendley wrote:
    > writes:
    > >
    > > > PLEASE DO NOT | :.:\:\:/:/:.:
    > > > FEED THE TROLLS | :=.' - - '.=:

    > >
    > > I don't think Xah is trolling here (contrary to his/her habit)
    > > but posing an interesting matter of discussion.

    >
    > It might be interesting in the abstract, but any such discussion, when
    > cross-posted to multiple language groups on usenet, will inevitably
    > devolve into a flamewar as proponents of the various languages argue
    > about which language better expresses the ideas being talked about.
    > It's like a law of usenet or something.
    >
    > If Xah wanted an interesting discussion, he could have posted this to
    > one language-neutral group such as comp.programming. He doesn't want
    > that - he wants the multi-group flamefest.


    Not everyone follows language-neutral groups (such as comp,programming
    as you pointed out), so you actually reach more people by cross posting.
    This is what I don't understand - everyone seems to assume that by cross
    posting, one intends on start a "flamefest", when in fact most such
    "flamefests" are started by those who cannot bring themselves to
    skipping over the topic that they so dislike.

    --
    wg
     
    Waylen Gumbal, May 9, 2008
    #8
  9. "Waylen Gumbal" <> wrote:
    >Sherman Pendley wrote:
    >> writes:
    >> >
    >> > > PLEASE DO NOT | :.:\:\:/:/:.:
    >> > > FEED THE TROLLS | :=.' - - '.=:

    >Not everyone follows language-neutral groups (such as comp,programming
    >as you pointed out), so you actually reach more people by cross posting.


    You seem so have failed to grasp the concept of why Usenet is divided
    into separate groups in the first place.

    >This is what I don't understand - everyone seems to assume that by cross
    >posting, one intends on start a "flamefest", when in fact most such
    >"flamefests" are started by those who cannot bring themselves to
    >skipping over the topic that they so dislike.


    By your argument there is no need for individual groups in the first
    place. We could just as well use a single "HereGoesEverything" and just
    skip over those topics that we so dislike.

    jue
     
    Jürgen Exner, May 9, 2008
    #9
  10. Lew wrote:
    > Waylen Gumbal wrote:
    >> Not everyone follows language-neutral groups (such as
    >> comp,programming as you pointed out), so you actually reach more
    >> people by cross posting. This is what I don't understand - everyone
    >> seems to assume that by cross posting, one intends on start a
    >> "flamefest", when in fact most such "flamefests" are started by
    >> those who cannot bring themselves to skipping over the topic that
    >> they so dislike.

    >
    > It's not an assumption in Xah Lee's case. He spams newsgroups
    > irregularly with rehashed essays from years ago, and a number of
    > people are just tired of him.


    I did not know this. One should obviously not do that.

    > Don't blame the victims for the perpetrator's actions, OK?


    I'm not blaming any "victims", but I don't see anyone saying "read this
    or else", so why not just skip the thread or toss the OP in your
    killfile so you don't see his postings. If others want to discuss his
    topics, who are you or I to tell them not to?

    --
    wg
     
    Waylen Gumbal, May 9, 2008
    #10
  11. "Waylen Gumbal" <> wrote:
    > so why not just skip the thread or toss the OP in your
    >killfile so you don't see his postings.


    Done years ago.

    >If others want to discuss his
    >topics, who are you or I to tell them not to?


    They are very welcome to do so in an appropriate NG for those topics.

    jue
     
    Jürgen Exner, May 9, 2008
    #11
  12. George Neuner wrote:
    > On Thu, 8 May 2008 22:38:44 -0700, "Waylen Gumbal" <>
    > wrote:




    > > Not everyone follows language-neutral groups (such as
    > > comp,programming as you pointed out), so you actually reach more
    > > people by cross posting. This is what I don't understand - everyone
    > > seems to assume that by cross posting, one intends on start a
    > > "flamefest", when in fact most such "flamefests" are started by
    > > those who cannot bring themselves to skipping over the topic that
    > > they so dislike.

    >
    > The problem is that many initial posts have topics that are misleading
    > or simplistic. Often an interesting discussion can start on some
    > point the initial poster never considered or meant to raise.


    Is this not a possibility for any topic, whether it's cross-posted or
    not?


    --
    wg
     
    Waylen Gumbal, May 10, 2008
    #12
  13. David Combs wrote:
    > passing
    > *unnamed* functions as args (could Algol 60 also do something like that,
    > via something it maybe termed a "thunk")


    No, the "thunks" were necessary at the machine-language level to
    /implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.

    --
    John W. Kennedy
    "The first effect of not believing in God is to believe in anything...."
    -- Emile Cammaerts, "The Laughing Prophet"
     
    John W Kennedy, Jun 24, 2008
    #13
  14. Robert Maas, http://tinyurl.com/uh3t wrote:
    > Why this response is so belated:
    > <http://groups.google.com/group/misc.misc/msg/cea714440e591dd2>
    > = <news:>
    >> Date: Tue, 24 Jun 2008 18:42:15 -0400
    >> From: John W Kennedy <>
    >> ... the "thunks" were necessary at the machine-language level to
    >> /implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.

    >
    > Ah, thanks for the clarification. Is that info in the appropriate
    > WikiPedia page? If not, maybe you would edit it in?


    It is explained s.v. "thunk", which is referenced from "ALGOL 60". The
    ALGOL "pass-by-name" argument/parameter matching was perhaps the most
    extreme example ever of a language feature that was "elegant" but
    insane. What it meant, in effect, was that, unless otherwise marked,
    every argument was passed as two closures, one that returned a fresh
    evaluation of the expression given as the argument, which was called
    every time the parameter was read, and one that set the argument to a
    new value, which was called every time the parameter was set.

    See <URL:http://www.cs.sfu.ca/~cameron/Teaching/383/PassByName.html>.

    ALGOL 60 could not create generalized user-written closures, but could
    create one no more complex than a single expression with no arguments of
    its own simply by passing the expression as an argument. But it was not
    thought of as a closure; that was just how ALGOL 60 did arguments.
    --
    John W. Kennedy
    "Give up vows and dogmas, and fixed things, and you may grow like
    That. ...you may come to think a blow bad, because it hurts, and not
    because it humiliates. You may come to think murder wrong, because it
    is violent, and not because it is unjust."
    -- G. K. Chesterton. "The Ball and the Cross"
     
    John W Kennedy, Jul 2, 2008
    #14
  15. Robert Maas, http://tinyurl.com/uh3t wrote:
    >>>> ... the "thunks" were necessary at the machine-language level to
    >>>> /implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.
    >>> Ah, thanks for the clarification. Is that info in the appropriate
    >>> WikiPedia page? If not, maybe you would edit it in?

    >> From: John W Kennedy <>
    >> It is explained s.v. "thunk", which is referenced from "ALGOL
    >> 60". The ALGOL "pass-by-name" argument/parameter matching was
    >> perhaps the most extreme example ever of a language feature that
    >> was "elegant" but insane. What it meant, in effect, was that,
    >> unless otherwise marked, every argument was passed as two closures,
    >> one that returned a fresh evaluation of the expression given as the
    >> argument, which was called every time the parameter was read, and
    >> one that set the argument to a new value, which was called every
    >> time the parameter was set.

    >
    > Wow! All these years when I occasionally heard of a "thunk" I never
    > was told, until now, what it really meant. Thanks for the info!!
    >
    > Followup question #1: I assume these are lexical closures in the
    > environment of the point of the call, right?


    Yes. (Actually, subprogram calls are first described as working like
    macro expansions, but then the specification adds that there must be
    magic fixups so that variable names are resolved in point-of-call
    context anyway.)

    At this point in the history of computing, the conceptual distinction
    between subprograms and macros was not at all clear. It was quite
    possible to have "macros" that generated an out-of-line subprogram once
    and then generated calling code the first time and every time thereafter
    (it was a way of life on systems without linkage editors or linking
    loaders), and it was also quite possible to refer to in-line macro
    expansions as "subprograms". I suspect that the triumph of FORTRAN may
    have had something to do with cleaning up the terminological mess by the
    mid-60s.

    Into the 60s, indeed, there were still machines being made that had no
    instruction comparable to the mainframe BASx/BALx family, or to Intel's
    CALL. You had to do a subprogram call by first overwriting the last
    instruction of what you were calling with a branch instruction that
    would return back to you.

    > Followup question #2: For simple arithmetic expressions, I can
    > possibly understand how the UPDATE closure might be implemeted
    > (expressed in Lisp to make the intent clear):
    > Call form: MyFunction(X+2);
    > GET closure: (+ closedX 2)
    > UPDATE closure: (lambda (newval) (setf closedX (- newval 2))
    > Thus from inside MyFunction where formal parameter Arg1 is bound
    > to actual parameter X+2, after doing Arg1 := 7; X will have the
    > value 5 so that calling Arg1 will return 7 as expected, right?
    > But if the actual argument is something complicated, especially if
    > it makes a nested function call, how can that possibly be
    > implemented?


    It was forbidden. In the formal definition of ALGOL 60, there was no
    such thing as an external subprogram (except for non-ALGOL code, which
    was treated as magic), so the whole program was supposed to be one
    compile. Therefore, a theoretical compiler could verify that any
    parameter used as an LHS was always matched with an argument that was a
    variable. (However, a "thunk" was still required to evaluate any array
    index and, possibly, to convert between REAL and INTEGER variables.)
    Many actual compilers /did/ support separate complication as a language
    extension -- I suppose they had to use run-time checking.

    --
    John W. Kennedy
    "Compact is becoming contract,
    Man only earns and pays."
    -- Charles Williams. "Bors to Elayne: On the King's Coins"
     
    John W Kennedy, Jul 20, 2008
    #15
  16. On Tue, 24 Jun 2008 18:42:15 -0400, John W Kennedy wrote:

    > David Combs wrote:
    >> passing
    >> *unnamed* functions as args (could Algol 60 also do something like that,
    >> via something it maybe termed a "thunk")

    >
    > No, the "thunks" were necessary at the machine-language level to
    > /implement/ ALGOL 60, but they could not be expressed /in/ ALGOL.
    >

    Are you sure about that?

    The first time I ran across the term "thunking" was when Windows 3
    introduced the Win32S shim and hence the need to switch addressing between
    16 bit and 32 bit modes across call interfaces. That was called "thunking"
    by Microsoft and even they would surely admit it was a kludge.

    I used Algol 60 on an Elliott 503 and the ICL 1900 series back when it was
    a current language. The term "thunking" did not appear in either compiler
    manual nor in any Algol 60 language definition I've seen. A60 could pass
    values by name or value and procedures by name. That was it. Call by name
    is what is now referred to as reference passing.

    I should also point out that Algol 60 was initially written as a means for
    communicating algorithms between people. Compiler implementations came
    later. In consequence the language did not define links to libraries or
    i/o methods. Both features were compiler specific - for instance the
    Elliott introduced 'input' and 'print' reserved words and syntax while the
    1900 compilers used function calls. The Elliott approach was more readable.

    Algol 60 did not have 'functions'. It had procedures which could be
    declared to return values or not. A procedure that returned a value was
    equivalent to a function but the term 'function' was not used. Similarly
    it did not have a mechanism for declaring anonymous procedures. That, like
    the incorporation of machine code inserts, would have been a
    compiler-specific extension, so it is a terminological mistake to refer to
    it without specifying the implementing compiler.


    --
    martin@ | Martin Gregorie
    gregorie. |
    org | Zappa fan & glider pilot
     
    Martin Gregorie, Jul 22, 2008
    #16
  17. Martin Gregorie wrote:

    > Are you sure about that?


    > I used Algol 60 on an Elliott 503 and the ICL 1900 series back when it was
    > a current language. The term "thunking" did not appear in either compiler
    > manual nor in any Algol 60 language definition I've seen. A60 could pass
    > values by name or value and procedures by name. That was it. Call by name
    > is what is now referred to as reference passing.


    Are you sure about that? ;-)

    AFAIK "Call by name" is *not* the same as passing an argument by
    reference. With "call by name" you can implement this wonderful thing
    called "Jensen's Device", which you cannot do when you pass parameters
    by reference!

    Josef
    --
    These are my personal views and not those of Fujitsu Siemens Computers!
    Josef Möllers (Pinguinpfleger bei FSC)
    If failure had no penalty success would not be a prize (T. Pratchett)
    Company Details: http://www.fujitsu-siemens.com/imprint.html
     
    Josef Moellers, Jul 22, 2008
    #17
  18. Martin Gregorie wrote:
    > I used Algol 60 on an Elliott 503 and the ICL 1900 series back when it was
    > a current language. The term "thunking" did not appear in either compiler
    > manual nor in any Algol 60 language definition I've seen.


    It doesn't have to; Algol 60 thunks are not part of the language.
    However, practical implementation of Algol 60 call by name means that
    thunks are created by every Algol 60 compiler, and the word "thunk" was
    coined in 1961 to designate them.

    > A60 could pass
    > values by name or value and procedures by name. That was it. Call by name
    > is what is now referred to as reference passing.


    Either you misunderstood (because in many simple cases the semantics of
    call-by-reference and call-by-name cannot be distinguished) or the
    compiler you used implemented non-standard Algol (which was fairly
    common in compilers meant for day-to-day practical work). Algol
    call-by-name was a unique form that subsequent language designers have
    recoiled from in horror.

    (Historically, "call-by-name" has sometimes been used in non-Algol
    contexts to mean "call-by-reference".)

    > Algol 60 did not have 'functions'. It had procedures which could be
    > declared to return values or not. A procedure that returned a value was
    > equivalent to a function but the term 'function' was not used.


    This is simply wrong. You are accurately describing the language syntax,
    which used (as PL/I does) the keyword "procedure" for both functions
    and subroutines, but Algol documentation nevertheless referred to
    "functions".

    > Similarly
    > it did not have a mechanism for declaring anonymous procedures. That, like
    > the incorporation of machine code inserts, would have been a
    > compiler-specific extension, so it is a terminological mistake to refer to
    > it without specifying the implementing compiler.


    Standards-conforming Algol compilers had a limited ability to create
    de-facto anonymous functions in the call-by-name implementation.

    --
    John W. Kennedy
    "Information is light. Information, in itself, about anything, is light."
    -- Tom Stoppard. "Night and Day"
     
    John W Kennedy, Jul 22, 2008
    #18
  19. Rob Warnock wrote:
    > Thunks were something used by Algol 60
    > *compiler writers* in the code generated by their compilers to
    > implement the semantics of Algol 60 call-by-name, but were not
    > visible to users at all [except that they allowed call-by-name
    > to "work right"].


    ....unless you were a system programmer and had to write Algol-friendly
    assembler.



    --
    John W. Kennedy
    "Give up vows and dogmas, and fixed things, and you may grow like
    That. ...you may come to think a blow bad, because it hurts, and not
    because it humiliates. You may come to think murder wrong, because it
    is violent, and not because it is unjust."
    -- G. K. Chesterton. "The Ball and the Cross"
     
    John W Kennedy, Jul 22, 2008
    #19
  20. Roedy Green Guest

    On Tue, 12 Aug 2008 12:28:33 -0700,
    (Robert Maas,
    http://tinyurl.com/uh3t) wrote, quoted or indirectly quoted someone
    who said :

    >Note: On IBM 1620, instructions and forward-sweeping data records
    >were addressed by their *first* digit, whereas arithmetic fields
    >were addressed by their *last* digit, the low-order position, to
    >support natural add-and-carry operations. Storage was decimal
    >digits, with two extra bits, flag to indicate negative value (if in
    >low-order position) or high-order-end (if in any other position),
    >and parity.


    What a memory you have to recall the precise details of work you did
    45 odd years ago.
    --

    Roedy Green Canadian Mind Products
    The Java Glossary
    http://mindprod.com
     
    Roedy Green, Aug 12, 2008
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Replies:
    5
    Views:
    503
    Darryl L. Pierce
    Jan 30, 2006
  2. Replies:
    64
    Views:
    1,700
    Martin Gregorie
    Sep 2, 2008
  3. Joachim Durchholz

    Re: The Importance of Terminology's Quality

    Joachim Durchholz, May 8, 2008, in forum: Java
    Replies:
    1
    Views:
    329
    John W Kennedy
    May 9, 2008
  4. Replies:
    67
    Views:
    1,463
    Martin Gregorie
    Sep 2, 2008
  5. Paul
    Replies:
    63
    Views:
    1,314
Loading...

Share This Page