HDTenEightyP/NetNews huggingface dataset:
From: cosc161m@menudo.uh.edu (92s07275)
Subject: URGENT: OS/multimedia papers needed as soon as possible
Organization: University of Houston
Date: Fri, 10 Apr 1992 05:53:18 GMT

        I am writing a survey paper on "multi-structured I/O file systems that
use various techniques to provide higher data transfer rates for multimedia
applications on object-oriented distributed computing systems."  I would
appreciate it very much if anybody knows of any ftp sites for OS/multimedia
papers.  Also, if you have a copy of any of the papers (postscript format)
mentioned below or know how to contact the authors of the papers or have other
papers relating to OS/multimedia, could you please email the papers or any
information on how to obtain them or other papers to me as soon as possible.
My email address is:   cosc161m@menudo.uh.edu


I already have the three papers at the "icsi-ftp.Berkeley.EDU" site in the
directory "pub/dash".
********

        In particular, I am looking for the following papers:



"Designing file systems for digital audio and video"

Authors: P. Venkat Rangan & Harrick M. Vin
DEPTCSE., Univ. of California, San Diego
Proceedings of the 13th Symposium on Operating System Principles
ACM. SIGOPS 13 Oct. 1991



"Support for Continuous Media in the DASH systems"

Authors: David P. Anderson, Shin-Yuan Tzou & Robert Wahbe
Proc. 10th International Conference on Distributed Computing Systems
Paris, May 28-June 1, 1990.
IEEE



"Distributed processing of multimedia information"

Authors: E. Moeller, A. Schller & G. Shunmann
Proc. 10th International Conference on Distributed Computing Systems
Paris, May 28-June 1, 1990.
IEEE.

***************

      I am also trying to find any papers from the: 
Proceedings of the International Conference on Multimedia Information Systems,
Singapore, Jan. 1991.


"A Variable Rate Strategy for Retrieving Audio Data From Secondary Storage"

Authors: A. Park & P. English
Proceedings of the International Conference on Multimedia Information Systems,
Singapore, Jan. 1991, 135-146.



"Abstractions for Continuous Media in a Network Window System"

Authors: D.P. Anderson, R. Govindan and G. Homsy
Proceedings of the International Conference on Multimedia Information Systems,
Singapore, Jan. 1991.


*************
        And finally,


"A Testbed For Managing Digital Video and Audio Storage"

Authors: P.V. Rangan, W.A. Burkard, R.W. Bowdidge, H.M. Vin, H.W. Lindwall
         K. Chan, I.A. Aaberg, L.M Yamamoto & I.G. Harris
Proceedings of the 1991 Summer USENIX Conference, Nashville, TN, June 10-14,
1991, 199-208.



"Principles of Delay Sensitive Multi-media Data Storage and Retrieval"

Authors: J. Gemmell & S. Christodoulakis
ACM TOIS (to appear), 1991.

****************************************************************************
Rahul Aggarwal, Graduate Student at the University of Houston.

"Report Due at the end of this month, so PLEASE email replies soon"

                 !!!Resources at library are next to nothing!!!
****************************************************************************

Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr9233337@socrates.umd.edu>
	<1992Apr10.091945.25904@newshost.lanl.gov>
Date: Sat, 11 Apr 1992 04:32:51 GMT

Jim Giles:
   Yes, this is what I want.  Can you give an example of how to do it
   that's actually statically checked?

Not until I (or someone else) gets a compiler working.  Presently I'm
talking pretty much in theoretical terms.

   How do you guard against reassignments?  Note, the `colon'
   definitions you described earlier prevent the identifier from being
   reassigned at all.  What I want is to allow the _value_ to be
   assigned without allowing the type to ever be alterred.

I need to think about this one a bit more.  For example, how would you
deal with the case where the type of an object is "an active element
of database blahblah"?

From my experience, the significant problem area in large programs is
race conditions.  If there's no race condition, there's no need to do
the reassignment in the first place.

And, I don't know about you, but to me it seems kind of silly to
introduce a "safety mechanism" that entirely ignores the big picture.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: Fortran90 and Arrays
Organization: Xenix Support, FICC
Date: Mon, 13 Apr 1992 17:51:54 GMT

In article <STEPHEN.92Apr11201347@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
> In article <id.6DTO.VWK@ferranti.com> peter@ferranti.com (Peter da Silva) writes:
> |	   The word `type' refers to the set of operations that may
> |	   be performed on a collection of data.

