Lisp Book(s) in the K&R Style
no.e...@this.place
of "The C Programming Language" by K&R?
Kenny Tilton
no.e...@this.place wrote:
> Are there any Lisp books in the style
> of "The C Programming Language" by K&R?
>
Maybe Paul Graham's "ANSI Common Lisp"?
--
Cells? Cello? Cells-Gtk?: http://www.common-lisp.net/project/cells/
Why Lisp? http://lisp.tech.coop/RtL%20Highlight%20Film
"Doctor, I wrestled with reality for forty years, and I am happy to
state that I finally won out over it." -- Elwood P. Dowd
Jens Axel Søgaard
> Are there any Lisp books in the style
> of "The C Programming Language" by K&R?
If Scheme counts as a Lisp, then "The Scheme Programming
Language" by Dybvig fits the bill.
<http://www.scheme.com/tspl3/>
--
Jens Axel Søgaard
Nikhil Ketkar
language. You see, if you know the rules for tic-tac-toe you know to
play tic-tac-toe but if you know the rules of chess you dont know
chess. Its like that.
I think these 4 books together make good combo,
1)Common Lisp: An Interactive Aproach
2)On Lisp
3)Commmon Lisp The Language
4)Practical Common Lisp
Lisp supports 5 styles of programming
1>Functional
2>Applicative
3>Imperative
4>Object Oriented
Book (1) introduces you to all of them.
Book (2) shapens your lisp skills.
Book (3) tells you a lot about lisp, must read or you will end up
duplicating the functionality already present in lisp.
Book (4) is to learn to work on real world apps.
All these books are free!!!!
Hope this helps,
Nikhil Ketkar
Edi Weitz
> I think these 4 books together make good combo,
> 1)Common Lisp: An Interactive Aproach
> 2)On Lisp
> 3)Commmon Lisp The Language
> 4)Practical Common Lisp
>
> Lisp supports 5 styles of programming
> 1>Functional
> 2>Applicative
> 3>Imperative
> 4>Object Oriented
Five? Hmmm...
Anyway, to me this sounds as if all of these styles were mutually
exclusive. That's not necessarily the case. The beauty of Lisp is
that you can mix them as you like it.
> Book (1) introduces you to all of them.
> Book (2) shapens your lisp skills.
> Book (3) tells you a lot about lisp, must read or you will end up
> duplicating the functionality already present in lisp.
> Book (4) is to learn to work on real world apps.
I think (4) is a very good book to start learning Lisp, escpecially if
you already know other programming languages like Java or C. (2) is a
great book but it is quite advanced and assumes that you've already
mastered the basics. (3) describes a point in time during the
standardization process but not the language as defined by ANSI now.
For that you should look at the ANSI standard which is available
in HTML-ized form here:
<http://www.lispworks.com/documentation/HyperSpec/Front/index.htm>
(3) includes some stuff that is of historical interest and it also
includes more explanation than the ANSI standard. But if in doubt you
have to check the standard. (1) I don't know good enough.
For learning good, idiomatic Lisp I'd also recommend Peter Norvig's
PAIP:
<http://www.norvig.com/paip.html>
> All these books are free!!!!
What does "free" mean? All these books are available for online
reading but still copyrighted works. Some of them are also available
in dead-tree form so if you like them you should consider buying them
to support their authors.
Cheers,
Edi.
--
Lisp is not dead, it just smells funny.
Real email: (replace (subseq "spam...@agharta.de" 5) "edi")
Paolo Amoroso
> What does "free" mean? All these books are available for online
> reading but still copyrighted works. Some of them are also available
> in dead-tree form so if you like them you should consider buying them
> to support their authors.
And the publishers who invest in Lisp.
Paolo
--
Why Lisp? http://lisp.tech.coop/RtL%20Highlight%20Film
Recommended Common Lisp libraries/tools (see also http://clrfi.alu.org):
- ASDF/ASDF-INSTALL: system building/installation
- CL-PPCRE: regular expressions
- UFFI: Foreign Function Interface
Kenny Tilton
Nikhil Ketkar wrote:
> There canot be a K&R like book for Lisp because its a different kind of
> language.
No doubt, but I assume the OP knew that. So we are looking for other
commonalities:
- high quality prose
- exercises at the end of the chapters
- usable as a reference as well as a linear course of study
But I did not actually drag out K&R and Paul's book, so maybe I am
missing something else.
kt
Pascal Bourguignon
> Lisp supports 5 styles of programming
> 1>Functional
> 2>Applicative
> 3>Imperative
> 4>Object Oriented
What about the other programming paradigms?
* Structured programming
* Unstructured programming
* Imperative programming
* Declarative programming
* Procedural programming
* Functional programming
* Value-level programming
* Function-level programming
* Flow-driven programming
* Event-driven programming
* Scalar programming
* Array programming
* Class-based programming
* Prototype-based programming
* Rule-based programming
* Constraint programming
* Component-oriented programming
* Aspect-oriented programming
* Symbolic programming
* Table-Oriented Programming
* Pipeline Programming
* Post-object programming
* Subject-oriented programming
* Reflective programming
http://en.wikipedia.org/wiki/Programming_paradigm
--
__Pascal Bourguignon__ http://www.informatimago.com/
Nobody can fix the economy. Nobody can be trusted with their finger
on the button. Nobody's perfect. VOTE FOR NOBODY.
Gareth McCaughan
> Nikhil Ketkar wrote:
>
>> There canot be a K&R like book for Lisp because its a different kind of
>> language.
>
> No doubt, but I assume the OP knew that. So we are looking for other
> commonalities:
>
> - high quality prose
> - exercises at the end of the chapters
> - usable as a reference as well as a linear course of study
- concise
- written by people intimately familiar with the language
--
Gareth McCaughan
.sig under construc
André Thieme
> Lisp supports four styles of programming
> 1>Functional
> 2>Applicative
> 3>Imperative
> 4>Object Oriented
One question: in what language can you /not/ programm object oriented?
André
--
Christopher C. Stacy
> Are there any Lisp books in the style
> of "The C Programming Language" by K&R?
I haven't read that book since 1979, so I don't remember
the style at all. What was it that appealed to you?
Patrick Frankenberger
You can program any way you like in any turing-complete language by
implementing half of common lisp in it.
Language support makes it far easier though.
AFAIK language support for OO-style programming is missing in Awk, C,
Forth, Fortran, APL, Prolog.
RC
news:uy8axl...@news.dtpq.com:
Tough to say but I'll try to explain.
There are several points already mentioned:
<quote>
- high quality prose
- exercises at the end of the chapters
- usable as a reference as well as a linear course of study
- concise
- written by people intimately familiar with the language
</quote>
Some other points that emerge from the ones mentioned:
- examples used to illustrate the language are the simplest
possible but yet useful enough to be reused in larger contexts.
- a style of coding that you are inspired to emulate.
- simplicity of exposition.
- the shortest distance between two points philosophy.
- a picture is worth 1000 words philosophy.
- elegance.
- all in a bit more than 200 pages.
- the "wow, I didn't know you could do that" in one line of code.
- did I mention the examples?
Alain Picard
> One question: in what language can you /not/ programm object oriented?
C++.
And I'm only _half_ joking.
Tim X
> Nikhil Ketkar wrote:
>
>> There canot be a K&R like book for Lisp because its a different kind of
>> language.
>
> No doubt, but I assume the OP knew that. So we are looking for other
> commonalities:
>
> - high quality prose
> - exercises at the end of the chapters
> - usable as a reference as well as a linear course of study
>
> But I did not actually drag out K&R and Paul's book, so maybe I am
> missing something else.
>
I think one of the key things about K&R's book was that it was
increadibly concise, small clear and contained good examples
etc. Putting aside language issues for a moment, I would have to say
that learning C with that book was one of the more pleasant
experiences I had when tackling a new language.
Unfortunately, the trend with computer books these days seems to be to
see how many dead trees you can squeeze into one book. It never ceases
to amaze me how books with so many pages contain such little
substance.
Personally, I'd love a K&R style book for CL, but I'm not sure it can
be done. The hyperspec is great, but sometimes you want just a little
more context and you want a book where you can find the paragraph
relevant to what you are doing quickly and find that when you have
read it, you have more understanding. I've found with many Lisp books
that while I might eventually find an answer to my question, I end up
with more questions. However, this is more likely to be a function of
the language than how the authors have written the book.
Tim
--
Tim Cross
The e-mail address on this message is FALSE (obviously!). My real e-mail is
to a company in Australia called rapttech and my login is tcross - if you
really need to send mail, you should be able to work it out!
Paul F. Dietz
> - exercises at the end of the chapters
K&R had exercises?
Paul
T.M. Sommers
Sure. There was also _The C Answer Book: Solutions to the
Exercises in The C Programming Language_, by Tondo and Gimpel, 1985.
--
Thomas M. Sommers -- t...@nj.net -- AB2SB
Zach Beane
> - examples used to illustrate the language are the simplest
> possible but yet useful enough to be reused in larger contexts.
>
> - a style of coding that you are inspired to emulate.
>
[snip]
>
> - did I mention the examples?
I like K&R, but some of the examples were elegant and simple because
they explicitly omitted error checking necessary for robustness.
Zach
Thomas F. Burdick
Right, that would be correct C style. Fortunately for Lispers,
correct Lisp style and correct behavior go together.
I'm afraid that PAIP might be the best we have. It's huge, but
there's not really any filler in it, it's all content.
Alternately, On Lisp is a great example of a perfectly nice, if a
little quirky, style.
Nikhil Ketkar
Thanks
Nikhil Ketkar
provides constructs to make the job easy.
Philip Ansteth
> Are there any Lisp books in the style
> of "The C Programming Language" by K&R?
I second the comparison to Graham's "ANSI Common Lisp".
Both start with a tutorial. Then both have a series of more
advanced explanations. Then both end with a reference section.
David Steuber
> Personally, I'd love a K&R style book for CL, but I'm not sure it can
> be done. The hyperspec is great, but sometimes you want just a little
> more context and you want a book where you can find the paragraph
> relevant to what you are doing quickly and find that when you have
> read it, you have more understanding. I've found with many Lisp books
> that while I might eventually find an answer to my question, I end up
> with more questions. However, this is more likely to be a function of
> the language than how the authors have written the book.
Keene's book on CLOS has an appealing thinness to it.
--
An ideal world is left as an excercise to the reader.
--- Paul Graham, On Lisp 8.1
No excuses. No apologies. Just do it.
--- Erik Naggum
GP lisper
As a long time perl coder, I never learned how to update running
source, something I did this morning in cmucl at about 3x the
development rate of the old run-check output-recode-do over method.
--
Everyman has three hearts;
one to show the world, one to show friends, and one only he knows.
beli...@aol.com
<snip>
> > One question: in what language can you /not/ programm object
oriented?
>
> You can program any way you like in any turing-complete language by
> implementing half of common lisp in it.
>
> Language support makes it far easier though.
>
> AFAIK language support for OO-style programming is missing in Awk, C,
> Forth, Fortran, APL, Prolog.
Fortran 90 has user-defined types with public and private members and
operator overloading and thus provides some support for OOP. Fortran
2003 adds single inheritance and other OOP features.
RC
news:xcvmzrc...@conquest.OCF.Berkeley.EDU:
> I'm afraid that PAIP might be the best we have. It's huge, but
> there's not really any filler in it, it's all content.
>
I've started looking at the PAIP source code and
I'm getting this error while loading auxfns.lisp:
CL-USER> (load "auxfns.lisp")
DEFUN/DEFMACRO(SYMBOL): #<PACKAGE COMMON-LISP> is locked
[Condition of type SYSTEM::SIMPLE-PACKAGE-ERROR]
Restarts:
0: [CONTINUE] Ignore the lock and proceed
1: [ABORT] Abort handling SLIME request.
It does not seem to affect loading (if you continue) but what does this
mean and is there a way to correct it?
This also happens while loading other modules.
Thanks
RC
Fred Gilham
> It does not seem to affect loading (if you continue) but what does this
> mean and is there a way to correct it?
This is one of the relatively few places where Lisp makes you "take
your medicine, it's good for you even if it tastes bad." You aren't
supposed to be able to modify system packages, and more and more
implementations are enforcing it.
To get rid of the continuable error, wrap the offending forms in a
WITHOUT-PACKAGE-LOCKS form. I should say, find what your system's
package-lock disabling method is and use it. In CMUCL it's
WITHOUT-PACKAGE-LOCKS.
--
Fred Gilham gil...@csl.sri.com
When I was growing up, I found that the main argument against
laissez-faire, and for socialism, was that socialism and communism
were inevitable: "You can't turn back the clock!" they chanted, "you
can't turn back the clock." But the clock of the once-mighty Soviet
Union, the clock of Marxism-Leninism, a creed that once mastered half
the world, is not only turned back, but lies dead and broken forever.
-- Murray Rothbard
Pascal Bourguignon
> I've started looking at the PAIP source code and
> I'm getting this error while loading auxfns.lisp:
> It does not seem to affect loading (if you continue) but what does this
> mean and is there a way to correct it?
PAIP was written at the CLtL2 times. I use the following loader
script. Define a NORVIG logical host with translations to the
directory where you put the code, eg.:
(setf (logical-pathname-translations "NORVIG")
'((#P"NORVIG:**;*.*" #P"/home/pjb/src/lisp/norvig/**/*.*")
(#P"NORVIG:**;*" #P"/home/pjb/src/lisp/norvig/**/*")))
;; then:
(load "norvig.lisp"
(in-package "COM.NORVIG")
; have fun!
;;****************************************************************************
;;FILE: norvig.lisp
;;LANGUAGE: Common-Lisp
;;SYSTEM: -
;;USER-INTERFACE: -
;;DESCRIPTION
;;
;; Loaded for Norvig's code
;;
;;AUTHORS
;; <PJB> Pascal Bourguignon
;;MODIFICATIONS
;; 2003-05-14 <PJB> Created.
;;BUGS
;;LEGAL
;; GPL
;;
;; Copyright Pascal Bourguignon 2003 - 2003
;; mailto:p...@informatimago.com
;;
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License
;; as published by the Free Software Foundation; either version
;; 2 of the License, or (at your option) any later version.
;;
;; This program is distributed in the hope that it will be
;; useful, but WITHOUT ANY WARRANTY; without even the implied
;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;; PURPOSE. See the GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public
;; License along with this program; if not, write to the Free
;; Software Foundation, Inc., 59 Temple Place, Suite 330,
;; Boston, MA 02111-1307 USA
;;****************************************************************************
(defpackage "COM.NORVIG"
(:use "COMMON-LISP")
(:SHADOW "EXP"))
(in-package "COM.NORVIG")
(DEFPARAMETER CONFIGURATION
'(GPS-SEARCH ELISA-PM PROLOG-CP KREP SYNTAX-3 SCHEME-3 SCHEME-C3))
(DEFMACRO EXCLUSIVE (&REST E-B)
(LET ((ETIQUETTES (MAPCAR (FUNCTION CAR) E-B))
(REP (GENSYM "REP")))
`(LET ((,REP (INTERSECTION CONFIGURATION ',ETIQUETTES)))
(IF (= 1 (LENGTH ,REP))
(PROGN
(SETQ ,REP (CAR ,REP))
(FORMAT T "~&CONFIGURED: ~A~%" ,REP))
(SETQ ,REP
(DO ((,REP NIL))
(,REP ,REP)
(FORMAT *QUERY-IO* "~&Please choose what to load from ~S: "
',ETIQUETTES)
(SETQ ,REP (READ *QUERY-IO*))
(UNLESS (MEMBER ,REP ',ETIQUETTES) (SETQ ,REP NIL)))))
(CASE ,REP
,@E-B))))
(DEFVAR *PAIP-SOURCE-FILES*
(TRANSLATE-LOGICAL-PATHNAME (MAKE-PATHNAME
:HOST "NORVIG"
:DIRECTORY '(:ABSOLUTE)
:NAME NIL
:TYPE "LISP"))
"The location of the source files for this book.
CHANGE IT TO REFLECT THE LOCATION OF THE FILES ON YOUR COMPUTER.")
(LOAD "norvig:intro.lisp") ;; A few simple definitions
(LOAD "norvig:simple.lisp") ;; Random sentence generator (two versions)
(LOAD "norvig:overview.lisp") ;; 14 versions of LENGTH and other examples
(LOAD "norvig:auxmacs.lisp") ;; A few macros; load this first.
(UNLESS (FBOUNDP 'COMMON-LISP:LOOP)
(LOAD "norvig:loop.lisp")) ;; Load if your Lisp doesn't support ANSI LOOP
(LOAD "norvig:auxfns.lisp") ;; Commonly used auxiliary functions.
(LOAD "norvig:search.lisp") ;; Search Utility
;; "norvig:search.dat" ;; Test data (examples) for above
(EXCLUSIVE
(GPS-SIMPLE
(LOAD "norvig:gps1.lisp") ;; Simple version of General Problem Solver
;; "norvig:gps1.dat" ;; Test data (examples) for above
)
(GPS
(LOAD "norvig:gps1.lisp") ;; Simple version of General Problem Solver
(LOAD "norvig:gps.lisp") ;; Final version of General Problem Solver
;; "norvig:gps.dat" ;; Test data (examples) for above
)
(GPS-SEARCH
(LOAD "norvig:gps1.lisp") ;; Simple version of General Problem Solver
(LOAD "norvig:gps.lisp") ;; Final version of General Problem Solver
(LOAD "norvig:gps-srch.lisp") ;; Version of GPS using the search utility
;; "norvig:gps-srch.dat" ;; Test data (examples) for above
))
(LOAD "norvig:patmatch.lisp") ;; Pattern Matching Utility
;; "norvig:patmatch.dat" ;; Test data (examples) for above
(EXCLUSIVE
(ELISA-BASIC
(LOAD "norvig:eliza1.lisp") ;; Basic version of Eliza program
)
(ELISA
(LOAD "norvig:eliza.lisp") ;; Eliza with more rules; different reader
)
(ELISA-PM
(LOAD "norvig:eliza-pm.lisp") ;; Version of Eliza using utilities
(LOAD "norvig:cmacsyma.lisp") ;; Efficient Macsyma with canonical form
;; "norvig:cmacsyma.dat" ;; Test data (examples) for above
))
(LOAD "norvig:student.lisp") ;; The Student Program
;; "norvig:student.dat" ;; Test data (examples) for above
(LOAD "norvig:macsyma.lisp") ;; The Macsyma Program
(LOAD "norvig:macsymar.lisp") ;; Simplification & integration rules for Macsyma
;; "norvig:macsyma.dat" ;; Test data (examples) for above
(LOAD "norvig:unify.lisp") ;; Unification functions
(EXCLUSIVE
(PROLOG1
(LOAD "norvig:prolog1.lisp") ;; First version of Prolog interpreter
;; "norvig:prolog1.dat" ;; Test data (examples) for above
)
(PROLOG
(LOAD "norvig:prolog.lisp") ;; Final version of Prolog interpreter
;; "norvig:prolog.dat" ;; Test data (examples) for above
)
(PROLOG-C1
(LOAD "norvig:prologc1.lisp") ;; First version of Prolog compiler
;; "norvig:prologc1.dat" ;; Test data (examples) for above
)
(PROLOG-C2
(LOAD "norvig:prologc2.lisp") ;; Second version of Prolog compiler
;; "norvig:prologc2.dat" ;; Test data (examples) for above
)
(PROLOG-C
(LOAD "norvig:prologc.lisp") ;; Final version of Prolog compiler
;; "norvig:prologc.dat" ;; Test data (examples) for above
)
(PROLOG-CP
;;(LOAD "norvig:prologcp.lisp") ;; Primitives for Prolog compiler
;;(LOAD "norvig:unifgram.lisp") ;; Unification Parser
;; "norvig:unifgram.dat" ;; Test data (examples) for above
;;(LOAD "norvig:lexicon.lisp") ;; Sample Lexicon of English
;; "norvig:grammar.dat" ;; Test data (examples) for above
(LOAD "norvig:grammar.lisp") ;; Comprehensive grammar of English
))
(LOAD "norvig:clos.lisp") ;; Some object-oriented and CLOS code
;; "norvig:clos.dat" ;; Test data (examples) for above
(EXCLUSIVE
(KREP-1
(LOAD "norvig:krep1.lisp") ;; Knowledge Representation code: first version
;; "norvig:krep1.dat" ;; Test data (examples) for above
)
(KREP-2
(LOAD "norvig:krep2.lisp") ;; Knowledge Representation code w/ conjunctions
)
(KREP
(LOAD "norvig:krep.lisp") ;; Final KR code: worlds and attached functions
))
(LOAD "norvig:mycin.lisp") ;; The Emycin expert system shell
(LOAD "norvig:mycin-r.lisp") ;; Some rules for a medical application of emycin
;; "norvig:mycin.dat" ;; Test data (examples) for above
(LOAD "norvig:waltz.lisp") ;; A Line-Labeling program using Waltz algorithm
;; "norvig:waltz.dat" ;; Test data (examples) for above
;; (LOAD "norvig:othello.lisp") ;; The Othello playing program & strategies
;; "norvig:othello.dat" ;; Test data (examples) for above
(LOAD "norvig:othello2.lisp") ;; Additional strategies for Othello
(LOAD "norvig:edge-tab.lisp") ;; Edge table for Iago strategy
(EXCLUSIVE
(SYNTAX-1
(LOAD "norvig:syntax1.lisp") ;; Syntactic Parser
;; "norvig:syntax1.dat" ;; Test data (examples) for above
)
(SYNTAX-2
(LOAD "norvig:syntax2.lisp") ;; Syntactic Parser with semantics
;; "norvig:syntax2.dat" ;; Test data (examples) for above
)
(SYNTAX-3
(LOAD "norvig:syntax3.lisp") ;; Syntactic Parser with semantics and pref.
;; "norvig:syntax3.dat" ;; Test data (examples) for above
))
(EXCLUSIVE
(SCHEME-1
(LOAD "norvig:interp1.lisp") ;; Scheme interpreter, incl. version with macros
;; "norvig:interp1.dat" ;; Test data (examples) for above
)
(SCHEME-2
(LOAD "norvig:interp1.lisp") ;; Scheme interpreter, incl. version with macros
(LOAD "norvig:interp2.lisp") ;; A tail recurive Scheme interpreter
)
(SCHEME-3
(LOAD "norvig:interp1.lisp") ;; Scheme interpreter, incl. version with macros
(LOAD "norvig:interp3.lisp") ;; A Scheme interpreter that handles call/cc
;; "norvig:interp3.dat" ;; Test data (examples) for above
))
(EXCLUSIVE
(SCHEME-C1
(LOAD "norvig:compile1.lisp") ;; Simple Scheme compiler
)
(SCHEME-C2
(LOAD "norvig:compile2.lisp") ;; Compiler with tail recursion and primitives
)
(SCHEME-C3
(LOAD "norvig:compile3.lisp") ;; Compiler with peephole optimizer
(LOAD "norvig:compopt.lisp") ;; Peephole optimizers for compile3.lisp
;; "norvig:compile.dat" ;; Test data (examples) for all 3 versions above
))
;;;; norvig.lisp -- 2003-05-16 07:54:59 -- pascal ;;;;
Marco Antoniotti
Have they added recursive functions?
Cheers
--
Marco
Hannah Schroeter
Marco Antoniotti <mar...@cs.nyu.edu> wrote:
>> Fortran 90 has user-defined types with public and private members and
>> operator overloading and thus provides some support for OOP. Fortran
>> 2003 adds single inheritance and other OOP features.
>Have they added recursive functions?
Yes. IIRC since F'90.
Kind regards,
Hannah.
Marco Antoniotti
Ok. So the only real advantage that Fortran had over C when writing
numerical software is essentially gone.
I feel I can safely say that right now people are writing Fortran code
because it is a bitch to interface 1-based column-major matrix code with
0 based row-major languages :)
Don't ask me to back it up. It is a conjecture. :)
Cheers
--
Marco
Sampo Smolander
> Have they added recursive functions?
They were in Fortran 90, though you have to mark them like:
RECURSIVE FUNCTION f(x,y)
...
Probably also a lot earlier as almost-standard-non-standard
extensions in several f77 compilers.
Maks Romih
debugger? I mean, the source of the very function or loop you are
stepping through.
This is one of few things that I've enjoyed in Visual Basic and I'm
curious when I will find it in any lisp debugger.
beli...@aol.com
> >>[Has Fortran] added recursive functions?
> >
> >
> > Yes. IIRC since F'90.
> >
>
> Ok. So the only real advantage that Fortran had over C when writing
> numerical software is essentially gone.
> I feel I can safely say that right now people are writing Fortran
code
> because it is a bitch to interface 1-based column-major matrix code
with
> 0 based row-major languages :)
I don't understand why adding recursive functions to Fortran makes it a
poorer language for numerical software. If you are saying there is a
speed penalty for using recursion, the programmer can avoid using it in
the time-critical sections of the code. He need not declare every
function "recursive".
Fortran 90/95 has operations on arrays and array sections, which make
many codes using arrays much smaller than their Fortran 77 or C
analogs.
Barry Margolin
> Is it possible in CMUCL to change the source when stepping through the
> debugger? I mean, the source of the very function or loop you are
> stepping through.
I expect that you can redefine the function, but it won't affect the
current execution that's in progress. Unless the function is
inline-coded into the callers, it should affect subsequent calls to the
function.
--
Barry Margolin, bar...@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
Marco Antoniotti
beli...@aol.com wrote:
> Marco Antoniotti wrote:
>
>
>>>>[Has Fortran] added recursive functions?
>>>
>>>
>>>Yes. IIRC since F'90.
>>>
>>
>>Ok. So the only real advantage that Fortran had over C when writing
>>numerical software is essentially gone.
>>I feel I can safely say that right now people are writing Fortran
>
> code
>
>>because it is a bitch to interface 1-based column-major matrix code
>
> with
>
>>0 based row-major languages :)
>
>
> I don't understand why adding recursive functions to Fortran makes it a
> poorer language for numerical software. If you are saying there is a
> speed penalty for using recursion, the programmer can avoid using it in
> the time-critical sections of the code. He need not declare every
> function "recursive".
Sorry. That was not my intention. I am simply stating a fact. AFAIK,
in Fortran77 and ancestors, subroutines "statically" laid out and
calling from one to another did not incur the cost of pushing a stack
frame. By adopting recursion, F90/95 cannon claim this "efficiency
advantage" anymore.
> Fortran 90/95 has operations on arrays and array sections, which make
> many codes using arrays much smaller than their Fortran 77 or C
> analogs.
That is good. So does Ada. Basically what you are saying is that the
key to writing numerical software now resides on the basic array
manipulation facilities that the language has to offer. I can live with
that.
Cheers
--
Marco
