After lunch on Sunday, many of the speakers formed a panel,
and we had a panel discussion.
One of
the hot buttons was Java vs. Ruby.
Bruce
Tate does all Ruby consulting, and it’s working well for him.
Others on the panel stress that Java and
other strictly typed languages can still be wildly useful.
One of the big points was that Ruby has turned the
conversation from compiled/interpreted and strictly typed vs. dynamically typed
to verifiable. Ruby has proven that strict
typing isn’t as important as working code.
The compiler has become a big spell-checker, but tests are the only
thing that can verify that the program is actually working as expected. Many times we have to add syntax to get the
compiler to shut up. What really matters
is how the program runs.
Venkat (author of Practices of an Agile Developer) added that many languages
check typing at runtime. For instance,
Ruby does do type checking at runtime, but you don’t have declare types when
writing the code. Even with compiled
languages with strict typing, he still wrote bugs and still had to write tests
to verify his code. He has changed his
opinion about compilers and the need. He
says that in dynamic languages, he can speak less, but the computer can infer
the rest from the context of the program.
Scott Bellware asked the question of tool support in Ruby,
and Bruce has acknowledged that the tool support isn’t there yet. Bruce says that every language has grown up
on the command line and then went to an IDE.
Bruce relates that some FUD is circulating that you can’t have
refactoring or write-time help with a dynamic language. The smalltalk browser was very strong, so
that’s an example of a good IDE for that type of language. There are some languages that are compelling
enough for folks to use even before they have good IDE support.
Ted Neward closed the panel with the following: “If anyone disagrees with anything said on
this panel, you are wrong!” :)