> This is still a little buggy. Consider the (constructed :-) example of
> a language that has two mappings from the same _abstract_ type to the
> same storage format - say 1-s and 2-s complement integers (or an int
> and an unsigned both being used to hold numbers between 1 and 100, a
> very common case in C).

> Now the same "operations", like +, may be available for both, even
> with the same meanings.

If the two objects have the same operations with the same meanings they
have the same type.

If the two objects have the same operations with the same meanings over
some range of values, and different meanings over other ranges of values,
then you can't say they have the same operations nor that they are the
same type.

In C, the type is bound to the identifier, so you can set up an alias
for a collection of data that treats it as a different type. But the
type can still be defined as the set of operations you can perform on
that data. This is referred to in C as "type punning" and is considered
as bad thing.

In Fortran, type punning is not possible in legal programs, but few if
any compilers prevent you from using (for example) implicit aliasing of
function arguments to cause type punning.

In languages where the type is bound to the data the whole concept is
meaningless. This has advantages and disadvantages. It costs some in
performance and you can't take advantage of the tools the language
provides to prevent type punning and enforce design rules, but it also
makes it easier to trace when you slip a design rule violation past
the compiler.

Some object oriented languages allow you to provide explicit assertions
about design rules that provide the same sort of protection, and also
help optimisation.
-- 
/F{findfont exch scalefont setfont}def /S{moveto show}def /T{/Times-Roman F}def
8 T(Ferranti International Controls Corporation)24 28 S(+1 713 274 5180)24 12 S
(Sugar Land, TX  77487-5012)24 20 S 12 /Courier F(`-_-')320 32 S( 'U` )320 16 S
12 T(Peter da Silva)24 36 S 16 T(Have you hugged your wolf today?)358 24 S
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Fortran90 and Arrays
Organization: Traveller
	<ROCKWELL.92Apr8001532@socrates.umd.edu>
	<1992Apr8.180420.9294@newshost.lanl.gov>
	<ROCKWELL.92Apr8164502@socrates.umd.edu>
	<STEPHEN.92Apr9214055@estragon.uchicago.edu>
	<ROCKWELL.92Apr10214059@socrates.umd.edu
	<STEPHEN.92Apr11045523@estragon.uchicago.edu>
	<ROCKWELL.92Apr12194228@socrates.umd.edu>
	<STEPHEN.92Apr13001457@estragon.uchicago.edu>
Date: Tue, 14 Apr 1992 02:53:24 GMT

Stephen P Spackman:
   I'm NOT suggesting having no fixed syntax (there are very GOOD
   reasons not to want that, including implementability and
   readability). Just that if I want to write a function called
           "if ... represents ... then ... end"
   the fact that there is one called
           "if ... then ... else ... end"
   in the language core shouldn't stop me. Surely you see the
   difference?

What is it, here, which is fixed?

   An added benefit of this approach is that, given a syntax that is
   INDEPENDENT of the actual identifiers, you don't even have to know
   the full set of CORE language facilities to start reading code -
   the opposite situation from PL/1 !

I've never programmed in PL/1.  But I'm not sure what you're saying.
For instance, in your above example, is the syntax of the word
'represents' independent of the identifier 'represents'?  If so, how
does this make it easier to read the code?  If not, could you give an
example of what you're saying?

   You're saying "if your types are other than characters and floats,
   go elsewhere; this language is not for you". How silly!

I'm saying nothing of the sort.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<STEPHEN.92Apr11043808@estragon.uchicago.edu>
	<1992Apr13.194947.17250@newshost.lanl.gov>
	<STEPHEN.92Apr14171919@estragon.uchicago.edu>
	<ROCKWELL.92Apr15002308@socrates.umd.edu>
	<STEPHEN.92Apr15014148@estragon
	<ROCKWELL.92Apr15094037@socrates.umd.edu>
	<STEPHEN.92Apr15094139@estragon.uchicago.edu>
