HDTenEightyP/NetNews huggingface dataset:
From: mps@hri.com (Mark Stockley)
Newsgroups: comp.programming
Subject: NEED INFO: Lauser (sp?) trees
Date: 16 Apr 92 20:07:32 GMT
Article-I.D.: bigbird.6296
Reply-To: mps@hri.com
Organization: Horizon Research, Inc.

I came across a brief description of a data structure called a "lauser" (sp?)
tree. Basically this structure has four pointers, "up", "down", "left" and 
"right" and can be used in graphics applications to find the nearest object
to a specified location. 

I would appreciate any information or leads on learning more of this data
structure and application.

------------------------------------------------------------------------------
Mark P. Stockley    |   INET: mps@hri.com    | But I don't like Spam!!!
Horizon Research    |  Voice: (617) 466-8300 | 
1432 Main St.,      |   		     | Is the alphabet in that order
Waltham MA 02154    |    FAX: (617) 466-8323 | or is it because of that song?
------------------------------------------------------------------------------
Newsgroups: comp.programming
From: quinn@cs.uwa.edu.au (Quinn "The Eskimo!")
Subject: Re: Names
Organization: The University of Western Australia
Date: Mon, 13 Apr 1992 05:33:00 GMT

In article <1992Apr13.021853.4539@cujo.curtin.edu.au>, peter@cujo.curtin.edu.au (Peter N Lewis) writes:
> 
> Did I get the definitions right Quinn? :-)

I think this question was directed at me (custodian of the namespace on KAOS 2).

