Friday, 27 June 2008
Eclipse 3.4: Ganymede has landed!
I'm so happy I can hardly contain myself!
Posted by at 2:18 PM in Eclipse
Monday, 26 May 2008
Byzantine or Babylonian Confusion in Eclipse?
The entry in Wikipedia on Byzantine Fault Tolerance seems to suggest that the failure of a compiler to report rigorously on the remaining code base, once a syntactical error has been encountered, is an example of a Byzantine Fault.
Somehow, as Byzantine Fault Models are a topic of study in the field of distributed computing, this example feels a bit out of place. The stated problem does not illustrate a specific known issue with distributed compilers either, since it can easily be demonstrated with a compiler running on a standalone single-processing machine. Is this example perhaps the result of Babylonian confusion?
The above example shows a first attempt to make the compiler trip over itself and generate a superfluous error, but does it? Unfortunately, this little ambush yields only one error in the Problems View: in the Java Editor the access modifier of the constructor is flagged as the offending syntax. That's a near miss, of course. The screenshot is taken from the JDT bundled with Eclipse 3.2.2. It can be reproduced on Eclipse 3.4M7.
Remarkably, the Outline View shows a class with the alledgedly offending constructor visible. The incremental compiler of the JDT has classified this error, but managed to create a class file nonetheless. Other objects can invoke this constructor. The fact that a marker is reporting an issue on a working construct is very confusing. It would not be unfair to flag this as a JDT bug. Even if the broken statement is the cause for the compiler's faulty marking, at the least the broken statement should have been marked as well.
A quick comparison with the competition, Netbeans 6.0.1 shows that it can be done. Netbeans complains that it cannot find the class dontSto.
This run-in with the unexpected behaviour of the JDT compiler might have taken the attention away from the original question, yet so far there is no tangible evidence to support an analogy with the underlying Byzantine Generals problem. The compiler is simply struggling with problems studied in the field of Formal Languages Theory. Call it a Babylonian Fault instead if you will, even by granting some vague similarity in terms of recognizing a locus of fault, Byzantine it surely is not.
Technorati Tags: eclipse byzantine fault tolerance compiler jdt
Posted by at 2:13 AM in Eclipse
About:
Categories:
