HDTenEightyP/NetNews huggingface dataset:
From: sudhir@pyramid.unr.edu (Sudhir Srikantian)
Newsgroups: comp.lang.misc
Subject: How to append a file in TurboBasic....
Date: 10 Apr 92 00:34:24 GMT
Organization: University of Nevada, Reno  Department of Computer Science


	I what to know how we can append data to a file
in TurboBasic. I have problem in it and i do not find any command
to use it. At present i am reading the existing file and rewriting it.

If anyone as used appending data to a existing files in TurboBasic
please send me the idea how to use it.

thank you

sudhir srikantiah
pyramid@cs.unr.edu

_______________________________________________________________________________
---- 			---~~~~          ~~~~~---
            ~~~~                 O       __O
                               -\<,      \<,
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
From: chisnall@cosc.canterbury.ac.nz (The Technicolour Throw-up)
Date: 14 Apr 92 00:40:35 +1200
Reply-To: chisnall@cosc.canterbury.ac.nz
Distribution: world
Organization: Computer Science,University of Canterbury,New Zealand

From article <15195@optima.cs.arizona.edu>, by gudeman@cs.arizona.edu (David Gudeman):
> as a "static property of an identifier".  The word "type" has several
> completely different definitions, but none that I know of refer to
> static properties in general.  Furthermore, it is only in low-level
> languages that type is an attribute of identifiers at all.  In
> high-level languages type is an attribute of a value.

Type is an attribute of value in dynamically typed languages and is an
attribute of identifiers in statically typed languages.  It has nothing to
do with the level of the language.  There are plenty of high-level languages
that use static typing (e.g. Miranda, haskell).

--
Just my two rubber ningis worth.
Name: Michael Chisnall          email: chisnall@cosc.canterbury.ac.nz
I'm not a .signature virus and nor do I play one on tv.
Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Xenix Support, FICC
Date: Mon, 13 Apr 1992 17:20:18 GMT

In article <1992Apr8.170023.1191@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
> That's _NOT_ what the supporters of J are claiming.  They are saying that
> every occurrence of an assignment introduces a new scope and that the 
> assignment was a _definition_ of the variable.

That's what our friend at UMD is saying. I don't think he understands scope
at all, and he's just muddying the waters with this sort of comment. Just
as you are when you start mixing up types and names.

> Whatever you call it, an identified may refer to something of different
> type in different parts of the program - something which I consider to
> be undesirable.

It may indeed be undesirable, but you haven't demonstrated that. How about
directing your energies that way?
-- 
/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: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: University of Chicago CILS
	<ks8boqINN8ht@network.ucsd.edu>
	<ROCKWELL.92Apr5115242@socrates.umd.edu>
	<1992Apr6.193950.5862@newshost.lanl.gov>
	<ROCKWELL.92Apr6233655@socrates.umd.edu>
Date: Tue, 7 Apr 1992 04:25:59 GMT

In article <ROCKWELL.92Apr6233655@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Explicitly defined routines are declared with either
|>  string1 : string2
|or
|>  string  : n

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!

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?
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.lang.misc
From: spot@CS.CMU.EDU (Scott Draves)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Date: Thu, 16 Apr 92 17:57:51 GMT
Organization: School of Computer Science, Carnegie Mellon University
	<STEPHEN.92Apr16042133@estragon.uchicago.edu>
Originator: spot@FORTRAN.FOX.CS.CMU.EDU

>>>>> On 16 Apr 92 09:21:25 GMT, stephen@estragon.uchicago.edu (Stephen P Spackman) said:
>>>>> In article <1992Apr15.201453.10255@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:


Stephen> A language should not be restricted to a particular problem
Stephen> domain or domains. A good language is _necessarily_ a general
Stephen> purpose language.