Types
-----
 o lower case first word
 o mixed case following words
 o must contain two words (a possible draw back that we got around by adding
   an arbitrary second word (like 'record' or 'array') where nothing else
   made sense
eg indexedString, listHead

Procedures/Functions
--------------------
 o mixed case all words
eg FindTail, IsEmpty

Variables
---------
 o all words in lower case
eg i, tempstring

Constants
---------
 o all words in lower case
 o separated by underscore (_)
eg frame_size

Exceptions (ala Ada)
----------
 o all words in mixed case
 o separated by underscore (_)
eg Stack_Death, File_Not_Found, Disk_Error

Given that work on KAOS 2 has stopped I would most probably modify the notation
in the following way:

Variables
---------
 o all words in lower case
 o separated by underscore (_)
eg i, temp_string

Constants
---------
 o all words in mixed case
 o separated by underscore (_)
eg Frame_Size

Exceptions
----------
 o same as constants
 o suffix with _Error
eg Stack_Error, File_Not_Found_Error, Disk_Error

This name space has some obvious additions that one could use to flag other classes
of identifiers.  For example "_Wombat" and "_wombat".

But I think I'll go away and ftp the discussion on Hungarian notation.  I
saw an article on it a while ago and it looks very interesting.

Quinn "The Eskimo!"   <quinn@cs.uwa.edu.au>  "Real Coke, Diet .sig"
Department of Computer Science, The University of Western Australia
From: sz@Materna.DE (Stefan Zimmermann)
Newsgroups: comp.programming
Subject: Re: SCCS & make
Keywords: SCCS, make, C
Date: 15 Apr 92 09:42:13 GMT

sz@Materna.DE (Stefan Zimmermann) writes:

>Perhaps you forgot to define a depends between the c-file and the h-files?
>like this
>	expamle.c:	expamle.h elmapxe.h

Sorry, I mean o-files in each case.

Thanks Scott.

	Stefan
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.programming
Subject: Re: The new international trade agreement...
Date: 7 Apr 92 00:39:42 GMT
	<1992Apr3.051942.27151@bohra.cpg.oz.au>
	<1992Apr6.155111.28253@helios.physics.utoronto.ca>
Organization: University of Chicago CILS

In article <1992Apr6.155111.28253@helios.physics.utoronto.ca> dooley@helios.physics.utoronto.ca (Kevin Dooley) writes:
|This is a good point, however it is still possible to earn money off of
|PD software.  How?  Look at Donald Knuth and TeX.  The software is completely
|free, but the program is so big and complex that you need a manual in order
|to use it.  So he has made a lot of money selling copies of his `official'
|TeXBook.  Then, of course, others came along to sell alternative manuals
|and documentation, but most people prefer to buy the original.  I have
|always liked this way of doing things because it has the great advantage
|that, even if there is commercial software to do the same thing, people
|will in general do the free thing.  It has the great disadvantage that it
|only really works for software which is of a certain threshold complexity
|(otherwise people won't buy your manuals).  Also timing of the release of
|your manual and the release of the software is critical.  You don't want
|anybody else beating you to the punch with a better manual and you don't
|want to try to publish too soon or no publisher will take it.  Also it has
|the problem that you have to be able to write well, which is not always
|the programmer's strong suit.  Anyway, it *can* be done.

You notice that this only works because TeX is a really BAD programme
and you NEED a dozen chapters on how to hack it to make it useful! Now
tell me how someone with a sense of design elegance and social
responsability, using decent language design and modern UI technology,
can make a living writing free software?

I *really* resent people like Knuth and IBM who make a profit BY
making an inferior product. (Ok, Knuth tried harder. But still.)
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.programming,comp.lang.misc,comp.lang.ada
From: pattis@cs.washington.edu (Richard Pattis)
Subject: Reference for Simple Bug
Organization: Computer Science & Engineering, U. of Washington, Seattle
Date: Fri, 10 Apr 92 17:38:34 GMT

I recall reading something recently about a one line code patch that was not
tested, but instead put into immediate service (the phone company?) and
caused a disaster. The patch just set the value of an identifier, but the name
was mistyped (something like Rl instead of R1). I cannot remember the source,
but would like to cite it.

Can anyone tell me the particulars of this case, and supply a published
reference?

Rich

-- 
------------------------------------------------------------------------------
  Richard E. Pattis			"Programming languages are like
  Department of Computer Science	 pizzas - they come in only "too"
    and Engineering			 sizes: too big and too small."
Newsgroups: comp.programming
From: dooley@helios.physics.utoronto.ca (Kevin Dooley)
Subject: Re: The new international trade agreement...
Organization: University of Toronto Physics/Astronomy/CITA
Date: Mon, 6 Apr 1992 15:51:11 GMT

In article <1992Apr3.051942.27151@bohra.cpg.oz.au> fisherc@bohra.cpg.oz.au (Craig Fisher) writes:
>There is another problem with this. How are we supposed to earn a living
>writing software if we have to release everything into the public
>domain??

This is a good point, however it is still possible to earn money off of
PD software.  How?  Look at Donald Knuth and TeX.  The software is completely
free, but the program is so big and complex that you need a manual in order
to use it.  So he has made a lot of money selling copies of his `official'
TeXBook.  Then, of course, others came along to sell alternative manuals
and documentation, but most people prefer to buy the original.  I have
always liked this way of doing things because it has the great advantage
that, even if there is commercial software to do the same thing, people
will in general do the free thing.  It has the great disadvantage that it
only really works for software which is of a certain threshold complexity
(otherwise people won't buy your manuals).  Also timing of the release of
your manual and the release of the software is critical.  You don't want
anybody else beating you to the punch with a better manual and you don't
want to try to publish too soon or no publisher will take it.  Also it has
the problem that you have to be able to write well, which is not always
the programmer's strong suit.  Anyway, it *can* be done.
		Kevin
Newsgroups: comp.programming
From: eggert@twinsun.com (Paul Eggert)
Subject: Re: Difference between SCCS and RCS
Keywords: RCS, SCCS
Organization: Twin Sun, Inc
Date: Fri, 10 Apr 1992 20:34:48 GMT

narayan@aravali.everest.tandem.com (Pankaj Narayan) writes:

>Which of these is better, and why ?

That's almost a religious question.  You can find a brief summary of
one answer in the comp.software-eng Frequently Asked Questions posting;
basically, it's ``RCS is better, but...''.  It's fair to say that both
RCS and SCCS are showing signs of age.

You might look into CVS, which is also free and remedies some of RCS's
shortcomings; you can FTP it from prep.ai.mit.edu in pub/cvs-1.2.tar.Z.

>I get the feeling that people are moving from RCS to SCCS, but
>haven't been able to figure out why.

I don't know why you're having that feeling.  I suspect that most SCCS
shops stick with SCCS, and most RCS shops stick with RCS -- the only
real movement is caused by new shops that aren't tied into either regime.
With commercial products other than SCCS I'd even say RCS has an edge;
e.g. HP's software engineering tools use RCS format by default,
and on PCs I believe that many more folks use RCS format than SCCS format.
From: tromp@cwi.nl (John Tromp)
Newsgroups: comp.programming
Subject: Re: Permutation generation
Keywords: permutations
Date: 9 Apr 92 10:16:29 GMT

ressler@cs.cornell.edu (Gene Ressler) writes:

>Wow. This code looks too hard!
And way too long!

Here's something that has just the essentials of permutation generation:

char      *a;b,  j;t  (c)  {c
          [a]?(  t(
     ++b  ),
     --b  ,j=c)  &&(  c=j
          [a]^j
          [a-1]  )&&  (
     j--  [a]^=  c,j
          [a]^=  c,t  (j)  ,
     j++  [a]^=  c,j
          [a]^=  c):
puts      (a);}
main      (c,b)
char      **b;{
for       (;a=*
     ++b  ;)t
          (j);}

It produces all unique permutations of the argument strings,
and can easily be rewritten to work on integers.
If it still looks too hard, well, that may have something to do with
the fact that it was an entry to the Obfuscated C Code Contest:-)
I'm sure it can be rewritten in a more self-explanatory way...


-John Tromp (tromp@cwi.nl)         f() is total -- R.L. Goodstein
define s(n){;auto e,r;for(0;n;n/=b)r+=n%b*(b+1)^s(e++);return(r)}
define f(n){;for(b=2;n;b++)n=s(n)-1;return(b)} for(n=0;1;n++)f(n)
Newsgroups: comp.programming
From: aj3u@larch.cs.virginia.edu (Asim Jalis)
Subject: Names
Organization: University of Virginia, Charlottesville, VA 22903
Distribution: comp
Date: Fri, 10 Apr 1992 23:34:28 GMT

Do people have ideas on how to name entities in programs
(local/global variables, functions, types etc): some sort of
general guidelines.  I have seen some articles on the Hungarian
notation and have developed some conventions of my own also.
However, I remain unsatisfied with this and would like to get
more opinions.  Clearly, this is a very subjective issue.

Asim Jalis.
Newsgroups: comp.programming
From: dave@metapro.DIALix.oz.au (David Eddy)
Subject: Re: Engineering philosophy in programming (was: Re: Editor theory?)
Organization: MetaPro Systems, Perth, Western Australia
Date: Thu, 9 Apr 92 00:33:16 GMT

In <3477@caslon.cs.arizona.edu> dave@cs.arizona.edu (Dave Schaumann) writes:

>Certainly the theoretical investigations of programming qualify as science,
>and the construction of large artifacts requires no small amound of
>engineering.  Finally, there is a definite art to it.  Every program has a
>certain asthetic quality about it -- the format of the code, the way that
>operations fit together, the flow of the design, etc.

It has been said that every good engineer has more than a little
artist in his soul.

--
David Eddy, Metapro Systems Pty Ltd. -- dave@metapro.DIALix.oz.au
#include <std/disclaimer.h>
From: orpheus@reed.edu (P. Hawthorne)
Newsgroups: comp.programming
Subject: Re: Reinventing the wheel
Date: 10 Apr 92 13:48:51 GMT
Article-I.D.: reed.1992Apr10.134851.25240
Organization: Reed College, Portland OR

.dave@cs.arizona.edu (Dave Schaumann) writes:
.   I think that far more often than not, when you wish you could
.   return two values from a function, what you really need to do is
.   re-examine your data structures, and not redesign the language.

  schwartz@roke.cs.psu.edu (Scott Schwartz) writes:
.   You argue that returning multiple values is not as nice as returning a
.   single structure.  Do you also think that passing multiple values is
.   bad, and that one should just pass a structure?

    Maybe it's because I am used to Macintosh System param block managers
and register based traps, but it seems to me that one major advantage to
passing a structure is in passing by address, so that you can pass an
arbitrary set of arguments with a single address. It cuts down stack
overhead time and space by taking advantage of specific addressing modes.


  schwartz@roke.cs.psu.edu (Scott Schwartz) writes:
.   On the other hand, allowing functions to take multiple
.   values as parameters, but not to return them is needlessly inconsistent.

    For functions, perhaps. For acquaintences, traversals, dispatchers,
indicators, semaphores, monitors, latches, locks and caches, I'm not sure.
What if you're object wants to make a private copy of the parameter blocks
as state variables? What if a particular client wants to make changes that
do not stick, or that depend on the value of some other state variables?
    Take a look at the trap dispatching of the 68k series and the Actor
language descriptions sometime, specifically about behaviours.

    I think you're guaranteed to get off on the whole actor premiss. If you
don't find it to be an elegant form of programming expression, you get
your money back, an official Functional Language fanatic ID card, and all
of this fun can be had at little or no physical risk.

    Theus (orpheus@reed.edu)
Newsgroups: comp.programming
From: mwbg9715@uxa.cso.uiuc.edu (Mark Wayne Blunier)
Subject: Re: need a HINT on a C code parsing name-strings
Organization: University of Illinois at Urbana
Date: Mon, 6 Apr 1992 14:35:33 GMT

nickh@CS.CMU.EDU (Nick Haines) writes:

>In article <92096.184215DECBC@CUNYVM.BITNET> DECBC@CUNYVM.BITNET writes:

>   I am writing a C code to parse an input string formatted in
>   'lastname,firstname,middle-initial' of each field is varying
>   length and total length is 30 bytes, into three separate
>   strings, 'lastname,' 'firstname,' and 'middle-initial.'

>30 bytes??? _30_ bytes? And _a_ middle initial??? This isn't a real
>application, is it?

>Nicholas David Anthony Haines, who's sick and tired of official
>American forms INSISTING that everyone has ONE middle initial and a
>ZIP code.

ZIP code, most forms ask for them but give enough space to write
3 of the digits, and as of yet I've never run into a form that
has enough space to add the 'plus four' digits!

Mark

Newsgroups: comp.programming
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Reinventing the wheel (was Re: Engineering philosophy in programming)
Organization: University of Chicago CILS
	<STEPHEN.92Apr1183604@estragon.uchicago.edu>
	<1992Apr02.223654.4016@ima.isc.com>
Date: Sun, 5 Apr 1992 08:53:02 GMT

In article <1992Apr02.223654.4016@ima.isc.com> suitti@ima.isc.com (Stephen Uitti) writes:
|
|There isn't time to reuse software.  We don't even have time to
|look at the old code.  There's no time to debug the old code.
|There's really only time to rewrite it from scratch.  If the
|design hasn't changed, the rewrite goes fast.  Sadly, the
|implementation language of choice is also what is used for
|prototyping.  The prototypes are then sent to the customers.

There certainly isn't time to READ old software, and there certainly
isn't time to CHANGE it. That doesn't mean we can't re-use it. Every
time I use a compiler, I am reusing assembly-language expertise that
someone has canned. Every time I send mail from this editor I am
reusing code. The "open up the source file and edit it" model is the
wrong model for software reuse because it slows you down. Sure. No
argument. In fact, if you are rewriting something, if you have to
tweak the source, how is this "reuse" at all? If I may be blunt,
that's not reuse, that's hacking.

The question is, why did you assume that this was what I meant?
Perhaps because you aren't familiar with tools that can do any better
and that are other than monolithic "applications". But dropping small
extensions into emacs is (in SOME cases!) quite practical. Linking dbm
into your C programme works just fine. It is POSSIBLE to make use of
previous work without doing surgery on it.

Now, how can we make that the usual case and save ourselves all some
time?

The answer has to be be better interface technology, and that needs to
go into the languages we use and the filing systems that we have for
already-written modules. And that technology isn't here yet in force,
and that's a problem, perhaps THE problem. At this point I should say
"join Project Mythos, help make the world safe and happy for
computers" or something, but we aren't at that stage yet....
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.programming
Subject: Re: Multi-tasking kernel
Date: 12 Apr 92 10:20:18 GMT
	<STEPHEN.92Apr11210424@estragon.uchicago.edu>
	<rxvjyd-.jsteele@netcom.com>
Organization: University of Chicago CILS

In article <rxvjyd-.jsteele@netcom.com> jsteele@netcom.com (John Steele) writes:
|In <STEPHEN.92Apr11210424@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
|
|>In article <1992Apr11.122628.2131@nuscc.nus.sg> eletanjm@nuscc.nus.sg (Tan Jin Meng @ NUS) writes:
|>|Why don't you write one yourself? You can in fact write a simple and
|>|completely portable non preemptive multitasking kernel by just using the
|>|standard C routines setjmp() and longjmp().
|
|>How? Where are the stacks stored? Suddenly you have more than one....
|
|Although this probably belongs in comp.lang.c, a good reference to your
|question can be found in _Born to Code in C_ by Herbert Schildt.  Published
|by Osborne McGraw-Hill, ISBN 0-07-881468-5.
|
|He covers this well in Chapter 4 - A Multitasking Kernal for DOS, both in 
|concept and code.
|
|I mention this here only for the fact that this in fact *might not be* C
|specific, and the concepts are solid and useable in any language that can
|support the longjmp/setjmp functionality (flamers, see below :)

I think you missed my point. You _cannot_ write a multitasking kernel
to run in even vaguely portable C, not unless there are some
interesting new library routines since I last checked. Of course there
are hacks that might work, but setjmp/longjmp alone doesn't suffice,
in any language except a normal-order functional language where it
turns out to be isomorphic with a continuation (?!). So it couldn't
possibly be a comp.lang.c issue, and the multi-stack problem bites in
so many contexts that this MIGHT be the place for it....
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
From: mjd@saul.cis.upenn.edu (Not James E. Pommersheim in disguise)
Newsgroups: comp.programming
Subject: Re: functions & return values (was Re: Reinventing the wheel)
Date: 14 Apr 92 17:53:47 GMT
Followup-To: comp.misc
Organization: Eaters of Wisdom
In-reply-to: mcmahan@cs.unca.edu's message of 14 Apr 92 15:47:25 GMT

In article <1992Apr14.154725.9397@cs.unca.edu> mcmahan@cs.unca.edu (Scott McMahan -- Genesis mailing list owner) writes:
>   Functions that return more than one value!?
>   That's terrible -- why would anyone *want* to do this? If it needs to
>   return more than one value, it would be a lot easier to implement 
>   and understand it if you just passed them in as parameters.

    I don't agree; I think that's just because you're used to C, which
does things a certain way.  The only difference between a function which
returns multiple values and function which returns a structure or an
array is a matter of language semantics, and surely returning a
structure (which C can do) is reasonable?

    Nearly all UNIX system calls, for example, have at least two return
values, one a general success-or-failure code, and one an error number
describing the cause of failure, if any.  The failure code is placed
into a global variable with a special name (`errno').  This is a pretty
nasty hack.  UNIX stat(2) returns three kinds of result: An integer
return code, which it returns on the stack, an integer failure code,
which it places into the global variable `errno' on failure, and some
inode status information, which it places into a fixed-size buffer
pointed at by one of its arguments.  Wouldn't it be conceptually simpler
if UNIX `stat' returned an (int, int, struct stat) triple on the stack
instead of leaving the three parts of its results in three completely
different places?

    To take a simpler example, imagine a function whose parameters are
the coeffeicients of a quadratic equation, and which returns the two
roots.  Sure, if you were using C, you could define a special struct
root_pair that has members for two roots, and return that, but that
obscures what you're really doing.  

    Whenever I have to pass in a pointer to a fixed-size buffer where I
want my results stored, I think of Fortran.  Common Lisp has functions
with multiple return values and it seems to do just fine.
--

           Millions for defense, but not one cent for tribute.
Mark-Jason Dominus 	  			    mjd@central.cis.upenn.edu
From: markh@csd4.csd.uwm.edu (Mark William Hopkins)
Newsgroups: comp.programming
Subject: Re: How To Calculate Logarithm?
Date: 12 Apr 92 09:44:39 GMT
Article-I.D.: uwm.1992Apr12.094439.2700
Distribution: comp
Organization: Computing Services Division, University of Wisconsin - Milwaukee

In article <jpenne.702954846@ee.ualberta.ca> jpenne@ee.ualberta.ca (Jerry Penner) writes:
>markh@csd4.csd.uwm.edu (Mark William Hopkins) writes:
>>If you can find a good way to do square roots, especially of numbers near
>>1 (where sqrt(1 + d) ~~ 1 + d/2), then the following will work for large
>>enough N:
>
>>Y = ln(X):
>>----------
>>for (Y = X, I = 0; I < N; I++) Y = sqrt(Y);
>>Y--; Y <<= N;
>
>Actually, the easiest way to compute logarithms is to use CORDIC
>hyperbolic algorithms.  They were described in Dr. Dobbs Journal in
>1989 or 1990 (can't remember which month).  The article supplied
>source code in C to perform CORDIC manipulations on 32-bit fixed point
>numbers so that all trigonometric and hyperbolic functions (including
>LOG) could be done.  All these algorithms are very fast since they
>only do adds, subtracts, shifts and comparisons.

October 1990.  Source listings for the magazine are publically archived under
SIMTEL's msdos/ddjmag directory.  The magazine listing is under the name
ddj9010.zip, and when this file is unpacked (using unzip), the file jarvis.asc
will contain the source.  The file descrip.txt will summarize the contents of
all the files packaged under that zip file.

A SIMTEL mirror is maintained by anonymous ftp at wuarchive.wustl.edu.  Under
mirrors2 is the msdos directory, so the full path name of the magazine
directory there is: mirrors2/msdos/ddjmag.
Newsgroups: comp.programming