Favorite Quotes from this Years Dr. Dobbs Architecture and Design World
I had the opportunity to attend a panel discussion with Scott Ambler (Mr. Agile), Neal Ford (all around guru) and Robert C. Martin (Clean Code). The topic: Dynamic vs Static languages!!
The following is a terse summary of the panel. Use dynamic languages where possible and where appropriate. Where is appropriate? Depends. Most places. Do not fall down the trap that static languages, like C# or Java, will save the world. It’s been over 10 years; end of story. There isn’t a single general purpose to solve everything. Java and C# are “ceremonious”. Studies show that dynamic languages make developers 5x more productive. Dynamic languages will not work without TDD and unit testing. Statically typed run times like the JVM and CLR are ripe playgrounds for deploying dynamic languages on existing infrastructure. Framework libraries are important, but with bloat like .NET, it does not mean a developer will be more productive; what is the one way to read a file in .NET?
A lot of the questions thrown at the panel were similar to “why should I use dynamic languages” or “better than C++? Outrageous!” In my opinion, it’s not the responsibility of those in the know to defend dynamic languages to the rest of the software world. It’s that big, slow, unchanging side of software development that needs to do their own research and understand the benefits of the dynamic language conversation.
Now, a few of my favorite quotes:
Martin: “Is COBOL statically typed?”
Amber: “Sure.”
Ford: “If you only learned Java in school and are put on a C++ project you will blow up the universe.”
Ford or Martin: “Bad developers will move heaven and earth to write bad code.”
Ambler: “IT people screw around all the time. That’s what we do. We don’t act like professionals and aren’t respected.”
And, finally, my favorite quote is from Scott Ambler:
“There is some fantastic research from the 70’s that shows testing at the end [of the project] works really well.”
3 comments so far
Leave a reply
Stephen,
You write- “Studies show that dynamic languages make developers 5x more productive.” I was wondering what studies they site and how “productive” is measured. (Do we use time as a metric? The term “fast and dirty” comes to mind… so how do we then measure programmer “productivity”?)
There are actually a number of studies by Forrester Research and in IEEE Software and ACM showing gains in developer productivity. That does not mean “fast and dirty”. It’s writing less code to accomplish the same task and task while taking advantage of the productivity boosters like duck typing, late binding, introspection, etc. It’s not just a language, like Spanish, it’s about how it can be used and what it accomplishes.
A quote from Productive Programmer by Neal Ford:
Here is an explicit example. As an experienced Java developer, your task is to write a simple program that reads a text file and prints out the contents of the text file with line numbers added to the front of each line. Think about writing that application for a second. It’ll probably look something like this:
public class LineNumbers {
public LineNumbers(String path) {
File file = new File(path);
LineNumberReader reader = null;
try {
reader = new LineNumberReader(new FileReader(file));
while (reader.ready()) {
out.println(reader.getLineNumber() + “:”
+ reader.readLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
reader.close();
} catch (IOException ignored) {
}
}
}
Here is the complete Groovy application to do the same thing:
def number=0
new File (args[0]).eachLine { line ->
number++
println “$number: $line”
}
How many lines did that Java solution have? At some point, the syntactic requirements of Java become more of a constraint than an assistance. The Groovy version has fewer symbols than the Java one has lines of code! If Java and Groovy produce the same byte code, why use the fossilized Java syntax?
—-