Jim> Now we _really_ disagree.  I think that the `one size fits all'
Jim> language is impossible with the present technology and probably
Jim> always will be.  High-level languages _must_ decide on a target
Jim> user group and design for that problem domain or they will not be
Jim> high-level.

Stephen> This position is (pardon in advance) both defeatist and
Stephen> absurd! If we take this view we will end up in a world in
Stephen> which it is *not possible* to write a good, clear programme
Stephen> that involves text processing and floating point arithmetic,
Stephen> or....

i agree with jim.  a language that is very good at doing things in one
domain is necessarily not so good at other domains (eg, regexps are a
specialized language for string searching, they are good for just
about nothing else).  there are languages that are only somewhat
specialized towards a particular domain, and they are somewhat
applicable to other domains (eg snobol).  and there are languages that
are pretty much neutral wrt domain (eg lisp).

why is this true?  it seems that a language is good at a domain if it
does a lot of stuff from that domain automatically.  basically, you
want domain specific stuff baked in.  you might think this is bad, and
that such things should be provided with libraries, but this is a very
weak form of support.  could you do TeX with a library?  no.

is this defeatist?  no.  you just need a good way to create new
languages, and still have them communicate.
-- 
			conform
scott draves		deform
spot@cs.cmu.edu		explode
Newsgroups: comp.lang.misc
From: jlg@cochiti.lanl.gov (Jim Giles)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Los Alamos National Laboratory
Date: Thu, 9 Apr 1992 17:41:23 GMT

In article <ROCKWELL.92Apr8231542@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [...]
|> Well, in a very real sense, all objects except identifiers are
|> statically declared.  [...]

You mean, all objects except identifiers _and_ expressions involving
identifiers.  But this is a trivial property that's shared by all
programming languages - literals and built-in intrinsics have
statically determined attributes.  If you write code involving
only literals and intrinsics, then all attributes of your program
are static - so why write a program?

|> [...]             Also, there is a class of identifiers which may
|> only be declared once.  [...]

Really?  Please present the mechanism for doing this.  In particular
however, I want the ability to declare identifiers to have _some_
fixed attributes and _some_ attributes that are allowed to vary.
For example, I want to be able to say that X is a scalar floating-point
number - those characteristics of X are fixed for the life of the 
program - but I want the actual _value_ of X to be allowed to be 
changed.

|> [...]                   Finally, note that a compiler would likely
|> create an object whose semantics are fixed.

I don't know what you mean here.  The purpose of _any_ programming
language is to define the semantics of an algorithm.  As such, the
compiler always generates something with _some_ fixed properties.
The question is whether the end user of the language has control
over which properties are fixed and which aren't.

|> [...]
|>    Expressiveness is just exactly the issue.  J does not let me
|>    express clearly those constraints that I know when I write the
|>    code.
|> 
|> It lets me express arbitrary constraints.  Of course, I have the
|> advantage of having learned the language.

Really?  Then you can tell me the very thing I keep asking and you keep 
dodging - how do I declare that a given identifier has a specific type
for the life of the program - yet its _value_ can change?

J. Giles
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Organization: Traveller
	<ROCKWELL.92Apr8164502@socrates.umd.edu>
	<1992Apr9.003132.5175@newshost.lanl.gov>
	<STEPHEN.92Apr9220641@estragon.uchicago.edu>
Date: Sat, 11 Apr 1992 02:48:32 GMT

Stephen P Spackman:
   J is just willing to reinterpret what are the "cells" and what is
   the "carrier" on an operation-to-operation basis - one of its few
   really excellent notions, that other languages need to pick up. You
   are right, though: this information should be encoded in the
   definition of the operator, not at the callpoint.

Um... but J does encode this information at the definition of the
operator.  It's just that J makes operator definition so easy that
operators can be defined and used in place.

I happen to like this feature.  Anonymous function declarations can be
very expressive.

   (And our interlocutor is evading an important issue by saying that
   "names in J are no more significant than parentheses", because they
   seem to have strange interations with the more tightly-binding
   modifiers, like " - or else that " COULD have been in the
   definition).

huh?

   |A similar function can be defined for PSCAN (Fortran already uses
   |the name SCAN for something else) which could be written to
   |perform the same `adverb' that `\' does in APL and J.  The
   |exception would be that the associativity flag would be limited to
   |left-to-right or right-to-left (scanning doesn't make much sense
   |as a completely associative process - partial results appearing in
   |any order?).

   Makes perfect sense, actually: this is the precise structure of a
   search tree (under the interpretation I gave above). Just because
   BOTH FORTRAN and J are too broken to represent trivial data
   structures....  ;-).

