George Will on ABC TV's "This Week" becomes confused about which quagmire we're currently bogged down in...
Lieberman's model on Vietnam -- I'm sorry, on Iraq, is to some extent...Could we keep our quagmires straight please?
"I have a mind like a steel... uh... thingy." Patrick Logan's weblog.
Richard Bair puzzles over a scenario using Java 5 varargs...
The problem is thatI would have expected that passing null to be interpreted as passing one Object, which is null. Strange that null has to be cast to Object though.
(Object)nulltells the compiler to include a one element Object array where the first element is null. Instead, what we wanted to do was this
(Object)null! This is why we get the compiler warning, the compiler doesn't know if we want null to be an element in the vararg array or whether we want it to be the vararg array itself.
But then passing an Object array that is null means "don't pass anything"? This is just puzzling. It should be wrong... an artifact of a not-quite-object-oriented language with too much "magic".
To express "don't pass anything" I would expect to invoke the method like this...
...i.e. don't pass anything.
I would expect a null cast as an Object array to mean the same thing as a null cast to an Object. An Object array should be an Object, in an object-oriented language. No matter how you cast a null argument, it should be interpreted as one argument passed to the method. Instead the meaning changes on how the null is cast, or whether it is cast at all.
Unfortunately as well, invoking the method with no args means an implicit
new of an empty Object array, as opposed to a null cast as an Object array. I guess I need to fire up the computer that has Java 5 on it and see it for myself.
Confusing. These idiosyncracies will cause someone, somewhere, a sleepless night every now and then.
CNN has a list of 10 tech people who don't matter. I don't even know most of the people on the list.
I wonder about two people on the list though. One is Linus Torvalds. The CNN argument is that most Linux innovations come from large organizations rather than Linus. Maybe one could argue that CNN doesn't understand the way open source works, or the place of Torvalds and Linux within OSS. Unix was without a center for decades. Torvalds still appears to be the center of Linux. Without him I wonder if those contributing large organizations and individuals would go spinning off, out of the coherent Linux system, the way it used to be.
The other questionable choice for me would be Sun's Jonathan Schwartz. The point James Robertson continues to make is Schwartz' contribution to the enterprise blogging and transparency movement. As a software developer, the future of Java and the JVM matters to me, and Sun's attitude toward OSS. Also Sun appears to be innovating in the H/W market again, e.g. Thumper.
Steve Dekorte questions some of the conventional wisdom of implementing dynamic languages on Java/C# platforms. Ironically the implementations of Java and C# are essentially based on approaches from the dynamic language community. They have static-ness added on top (e.g. statically-oriented object models and class loaders) and/or into the mix (e.g. statically-oriented instructions).
Maybe a more interesting question is why aren't Java and C# implementations more thoughtfully layered on top of especially efficient implementations of dynamic languages? This has been done before, e.g. implementations of C, Fortran, Ada, et al. on Symbolics and other Lisp Machines. That ordering makes more sense in terms of complexxity.
Current implementations could provide a foundation for such a thing, e.g. the implementation Gambit Scheme would be a particularly good candidate. One problem: the implementation, like most long-lived, highly-tuned software designs, is fairly obscure and familiar to few people.
Depending on Gambit Scheme is riskier than depending on GCC, the JVM, or dotnet. On the other hand the benefits of putting multiple languages on the implementation would likely lead to a larger community of knowledgable systems developers.
Nat on the O'Reilly Radar writes...
Technologists very rarely create something new. C was inspired by BCPL, Unix was inspired by MULTICS, Linux by MINIX, XML by SGML, web services by traditional binary APIs, .... This is the problem with patents: the magic that gets patented often ends up being something as questionably worthy as "the right ingredients that we already had" or "this old solution applied to this new problem".
A comment on James Robertson's blog points out...
The Ruby "VM" is implemented in the slowest way imaginable.There is always the question of "fast enough"... Python, even Ruby have been around a many years. They are obviously meeting enough needs to keep going.
That's not to say better implementations could not expand their range. Certainly they would, all else being equal. But there are many factors and many answers to what is "fast enough".