🚀 go-pugleaf

In article <7032@saturn.ucsc.edu>, koreth@ssyx.ucsc.edu (Steven Grimm) writes:
> A colleague and I are preparing a paper on a new sorting algorithm we've
> come up with.  It only works on certain kinds of keys, though, so I'm
> interested in getting a general feel for how useful it will be.  So, my
> question is this: In your applications, what datatypes do you commonly
> use as sort keys?  Character (text) strings, integers, floating point
> numbers, or what?  Please respond by E-mail, if possible; I will summarize
> to the net if there's interest.  (Sorry, I don't want to give out any
> details about our algorithm before it's published; just look what premature
> release did for Pons and Fleischmann! :)
> 
> Thanks for any information you can provide.
> 
> ---
> Steven Grimm				koreth@ssyx.ucsc.edu
> Division of Social Sciences		uunet!ucbvax!ucscc!ssyx!koreth
> University of California, Santa Cruz	"Pithy quotes are for losers."


Allow the user to hand the sorting tools the comparison function to use on 
the keys.  That way you can sort anything.  C++ (a truely bitchin' language)
is built for this sort of thing.  You can of course do this in C and probably
many other languages.

I posted this to the net because I wanted to say that before I started using 
C++ the idea of reusing my own code (let alone anyone else's) turned my 
stomach.

To W. T. Wolfe and T. Dunning.

What exactly would an "intelligent software librarian" do?  I have seen 
software development environments that do "HyperCard" type things to link 
libraries to manuals to the code that refrences those libraries, etc.  The 
stuff was very neat, but only if the developers explicitly maintained all the 
interconnections.

How is the ADA COMMAND ENVIRONMENT better?  (The fact that it was comissioned
by the U.S. Government has me very skeptical about its usefulness.)

"... the most dramatic productivity gains in reuse will be realized through 
the development of libraries of components for specific domains, and 
structured according to explicit _domain_models_.  Such models can be realized
as detailed taxonomies of the objects and operations which are pertinent to 
the application domain to be served by the repository. ..."

It sounds like you've got to solve your software problem to solve your 
software problem.

thant@sgi.com "disclaimer"

In article <32269@sgi.SGI.COM> thant@horus.SGI.COM (Thant Tessman) writes:
>
>Allow the user to hand the sorting tools the comparison function to use on 
>the keys.  That way you can sort anything.  C++ (a truely bitchin' language)
>is built for this sort of thing.  You can of course do this in C and probably
>many other languages.

Yep, this is a great way to re-use a sorting "kernel" which implements
the order of comparisons, etc.  But I am betting that, since the type
of keys are significant, that this new technique won't lend itself to
such an implementation.  In fact, were I a betting man, I would say
it has something to do with text strings and organizing them in some
complex cousin of the tree family.  There are some text-sorting techniques
currently in use that do this, though names escape me.  But, I guess
we'll just have to wait for publication to be sure.

Wkat C++ are you using?  How do you feel it stacks up vs. Ada for
building "components"?

In article <5674@microsoft.UUCP>, paulc@microsoft.UUCP (Paul Canniff 2/1011) writes:
> 
> Wkat C++ are you using?  How do you feel it stacks up vs. Ada for
> building "components"?

I don't know Ada.  I don't even know what C++ I'm using except that it's the
one that we (Silicon Graphics) is using internally.  It's not officially
supported yet, but they are giving it to people with an AT&T C++ liscense.

My big hangup with C++ has to do with taking the address of member function.
The 'proper' way requires that you know the type of class the member function
belongs to.  But the reason I wanted to use function pointers was so I could
store a function without knowing anything about it.

The way to cheat is to cast the member function to a pointer to a function
that takes a void* as its argument.  When you call the function you pass it
the address of the object.  The compiler complains, but it does work.  The
code isn't as type secure, and according to Bjarne the trick isn't guaranteed
to work.

The way I should solve my problem is to use a base class and overload a
function.  This is only practical in general if there is only one function the
derived class wants to overload, because otherwise everything will have to
agree on which functions to call when.

I hear Objective-C deals with these problems by passing messages to class
objects, so it doesn't matter what the object's class is as long as it knows
how to do what you ask (like 'draw').  Does this make for slower code?

I also hear Ob-C has a problem dealing with typing what gets passed back.

I am very interested in how well software can be "componentized" with
different languages.  However, all I know is C++.  Discussion?

thant@sgi.com "I'm off to by a book on smalltalk"