I'm sorry, even after reading your search tree structure (elided to
try and keep the reading load down) I'm not sure what it is you think
is missing from J.

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
From: rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell)
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Organization: Traveller
	<ROCKWELL.92Apr8002239@socrates.umd.edu>
	<1992Apr8.180853.9814@newshost.lanl.gov>
Date: Wed, 8 Apr 1992 21:53:22 GMT

Jim Giles:
   Any such tools that are applicable to J could also be applied to
   Fortran to the same degree.  Debugging, for example, cannot be done
   for either language in a system independent way unless you
   interpret the source.  Source interpretation can be applied to
   Fortran.

Is there a standard for interpreted Fortran?  Does it allow you to
write utilities in platform-independent Fortran for debugging?  Can
you mix interpreted and compiled Fortran [to obtain speed for commonly
repeated operations]?

How easy is it to change a declaration in interpreted Fortran, should
that declaration turn out to be a problem?  Can Fortran be used to
manipulate blocks of interpreted code?

Or are you limited to whatever user interface your interpreted Fortran
vendor provides?

What facilities does Fortran have to support interpreted interaction?
[Note: I've never seen a Fortran interpreter, and am not sure I'd
consider such a thing to be particularly useful.  The design of
Fortran seems, to me, to demand more "batch-oriented" debugging
techniques.]

-- 
Raul Deluth Miller-Rockwell                   <rockwell@socrates.umd.edu>
Xref: sparky comp.lang.misc:1735 comp.lang.functional:495 comp.object:1772
From: jack@dcs.glasgow.ac.uk (Jack Campin)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: Re: Types as first-class values?
Date: 16 Apr 92 11:32:31 GMT
Reply-To: jack@dcs.glasgow.ac.uk (Jack Campin)
Organization: COMANDOS Project, Glesga Yoonie

oscar@cui.unige.ch (Oscar Nierstrasz) wrote:
> Can anyone provide any references to programming languages that
> treat types as first-class values?

David Harland's language Poly does this.  It's described in:

	AUTHOR: Harland D. M David M.
	TITLE: Polymorphic programming languages
	IMPRINT: Chichester Horwood 1984
	SERIES: Ellis Horwood series in computers and their applications 25

From what I've seen of it, it looks like a hacker's dream and a
theoretician's nightmare.  It's been implemented on special-purpose
hardware - the Linn Rekursiv, also designed by Harland.


-- 
--  Jack Campin    room G092, Computing Science Department, Glasgow University,
17 Lilybank Gardens, Glasgow G12 8RZ, Scotland   TEL: 041 339 8855 x6854 (work)
INTERNET: jack@dcs.glasgow.ac.uk or via nsfnet-relay.ac.uk    FAX: 041 330 4913
BANG!net: via mcsun and uknet     BITNET: via UKACRL    UUCP: jack@glasgow.uucp
Xref: sparky comp.lang.misc:1698 comp.lang.functional:477 comp.object:1746
From: jim@netlink.cts.com (Jim Bowery)
Newsgroups: comp.lang.misc,comp.lang.functional,comp.object
Subject: Re: Types as first-class values?
Date: 14 Apr 92 14:19:22 GMT
Article-I.D.: netlink.Zm68iB1w164w
Organization: NetLink Online Communications, San Diego CA

Oscar Nierstrasz writes:
>Can anyone provide any references to programming languages that
>treat types as first-class values?
 
