Home Original page

Python from Wise Guy's Viewpoint

Dirk Thierbach dthierbach at gmx.de
Fri Oct 24 08:35:14 EDT 2003 
Kenny Tilton <ktilton at nyc.rr.com> wrote:
> Big deal. From Robert C. Martin:
> 
> http://www.artima.com/weblogs/viewpost.jsp?thread=4639
> 
> "I've been a statically typed bigot for quite a few years....I scoffed 
> at the smalltalkers who whined about the loss of flexibility. Safety, 
> after all, was far more important than flexibility -- and besides, we 
> can keep our software flexible AND statically typed, if we just follow 
> good dependency management principles.
> 
> "Four years ago I got involved with Extreme Programming. ...
> 
> "About two years ago I noticed something. I was depending less and less 
> on the type system for safety. My unit tests were preventing me from 
> making type errors. The more I depended upon the unit tests, the less I 
> depended upon the type safety of Java or C++ (my languages of choice).

Note that he is speaking about languages with a very bad type system.
As has been said in this thread a few times, there are statically
typed languages and there are statically typed languages. Those two
can differ substantially from each other.

Here's a posting from Richard MacDonald in comp.software.extreme-programming,
MID <Xns9327E3738674Fmacdonaldrjworldneta at 204.127.36.1>:

: Eliot, I work with a bunch of excellent programmers who came from AI to 
: Smalltalk to Java. We despise Java. We love Smalltalk. Some months ago we 
: took a vote and decided that we were now more productive in Java than we 
: had ever been in Smalltalk. The reason is the Eclipse IDE. It more than 
: makes up for the lousy, verbose syntax of Java. We find that we can get 
: Eclipse to write much of our code for us anyway.
: 
: Smalltalk is superior in getting something to work fast. But refactoring 
: takes a toll on a dynamically typed language because it doesn't provide 
: as much information to the IDE as does a statically-typed language (even 
: a bad one). Let's face it. If you *always* check callers and implementors 
: in Smalltalk, you can catch most of the changes. But sometimes you 
: forget. With Eclipse, you can skip this step and it still lights up every 
: problem with a big X and helps you refactor to fix it
: 
: In Smalltalk, I *needed* unit tests because Smalltalk allowed me to be 
: sloppy. In Eclipse, I can get away without writing unit tests and my code 
: miraculously often works the first time I get all those Xs eliminated.
: 
: Ok, I realize I have not addressed your question yet...
: 
: No question but that a "crappy statically typed" (*) language can get you 
: into a corner where you're faced with lousy alternatives. But say I 
: figure out a massive refactoring step that gets me out of it. In 
: Smalltalk, I would probably fail without a bank of unit tests behind me. 
: In Eclipse, I could probably make that refactoring step in less time and 
: with far great certainty that it is correct. I've done it before without 
: the safety net of tests and been successful. No way I would ever have 
: been able to do that as efficiently in Smalltalk. (I once refactored my 
: entire Smalltalk app in 3 days and needed every test I had every written. 
: I have not done the equivalent in Java, but I have complete confidence I 
: could do it just as well if not much better.)
: 
: As far as productivity, we still write unit tests. But unit test 
: maintenance takes a lot of time. In Smalltalk, I would spend 30% of my 
: time coding within the tests. I tested at all levels, i.e., low-level, 
: medium, and integration, since it paid off when searching for bugs. But 
: 30% is too much. With Eclipse, we're able to write good code with just a 
: handful of high-level tests. Often we simply write the answer as a test 
: and do the entire app with this one test. The reason is once again that 
: the IDE is visually showing us right where we broke my code and we don't 
: have to run tests to see it.
: 
: (*) I suggest we use 3 categories: (1) dynamically typed, (2) statically 
: typed, (3) lousy statically typed. Into the latter category, toss Java 
: and C++. Into (2), toss some of the functional languages; they're pretty 
: slick. Much of the classic typing wars are between dynamic-typists 
: criticizing (3) vs. static-typists working with (2).
: 
: P.S. I used to be one of those rabid dynamic defenders. I'm a little 
: chastened and wiser now that I have a fantastic IDE in my toolkit.

- Dirk
More information about the Python-list mailing list