Date: Thu, 16 Apr 1992 02:43:05 GMT

Stephen P Spackman:
   Obviously, I meant 32767 (that or I meant max). The point is that
   the maximum for the representation and the maximum for the type are
   different notions, and that in any case (no matter what IEEE may
   tell you) "infinity" is not an integer and it's not a float. It's a
   domain extension, and you shouldn't have to rely on them in order
   to code up simple notions like min and max.

So use the maximum for the type.

If you wish to exclude certain representations, there will still be a
maximum element among the representations you allow.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: sullivan@teal.csn.org (Steve Sullivan)
Subject: "M" language
Organization: Colorado SuperNet, Inc.
Distribution: na
Date: Sun, 12 Apr 1992 00:58:50 GMT


Where can I find info about a language called "M"?
I've checked Bill Kinnersley's list, and found nothing.

Many thanks ...

Steve Sullivan
sullivan@csn.org

Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Xenix Support, FICC
Date: Tue, 7 Apr 1992 15:01:59 GMT

In article <STEPHEN.92Apr6203432@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
> I think the redefinability of globals is a practical necessity when
> writing languages with read-eval-print style interactivity that lack
> first-class namespaces. Corrections welcome.

You've fallen into Jim's trap. Since identifiers aren't typed in J, there is
no such thing as a redefinition of a global. There is just assignment of a
new value with a possible new type.
-- 
/F { dup /Courier findfont exch scalefont setfont } def /S { show } def /L { 12
mul 36 add 36 exch moveto } def 24 F 2 L (Have you hugged your wolf today?) S
12 F 1 L (Peter da Silva, Ferranti International Controls Corporation) S
0 L (Sugar Land, TX  77487-5012;  +1 713 274 5180) S 
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<STEPHEN.92Apr11043808@estragon.uchicago.edu>
	<1992Apr13.194947.17250@newshost.lanl.gov>
	<STEPHEN.92Apr14171919@estragon.uchicago.edu>
Date: Wed, 15 Apr 1992 05:23:08 GMT

Jim Giles:
   ||> [... reduction on empty array ...]
   ||> Nono, you missed the point. Some operations (like "+") make
   ||> SENSE for empty arrays, and there you supply the appropriate
   ||> value (0). Others (like "min") only make sense on an empty
   ||> array in an extended domain (for present purposes: don't make
   ||> sense) and so you REQUIRE at least one element, ...

I've been hoping some one else would bring this up, but:  what kind of
implementation is this, where you've got a numeric type but no maximum
element of that type?  I wasn't aware that could happen with a finite
set of numbers -- at least, not for the case where those numbers are
members of the set of real numbers.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Mar31185022@socrates.umd.edu>
	<1992Apr3.172844.6152@newshost.lanl.gov>
	<ROCKWELL.92Apr4080945@socrates.umd.edu>
	<STEPHEN.92Apr4215253@estragon.uchicago.edu> <R
	<STEPHEN.92Apr5185547@estragon.uchicago.edu>
Date: Tue, 7 Apr 1992 05:54:32 GMT

Stephen P Spackman:
   ... you have just substituted the words "programme text" and
   "routine" for "scope".  What do these things look like? What is the
   actual domain of the definition?

I'm not sure I understand the questions.  J hasn't been around long
enough for there to be a particular definition style.  For example, a
style which uses a separate file for each function definition would
look quite different than a style which uses scripts, with literal
text quoted in-line.  The first would look somewhat like a c program
with various modules and a makefile, the second would look somewhat
like a shar archive (or, perhaps, a bit cleaner).  And if the user is
driving the definition process from emacs, they'll just look like
text.  And, there are other definition styles.

If by "domain of the definition" you mean the domain of the thing
which is defined, well, that depends on the definition.  Domain, in
this sense, is more or less independent of the mechanisms used for
definition. 

   Oh, I realise there's still a missing piece of info: if you use =:
   in a scope that has introduced a new name textually identical to
   that on the left of the assignment, what gets updated? The local,
   the global, or both? If you are really LEXICALLY scoped, it ought
   to be the local, but what if that defining scope has already
   exited? Is that handled correctly?