Try SETL for starters.
 
Set theory defines the algebra of types you want.
 
The real problem for data abstraction languages is to define 
representation mappings between concrete sets representing the
same abstract set, which are implicitly applied when needed.
 
Combine set theory with representation mapping and you have 
accomplished most of the objectives of object oriented programming.

--                    
INTERNET:  jim@netlink.cts.com (Jim Bowery)
UUCP:   ...!nosc!ryptyde!netlink!jim
NetLink Online Communications * Public Access in San Diego, CA (619) 435-6181
From: jlg@cochiti.lanl.gov (Jim Giles)
Newsgroups: comp.lang.misc
Subject: Re: Modula-3, Fortran, Numbers & Aliens
Date: 9 Apr 92 00:51:32 GMT
Article-I.D.: newshost.1992Apr9.005132.8177
Organization: Los Alamos National Laboratory

In article <ROCKWELL.92Apr8165322@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|> [...]
|> Is there a standard for interpreted Fortran?  [...]

The Fortran standard does not specify the means of implementation.
As such, any implementation - including an interpreter - which correctly
processes Fortran programs according to the requirements of the standard
is a standard conforming implementation.

|> [...]                                         Does it allow you to
|> write utilities in platform-independent Fortran for debugging?  Can
|> you mix interpreted and compiled Fortran [to obtain speed for commonly
|> repeated operations]?

Provided you find a Fortran interpreter, the answers are yes and yes.
At least, there is nothing in the standard which prohibits such.

|> [...]
|> How easy is it to change a declaration in interpreted Fortran, should
|> that declaration turn out to be a problem?  [...]

I suspect (not having seen an implementation) that it can be done
as easily as Basic interpreters do.  That is, edit the text of
the offending declaration and type `run' again, or `relink', or
whatever causes the new declaration to be incorporated in the 
existing program.

|> [...]                                    Can Fortran be used to
|> manipulate blocks of interpreted code?

You mean: self modifying code?  Bletch.  But obviously Fortran programs
can be written which edit Fortran source and cause a `relink' or whatever
the interpreter requires.

|> [...]
|> Or are you limited to whatever user interface your interpreted Fortran
|> vendor provides?

Just like J, APL, Ada, Lisp, Algol, ...?

|> [...]
|> What facilities does Fortran have to support interpreted interaction?
|> [Note: I've never seen a Fortran interpreter, and am not sure I'd
|> consider such a thing to be particularly useful.  The design of
|> Fortran seems, to me, to demand more "batch-oriented" debugging
|> techniques.]

And indeed that is a superior method.  This interactive `session' 
pocket-calculator approach to programming languages leaves me cold.
I've never seen a Fortran interpreter either.  One is certainly
possible.  I don't think it's desirable for _any_ language to be 
interpreted.

In code development, you should write your algorithm before you even 
select your programming language.  You should write complete code
(or, at least, stand-alone code portions) before even firing up
the language processor once.  Hacking out algorithms in an interactive
`session' is not even programming in my view.

J. Giles
Newsgroups: comp.lang.misc
From: peter@ferranti.com (Peter da Silva)
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Organization: Xenix Support, FICC
Date: Tue, 14 Apr 1992 20:38:08 GMT

In article <1992Apr13.212346.335@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
> In J, SmallTalk, etc. _all_ attributes are dynamic and can only be 
> restricted by run-time tests (or, what are usually likely to be run-time 
> tests anyway - it is possible for the compiler to statically resolve some 
> of these if it stretches state-of-the-art compiler technology to the 
> utmost

I think you're exxagerating here. SmallTalk did quite a bit of this even back
in 1980, and the MIT MacLisp compiler did a better job on some numeric codes
than the DEC Fortran compiler. We're not talking state of the art technology
here, unless you mean state of the art for over 10 years ago.
-- 
/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
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.misc
Subject: Re: What is a type? (was Re: Fortran90 and Arrays)
Date: 10 Apr 92 17:09:34 GMT
	<BEVAN.92Apr9151907@panda.cs.man.ac.uk>
	<1992Apr10.095151.28116@newshost.lanl.gov>
Organization: Department of Computer Science, University of Manchester
In-reply-to: jlg@cochiti.lanl.gov's message of 10 Apr 92 09:51:51 GMT

In article <1992Apr10.095151.28116@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
   Ok.  But what is your criterion for determining which properties of 
   an object are `type' and which properties are just `value'.

