Re: interpretive vs. compiled
- From: Ed Prochak <edprochak@xxxxxxxxx>
- Date: Tue, 20 Jan 2009 12:23:52 -0800 (PST)
On Jan 20, 8:21 am, thomas.mer...@xxxxxx wrote:
On 19 Jan., 22:31, p...@xxxxxxxxxxxxxxxxx (Pascal J. Bourguignon)[]
wrote:
When writing complex applications it is very important to do a
careful program design. A heap of kludges does not help when the
problem is complex. Usually the development costs are tiny compared
to the maintenance costs which come later.
Please tell that to most management. If we all repeat it enough, maybe
it will sink in.
For this reason it is important to have deliberate concepts before
you start to write code. It is a good idea when this concepts are
also documented as part of the program. A program consists of code
and data and the concepts of both should be documented. It is a big
mistake to omit the description of the data concepts. Although the
data structure is implicitly defined in the code it should still be
described explicit. This improves the readability considerably.
As I often say, self documenting code isn't.
Keep in mind that programs are much more often read than written.
This is the second time you claimed that, but I wonder how true it
really is. I have no evidence either way, do you?
Everything that helps to make a program readable is an advantage.
Agree
There are studies about the costs of errors in big programs.
In general:
- Errors which happen earlier are more expensive than errors
happening later. E.g. A design error is more expensive than
a coding error.
This sounds exactly backwards. Th cost to design a feature is X, the
cost to code that feature is Y. The total cost to the company at the
point code is complete is X+Y. Your statements are confusing here.
- The sooner an error is found and fixed the cheaper. E.g. A
syntax error found at compile time (or at startup time in an
interpreter) is cheaper than a runtime error (which probably
needs a debugging session).
So you recover somewhat here. Errors found in code unit tests require
more work (more $$$ & time) to correct than errors found at design
time (e.g. in a design review). At least once I heard it was something
like a factor of 10 at each stage (i.e., error found at design time
costs about $1, then finding it when coding costs about $10, and in
test about $100 and finally in production about $1000) on a relative
scale.
Conclusion:
If a language is more permissive (no declarations, no types ...)
you get the subjective impression of higher development speed.
But in the end exact the contrary will probably happen:
- When you rush into coding the probability of design errors is
higher.
- Without compile time checks you will probably find the errors
later.
- With the omission of data documentation in the program the
maintenance costs will grow.
For that reasons the core of many comercial big applications is
written in a compiled language.
When I look at the job marked I see two big areas where developers
are searched for big applications: Java and C++. Both are compiled
languages which would not be seen as dynamic programming language.
Greetings Thomas Mertes
Seed7 Homepage: http://seed7.sourceforge.net
Seed7 - The extensible programming language: User defined statements
and operators, abstract data types, templates without special
syntax, OO with interfaces and multiple dispatch, statically typed,
interpreted or compiled, portable, runs under linux/unix/windows.
.
- Follow-Ups:
- Re: interpretive vs. compiled
- From: thomas . mertes
- Re: interpretive vs. compiled
- References:
- interpretive vs. compiled
- From: Jason
- Re: interpretive vs. compiled
- From: Pascal J. Bourguignon
- Re: interpretive vs. compiled
- From: thomas . mertes
- interpretive vs. compiled
- Prev by Date: Re: interpretive vs. compiled
- Next by Date: More game physics glitch questions
- Previous by thread: Re: interpretive vs. compiled
- Next by thread: Re: interpretive vs. compiled
- Index(es):
Relevant Pages
|