Well, the global definition is updated.  If you want the local
definition to be updated you can use '=.'  If there is some local
definition shadowing the global definition, you can always create a
new context where the local definition does not exist.

I might define an example of this as follows:

example =. (here_is '.') : ''
.  test=. 3
.  test=: 4
. 'local  ' label test
. 'global ' label 'test':'' 0
.                               NB. return an empty result

Then, if I used
   example 0
The routine would display:
local  3
global 4

And, on exit, 'test' would have the value 4

By the way, I'm presuming that the definitions of 'here_is' and
'label' are not pertinent to this discussion.  Also, 'NB.' introduces
a comment.


-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Newsgroups: comp.lang.misc
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Date: 11 Apr 92 10:05:26 GMT
	<STEPHEN.92Apr9220641@estragon.uchicago.edu>
	<1992Apr10.093445.26931@newshost.lanl.gov>
	<STEPHEN.92Apr10055926@estragon.uchicago.edu>
	<ROCKWELL.92Apr10223545@socrates.umd.edu>
Organization: University of Chicago CILS

In article <ROCKWELL.92Apr10223545@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Stephen P Spackman:
|   What, you think I'm defending J, just because I don't like FORTRAN?
|   They're practically dialects of each other anyway, with their
|   array-o-centrism, type-o-phobia, line-oriented syntax,
|   proliferation of system-reserved mechanisms, encouragement of
|   semantically inexplicable floating-point arithmetic and general
|   inattention to actually solving the problem....
|
|I was going to let all that bs slide until you got to "general
|inattention to actually solving the problem"....  What do you mean
|general inattention to actually solving the problem?
|
|Where in the world do you think J (or APL) get their reputation for
|solving arbitrary problems in one line of code if they don't pay any
|attention to problem solving?  The big reason I prefer J over a
|language like Fortran is that I can develop code in J (or APL) a lot
|faster than in a less structured language.

What, you think I'm defending FORTRAN, just because I don't like J?

I code in C and I hate it. But C (now) has almost enough type
structure that I can write code that runs as soon as it compiles clean
- presumably because I'm reasonably good at what I do. A tighter type
system would be better still - I spend a lot of extra time typing in C
to try and explain to it that I really WANT checks performed, and I'd
like to lose that by having more of them performed implicitly.

But what you pay for you also can get to use: one of the really nice
things about writing explicit type declarations is - or ought to be -
that the information about the INTENT of the programmer is visible to
the compiler. For instance, all it would take is a type declaration
for "a , b" to catenate lists - but take the union of sets, the
bagunion of bags, and the cons of trees. More generality, more
notational density (in the "throw out the irrelevancy" sense), more of
the underlying APL philosophy - accomplished by having type
declarations, static typing, and abandoning the magic status of
arrays. Heresy? Maybe. But think about it anyway.

J is just too notationally FLABBY to deal with anything outside of its
narrow floats-and-arrays outlook - which is why I say it is cut from
the same cloth as FORTRAN.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr5115242@socrates.umd.edu>
	<1992Apr6.193950.5862@newshost.lanl.gov>
	<ROCKWELL.92Apr6233655@socrates.umd.edu>
	<STEPHEN.92Apr6232606@estragon.uchicago.edu>
Date: Tue, 7 Apr 1992 14:25:58 GMT

Stephen P Spackman:
   I'd been charitably assuming that you'd fixed this nighmarish
   notation. Of COURSE you aren't showing us any examples of actual
   function definitions - much less nested ones - they're totally
   illegible!

I showed examples.  I don't think they were illegible.

   Worse than that, using strings for function bodies is going to
   wreak merry hell with your scoping rules, isn't it? Or does : get
   dynamic access to the static context, meaning that functions in
   general need to know the actual source names of all their local
   identifiers?

I'm not sure what you're asking here.

But, while I'm thinking of it: I oversimplified by calling them
strings.  Lists of strings, and character matrices may also be used.

