On Sat, 17 Nov 2007, Filip Miletic wrote:
|--------------------------------------------|
|"To the rest: please don't feed the trolls."|
|--------------------------------------------|
Refuting can be useful.
I apologize for provoking the original poster of this thread without
being able to remain to participate in future parts of the thread. Some
contributors to these newsgroups who had emailed me before this season
had been aware of circumstances which deprive me of much opportunity
to contribute to Usenet often. Hopefully I will be more active on Usenet
late in Spring 2008, but I can not be sure now what the circumstances
shall be at that time.
I quote from an article of the ACCU UK Python Users Group entitled
""The sound of one coconut shell clopping"" by Paul Brian in the
August 2002, Volume 14, Number 4 issue of "CVu" (
WWW.ACCU.org ) on
Page 28:
"[..]
Where are the type declarations? Well, Python discovers type at run-time,
[..]
[..]"
I quote from "Using Python's Dynamic Features to Encapsulate Relational
Database Queries" by Richard Taylor in the December 2002 issue of "CVu"
from Page 27:
"[..]
[..] Python's dynamic type system means that you can be unsure of the type
of the variable [..]
[..]"
One of the main goals of static strong typing such as in VHDL and Ada
is to detect mistakes early, especially when attempting to compile
instead of when running (and hence crashing). Instead, in a dynamic,
object-oriented language such as Lisp, mistakes which are trivial for
a VHDL compiler to find crash a program at runtime. E.g. perform the
following experiment: compile the Common Lisp program for theorem
proving called Prototype Verification System (PVS) (e.g. if I recall
correctly, in 2007 it took a CMU CL compiler approximately 40 minutes).
To satisfy yourself that it is how it should be, run PVS and invoke one of
the functions for pretty printing. Quit PVS and change only one lexical
token in PVS's source code: change something in one of the functions for
pretty printing such that a typing error occurs. Recompile (if I recall
correctly, it took approximately 10 minutes for me). Run your modified
PVS and do some things with it. Note how the error has not been detected
yet. Invoke the function you changed, then it crashes. This is an extremely
good advertisement against dynamic typing. I remember someone boasted
on that the advanced debugging features provided
by a Lisp implementation in a fielded application were retained which
made on-site debugging easy. For work of interest to me, being able
to maintain a deployed system is of importance, but that is not a
valid excuse for allowing errors to be present when launching
a system into the field. I quote from "Using Python's Dynamic Features
to Encapsulate Relational Database Queries" by Richard Taylor in the
December 2002 issue of "CVu" from Page 29:
"[..]
This article has demonstrated how features such as dynamic attribute
lookup and class definitions as first class objects can be used to build
flexible abstractions in Python. I have used such techniques extensively in
the applications on which I have worked. However, I have also learned
through bitter experience that such techniques can cause faults that, because
Python has little compile time checking, only become apparent at run time
and can prove very hard to find. These problems can be alleviated with
judicious use of pre- and post-conditions on methods along with careful
use of exception handlers to recover from runtime errors.
[..] tripped
up by a built-in method that you have overloaded by accident. [..]"
For Python; Eiffel; and Lisp, whitespace is significant which can
cause trouble if a text editor which forces a particular layout (e.g.
Pico; Nano; some of the modes of Emacs; Microsoft Edit.com; Vim if
ai (autoindent) is set; and a text editor for VMS Notes) is used and
a change forced by a text editor goes unnoticed.
Python with the Stratus hardware description language has not
displaced VHDL yet. Nor has Python with MyHDL.
The following have been claimed to be terser than VHDL for a
number of hardware uses: C++; Verilog; Verischemelog (I may
have misspelt that name earlier in this thread); APL; Lava;
Confluence; and HDCaml. How could Python even possibly
compete with APL for terseness?
I do not agree that conciseness is a good thing. If one sees
an asterisk, which of Kleene closure; multiplication;
convolution; footnote; and adjoint is denoted by the * in
this instance? How would one check? Adobe Acrobat's search
function can be extraordinarily slow when searching through
a strict subset of Synopsys's documentation on a quadcore
workstation; grep can also accept an asterisk but many
search engines will ignore an asterisk (and just about
every other character which is not alphanumeric). Can you
remember which of the intervals [1,5) and (1,5] includes the
number five? The command
Copy Source.txt Dest.txt
will behave differently on VMS if a file named Dest.txt
already exists than the lexically identical command on
MS DOS. Please find someone who knows neither MS DOS nor
VMS and tell me if this person will correctly say without
prompting all the possible outcomes of entering
Copy Source.txt Dest.txt. Are you fond of the way numbers
instead of words spelt with letters are used to select
different integration methods in SPICE? Would you risk
adjusting this setting without checking which numbers
correspond to which methods?
Please search for an old post by myself in in which I asked a Lint user how he would prevent accidentally
adding a value of a datatype for counting apples to a value of a
datatype for counting oranges. How should these situations be
handled in a better HDL to replace VHDL?