This post originated from an RSS feed registered with Agile Buzz
by James Robertson.
Original Post: Unintentionally Amusing
Feed Title: Cincom Smalltalk Blog - Smalltalk with Rants
Feed URL: http://www.cincomsmalltalk.com/rssBlog/rssBlogView.xml
Feed Description: James Robertson comments on Cincom Smalltalk, the Smalltalk development community, and IT trends and issues in general.
The preventive measures attempt to ensure that bugs are not possible in the first place. A lot of progress has been made in the last twenty years along these lines. Such programming practices as strong typing that allows compile-time assignment safety checking, garbage collectors that automatically manage memory, and exception mechanisms that trap and propagate errors in traceable and recoverable matter do make programming safer. The Java language, of course, personifies the modern general-purpose programming language with first-class systemic safety qualities. It's a huge improvement over its predecessor, C . Much can also be said about the visual development tools that simplify and automate more mundane and error-prone aspects of programming
Strong typing isn't the same thing as manifest typing. Smalltalk, for instance, has strong, dynamic typing - an object simply will respond to an inappropriate message in a completely predictable way. Take Java though - you can make the compiler completely happy with a cast, and then end up with a system that falls down at runtime. Languages like Java and C encourage casting - the rigidity of their libraries, the "final" declarations, the way the collection libraries work - you can walk yourself into trouble with MNU handlers in Smalltalk, but you are picked up and driven there by many existing libraries in Java. Maybe Ms. Livschitz should look at what Sun produces before she makes assertions like the above. Strong typing is a good thing - it's really too bad that Sun doesn't encourage it. What she needs to do is go pick up one of the many fine books on TDD - I'd recommend Beck.
There's more:
Q: How well do you think modern programming languages, particularly the Java language, have been able to help developers hide complexity?
A: Unfortunately, I believe modern computer science and software engineering have failed to make significant advances there. The syntax of all mainstream programming languages is rather esoteric. Mathematicians, who feel comfortable with purely abstract syntax, spend years of intense study mastering certain skills. But unlike mathematicians, programmers are taught to think not in terms of absolute proof, but in terms of working metaphors. To understand how a system works, a programmer doesn't build a system of mathematical equations, but comes up with real-life metaphor correctness which she or he can "feel" as a human being. Programmers are "average" folks; they have to be, since programming is a profession of millions of people, many without college degrees. Esoteric software doesn't scale to millions, not in people, and not in lines of code.
Fascinating. The current mainstream languages are Java and MS' "Son of Java", C#. Physician, heal thyself. Go download a Smalltalk, Ruby, or Python system. Heck, go back to your very own research labs and look at Self and Strongtalk - see what your company could have been encouraging instead of what it is encouraging. She says she wants to improve things; a trip to Sun's R&D labs, along with some internal evangelism would help a lot.... But wait!
I envision a programming language that is a notch richer then OO. It would be based on a small number of primitive concepts, intuitively obvious to any mature human being, and tied to well-understood metaphors, such as objects, conditions, and processes. I hope to preserve many features of the object-oriented systems that made them so safe and convenient, such as abstract typing, polymorphism, encapsulation and so on. The work so far has been promising.
She really, really needs to visit the Sun research labs. They already have something a lot like that, called Self. It's been around for years, too. Unintentionally amusing, this article... Further down, the "holy grail" of component based development is raised again. I'm not even going to bother quiting that; more tears and virtual ink have been spilled on that subject than anyone can count. I have little faith in positive progress in that direction; reuse is non-trivial, and I just don't see it getting a lot better anytime soon. Take a trip to the Sun R&D labs, and take a look at what Sun has left withering on the vine.
Previous Topic