I should note that, in general, most programming languages use some
form of text to represent programs in that language.  If you're trying
to make a generalization about languages which use a textual
representation for programs, keep this in mind.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Xref: sparky comp.lang.misc:1724 comp.lang.functional:488 comp.object:1764
From: gudeman@cs.arizona.edu (David Gudeman)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: Re: Types as first-class values?
Date: 15 Apr 92 20:33:35 GMT
Followup-To: comp.lang.misc
Organization: U of Arizona CS Dept, Tucson

In article  <STEPHEN.92Apr14174618@estragon.uchicago.edu> Stephen P Spackman writes:
]I'm a little confused by the notion of type you are looking for: the
]fact that you specify that you want a membership TEST suggests that
]you're thinking of a set theory rather than a type theory at all -
]types are properties of the expressions, not the values, *even when
]the types are values themselves*.

That is just another way of saying that types are static properties of
programs, which is far from a universal view.  It also happens to be
the case that sets make an excelent implementation of types.

]Languages that provide first-class sets? I can't think of any; in
]fact, I'm not sure how you could do that. Unless you restricted
]yourself to small finite sets a la SETL, most of your primitives would
]be too expensive (the advantage of the type-theoretic approach is that
]while compilation may fail to terminate unexpectedly, a successfully
]compiled programme won't misbehave in that way).

I can't imagine what you are trying to say here.  A language with
finite first-class sets has first-class sets.  And there are many that
do have them.  Furthermore, it is a simple matter to represent and
compute with infinite sets.  For example the complement of a finite
set X can be easily represented by a data structure that enumerates X.
Set operations on infinite sets can keep representations of the
argument sets, they don't have to do infinite operations.  First-class
predicates can be used to define sets by extension.

I could implement all this in a few hundred lines of lisp, but no
doubt it has already been done.  Of course if you allow full
generality of these operations, you have some expressions that are not
computable, but that is no different from any other sort of
non-terminating computation.
-- 
					David Gudeman
gudeman@cs.arizona.edu
noao!arizona!gudeman
Newsgroups: comp.lang.misc
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr5115242@socrates.umd.edu>
	<1992Apr6.193950.5862@newshost.lanl.gov>
Date: Tue, 7 Apr 1992 04:36:55 GMT

Raul Deluth Miller-Rockwell:
>  |> [...]
>  |> The lifetime of a definition created by name=.expr is similar to a
>  |> '=:' definition, but the definition is additionally tied to the
>  |> explicitly defined routine in which it appears. [...]
>  |>
>  |> [...]
>  |> Have I left any situation uncovered?

Jim Giles:
>  Yes.  You have yet to present _how_ explicitly defined routines are
>  delimited and named.

Explicitly defined routines are declared with either
>  string1 : string2
or
>  string  : n

In the first form, string1 is the text used for the monadic case of
the definition, and string2 is the text used for the dyadic case.  If
the string is empty, that part of the definition is also empty -- in
other words, it has no domain, and can not be applied to any data.

In the second form, n is a small cardinal number, and the definition
has special properties which I've not addressed.

Naming uses either =. or =:

For example, 
          invalid=.  '':''

defines an empty function with no domain.  This might be useful for
informing a compiler that some particular circumstance should not
occur.

>  You have yet to present whether such definitions may be nested.

Yes, of course.  I've not needed to use this feature, but then I
hardly ever use explicit definitions.

>  You have yet to explain why you think the ability to redefine
>  globals is desirable (I don't think it is).

Well, I rarely use redefinition of any sort.  However, such globals
are useful when building caching mechanisms, in debugging tools, and
when I'm doing exploratory work and trying to get a feel for the
problem domain.

And, in anticipation of what I think your next objection will be, yes,
if the programmer defines functions on the fly (where the compiler can
not anticipate what the definition will be), there will be a
performance cost.  This is analogous to invoking a compiler under
program control.

Also, in case you've followed my discussion of the rank of verbs, ':'
is a conjunction (a functional form) and thus can not have a rank in
and of itself.  However, if it creates a verb, then that verb may be
given a rank.

And yes, I'll agree that this is different from the way Fortran does
things.  I'll also agree that anything you can do with ':' you can, in
principle, achieve with Fortran.  But the Fortran implementation will
be considerably more complex, and many of the details will be specific
to the operating system under which Fortran is running.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>