|
|
|
An Interview with Brian Sletten of Bosatsu Consulting
|
Article Topics
Introduction · AOP · Ruby Page 3 of 3
Ruby
Stelligent: Ruby is certainly gaining popularity! Last month's interviewee, Tom Copeland,
was also a big Ruby fan! Come to think of it, scripting languages are
rarely analyzed for metrics- why do you think this is the case?
Brian: On one level, the answer
is because it is harder to determine static dependencies in more
dynamic languages. On another level it is because these tools have not
yet been developed although I imagine more will emerge soon enough. I
bet the reason folks haven't taken the time to work on these tools is
due to the intent of the languages themselves. Developers choose these
languages when they are focused on getting things done quickly.
They are satisfying business functionality (or scratching their own
itches), not necessarily worrying about the long-term state of the
code. They refactor as needed, not simply for inner beauty. The
approach reminds me of the great Jean Kerr line, "I'm tired of all this
nonsense about beauty being only skin-deep. That's deep enough. What do
you want, an adorable pancreas?" Scripting language developers don't
usually care about adorable pancreases, they want software running and
running well.
I don't think we are stuck unable to use metrics with scripting
languages though. McCabe and Halstead focus on logical and syntactic
complexity. We could easily calculate those for languages like Ruby and
Python. Those metrics can help identify refactoring candidates or get a
sense of the sufficiency of test code coverage, both of which fall
within the goal space of most Ruby and Python developers I'd say.
The notion of tracking dependencies and managing coupling is harder
without static typing, but, hey, you can still measure typing volume
with SLOC!
Stelligent: You've worked on the IKVM.NET project- what do you think the future holds for .NET/Java integration? Where are we on the continuum of integration right now?
Brian: Yeah, that's a great
project. Jeroen has done an amazing amount of work. Most programmers
think that the only way to integrate the two architectures is through
web services. Being able to run Java code on the .NET runtime without
modification is tremendously exciting. Being able to reuse Java
libraries in .NET applications is promising too. There is so much great
software that needs to be written, generating .NET versions of
well-used, well-tested Java code seems like a big waste of time. As
long as the nits and performance issues continue to be ironed out, this
is a tremendous opportunity for moving forward.
In most ways, Java is just another language to the .NET runtime.
People choose languages for their features, based on what they know,
etc. It will be phenomenal to mix and match languages as needed. I know
a lot of folks think that sounds like chaos, but some problems are more
elegantly expressed in certain languages. The success Jim Hugunin has had with IronPython is encouraging. I'd like to see similar successes for Ruby.
Groovy, Scheme, Jython, JRuby,
etc. can run on the JVM, but there would need to be some incompatible
changes to the VM to support dynamic languages really well. Perhaps it
is time for Sun to break with the past so we can all move forward.
Backward compatibility is a fine goal, but not one worth maintaining if
it is going to stifle innovation unnecessarily. In either case, if that
is the way things are going to GO;, it would be nice if both the JVM and
.NET runtimes supported that model.
Stelligent: What are some good resources for folks looking to learn more about software metrics?
Brian: I haven't been really
happy with most books on code metrics; I think the place to begin is
with good design skills. Once you understand how to manage dependencies
and modularize your design, the role of excessive coupling, complexity,
etc. will make more sense than if you try to apply these metrics in a
vacuum. I think Meilir Page-Jones' "Fundamentals of Object-Oriented Design in UML", Arthur Riel's "Object-Oriented Design Heuristics" and Robert Martin's "Agile Software Development, Principles, Patterns and Practices" are all excellent reads.
Brian Sletten is a liberal
arts-educated software engineer with a focus on forward-leaning
technologies. He grew up around the world in the Philippines, Germany
and Japan. He has a background as a system architect, a developer, a
mentor and a trainer. His experience has spanned defense, finance and
commercial domains with communication software, secure software
consulting, 3D simulation/visualization systems, Grid Computing and a
Semantic Web-based document processing pipeline. Brian speaks regularly
with the NoFluffJustStuff conference on aspect-oriented programming,
design patterns, software metrics, .NET/Java integration and
ZeroConf-based networking protocols. He has also spoken at JavaOne
twice and at user groups around the country. He lives in Fairfax, VA,
where he runs his software consulting business, Bosatsu Consulting,
Inc. He is a happy Apple PowerBook user who thinks "Once you GO; Mac,
you never GO; back."
|
|