The `type' properties of an object are whatever I assign to the object
or whatever the system infers for itself.  [I don't think this answers
your question, but I don't quite understand the question in the first
place :-)]


   I specified an explicit criterion for deciding what constitutes
   type: those properties which are permanently associated with a name
   (or function, expression, etc.) regardless of run-time variations.

And I objected, because I think this is one particular type of `type'
namely the `static type' of the object.  Whilst it is true that in a
certain class of languages there is no difference between the `static'
and `dynamic' type of an object, I don't think you can generalise to
saying that this means `type' = `static type' and the `dynamic type'
somehow isn't a `type'.


   At both ends of the language spectrum, the definition I gave for type
   is meaningless.

That's another reason why I don't like it as a definitin of `type'.


   In pure functional languages, _no_ property of an object is dynamic
   in a given scope.  So, by my definition, all attributes (including
   those normally called `value') are type attributes.

I'm beginning to _hate_ the definition now.


   In a typeless language (say, SmallTalk for variation in the
   discussion)

Smalltalk is not "typeless" as far as I'm concerned, it has strong,
dynamic (or latent) types.


   all the attributes associated with a name can be assigned.  So, by
   my definition, none of these attributes are type attributes.  In
   between these extremes are the only languages in which the word
   `type' is meaningfully distinguished from `value'.  In my opinion.

So why use a definition of `type' that has such a narrow scope.  IMHO
`static type' is comonly used to describe what you want, so why not
use that?


   (The above is not quite true of SmallTalk.  The distinction between
   a global variable and a temporary or local one is determined by the
   syntax of the identifier - with globals starting with an initial 
   capital letter and others beginning with a lower case letter.  So
   this property qualifies as a type attribute by my definition.)

I thought the upper/lower case stuff was a _convention_ for users
rather than anything enforced by the system.  I'm sure I've fired up
Smalltalk in the past and had global variables called "foo".  It has
been a while, so I guess I could be wrong.  Any current Smalltalkers
want to put the record straight?

bevan
Newsgroups: comp.lang.misc
From: rbe@yrloc.ipsa.reuter.COM (Robert Bernecky)
Subject: Re: Types, arrays, generality, and notation (was: Fortran90 and Arrays)
Reply-To: rbe@yrloc.ipsa.reuter.COM (Robert Bernecky)
Organization: Snake Island Research Inc, Toronto
Date: Mon, 13 Apr 92 15:38:07 GMT

In article <1992Apr10.103445.1055@newshost.lanl.gov> jlg@cochiti.lanl.gov (Jim Giles) writes:
>In article <ROCKWELL.92Apr10011141@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:

>|> Yes.  It gets worse: J doesn't allow you to change a single element of
>|> an array without respecifying the entire array.

Ahoy, there lad! You is confusing the semantics of the operation with
its implementation on a real system ("There are more things in heaven and
earth, Horatio..."): NO APL system I have EVER used would perform
merge-like operations except in place, when reference counts permit.
For most operations, the indexed assignment (whether performed with
indexed assign or a detected merge) IS done in place.

Bob






Robert Bernecky      rbe@yrloc.ipsa.reuter.com  bernecky@itrchq.itrc.on.ca 
Snake Island Research Inc  (416) 368-6944   FAX: (416) 360-4694 
18 Fifth Street, Ward's Island
Toronto, Ontario M5J 2B9 
Canada
Newsgroups: comp.lang.misc