JavaOne: Day 4


JavaOne Day Four


 


This is the last of my daily posts. I've got a list of bigger topics I'm going to post on, but I want to ruminate on them for a few days before I do so.


 


Keynote: Stretch Your Mind


 


“A Gosling-fest” this morning


 


JavaStudio Creater Demo – Again.


 


This and Looking Glass have been the things that get talked about over and over and over. It’s getting a little bit tiring for me, especially since I don’t know enough about the underlying system to be able to tell how cool it is what they’ve done.


 


I’m watching a demo right now with a 10 point font on a giant screen. It’s almost possible to read the text.


 


Demo is showing validation for web entries, which is being hand-coded. I think ASP.NET has better support than this. The demo is the epitome of a non-flashy demo. That may be bad, or that may be good – sometimes good demos can be viewed as too slick.


 


JavaStudio Enterprise demo


 


There are some interesting collaboration features, that let you do collaborative development, with two people viewing and editing the same file. It’s an interesting capability.


 


Java Real-time


 


There’s a real-time (purportedly “hard” real-time) version of Java available, in which you can have threads that aren’t affected by the GC. They show an inverted pendulum real-time control device. This is a really good demo – the pendulum can swing up to vertical, and then hold vertical, both against outside forces, while other anti-social programs are running on the box, and even fail-over to a different system.


 


This is the best keynote demo of the conference.


 


Bluetooth/Jini stuff


 


There’s an interesting concept here. Rather than try to ship out the software to control a device separately, make it part of the device firmware that can be downloaded to your client. The client just needs to be able to support downloading the code and running it, and then it gets a customized control straight from the device.


 


This is pretty cool, though I worry about the hackability. If there’s a security hold, I just need to put a little bluetooth device near the ATM, and I can probably grab ontrol from whomever comes by.


 


The demo is okay if you're a hardware guy - which I am - but for others, being able to turn on an LED from an interface on an IPAQ isn't terribly exciting.


 


Java and Open Source


 


This was a panel discussion, entitled “the Big Question”. The following members:


 


Brian Behlendorf (Apache, Collab.NET)


Rob Gingell  (Sun fellow)


James Gosling


James Governer


Laurence Lessig


Justin Schaffer (MLB.com)


Rod Smith (IBM fellow)


 


Moderator: Tim O’Reilly


 


I took a lot of notes, but I’ll try to summarize it down into something pretty minimal.


 


This talk came as a result of an open letter that Rob Smith sent to the Sun about open sourcing java.  I have to give Sun a lot of credit for engaging in such a discussion in an open forum – I’m pretty sure that Microsoft isn’t at that point. Yet.


 


Tim O’Reilly started by asking how many in the audience contributed to open source projects in their free time. By my estimate, less than 5% of the audience raised their hands.


 


I’ll try to summarize Rod Smith’s position, and talk about the general discussion. The reason I say “I’ll try” is because it’s Rod from IBM and Rob from Sun talking, and I’m not sure my notes are correct in all cases.


 


The most important point of Rod’s position is that there are lots of changes under way on the internet, such as the move towards SOA, and that their impression is that the pace of innovation is slowing down, and that the current rate is not fast enough. I don’t think Rod really put forth a good vision for how things would be different if Java were open source.


 


Brian added some comments on the experience that Apache has had in dealing wth the JCP process. It’s been harder to do than they would like, and he feels that there are many open source people who won’t work with Java because of the difficulty (or perceived difficulty).


 


Rob did most of the talking on the Sun side.


 


This is a continuation of a journey we’ve been on in the last 10 years, originally it was Sun only. Talking about evolution is important, but we have to be cautious about it – the promise we’re offering is that Java programs will not be lied to by things claiming to be Java out of malice or differences in quality of implementation. We need to maintain that as we evolve.


 


Gosling added:


 


There’s a process that happens, where somebody does something really cool, specialized for their needs, but cool. And then the community writes a JSR about taking the concept and coming up with the standard way to express it. Sometimes the community makes a mismash of it, but over time the argument happens about how to take innovation and spread them about. The JCP isn’t so much about innovation, but about harvesting innovation.


 


I think his last point there is very interesting.  Rob also mentioned that their processes are tuned to doing things the way they are now, and doing open source would probably be more expensive.


 


Lessig spent some time talking about not using licenses to keep trust, but using other devices (which, as far as I could tell, he never described in detail) to keep the wrong thing from happening. Both he and Brian have a lot of faith in the community doing the right thing on compatibility, but others see how it would be in the interest of others to be non-compatible (or to not put a focus on being compatible).


 


The best perspective came from Justin, who said:


 


What are you trying to accomplish with making Java open source? Why take what’s working well for many businesses and put it at risk?


 


This got a huge amount of applause from the audience.


 


Sun was very open in changing their process to make it easier for teams to interact. I’ve been struck throughout the conference how much in the Java world gets done through JSRs, and I think that’s one area where Sun has done a much better job than Microsoft has. Just the fact that there’s a public published place for all such ideas is a huge improvement over the way we do things at Microsoft.


 


Web services interoperability and performance: Java 2 platform, enterprise edition, and .NET


 


Note to Sun. Get somebody editing the titles of your talks. The worst I found is:


 


The P2P Sockets Project. Easily Create JXTA Techology based peer-to-peer applicatinos using your skills on the Java 2 platform Enterprise Edition (J2EE)


 


This talk wasn’t very good, as the speakers weren’t very familiar with .NET. Their results (which show J2EE is faster) may be correct, but they didn’t seem to approach the process with much rigor. I don’t think the results from somebody familiar with J2EE but not with .NET are of much use. Nor are the inverse.


 


Particularly annoying was the statement that there was no way to write provider-independent database code in .NET.


 


I left after about 30 minutes to get lunch and look for a power outlet.


 


What’s new with JBuilder (JBuilder 10)?


 


Value of the IDE:



  • Accelerate daily coding tasks (claim ownership of Code Insight, error insight. Didn’t VS do those first?)

  • Goto Definition, UML, etc. from type

  • Automate and integrate the lifecycle. Version management

  • Protocol and standards transparency

 One of the cool things that JBuilder does is distributed refactorings. This allows you to save a refactoring, ship it with a new version of your product, and then allow your client to apply that refactoring on their code to easily migrate to the new version. That’s a nice feature to have.


 


(boy am I tired of 4-quadrant graphs. I’ve seen them in too many talks today).


 


One of the real challenges in the Java space is that the API designers don’t really work with the IDE folks. The IDE talks are sprinkled with comments such as “deployment descriptors really aren’t too easy to understand” or “it’s not very easy to write EJBs”.


 


Code productivity



  • Templates, synch edit, code formatting

  • Refactorings (oo, in the uml borwser)


    • 10 different refactorings, though two of the listed ones are really about understanding rather code rather than refactoring it.

  • Local striping (snapshot of project, local source code)

  • Code folding (region support)

  • Filters in the structure pane

  • Custom debugger views

  • Scope Insight

 


Version management


 


Support StarTeam, CVS, VSS (?), ClearCase


Cutting edge (requirements tracking, bug tracking, task management)


 


Demos (on XP Pro)


 


Nice feature – the icon in solution explorer changes to show which files have compilation errors in them. That makes it somewhat easier to navigate errors and fix them.


 


Templates are very similar to snippets, but AFAICT, they only have a simple “surround” functionality.


 


Syncedit – select a block of text, and then within it if you edit an identifier, it changes all instances of the identifier as you edit it. Sort of like an inline refactoring. Cool.


 


Eclipse 3.0 – New and Noteworthy


 


Approximately 500 people for this talk.


 


Erich Gamma, John Niegard


 


85% of their downloads are on windows. Few Linux useres (< 10%), similar for Mac users.


 



  • Eclipse platform

  • Rich client platform

  • Java application development tools

 


Themes for 3.0



  • User experience – large scale products

  • Responsiveness

  • New look

 


Plan is to talk about things that matter to end users, but the first 20 minutes talks about what architectural changes were made in 3.0.


 


They have an interesting “cheat sheet” feature. It renders in a pane in the IDE, and has user-clickable buttons that cause things to happen.


 


Java related stuff


 


There were a lot of slides here with lots of details, so this is just an overview.


 


Their big push has been architecture to enable deep features. They have a really good AST-based system, and from what I can tell, they’re reconstructing code on the fly from AST changes. This is a really nice infrastructure, and they use it in a number of ways.


 


For example, when the do extract method, they search the ASTs to find other usages of the same pattern, and offer to extract them out as well.


 


They also have some very nice “code exploration” features. For example:


 



  • Click on a parameter highlights all uses of the parameter (background to yellow)

  • Click on exception in catch block highlights all the places where that exception could be thrown in the try block.

  • Click on interface highights all interface implementation methods.

This is a pretty compelling product, especially for the price.


Comments (10)

  1. Andrew Deren says:

    I agree that eclipse refactoring and code editing/navigation is much better than VS2005

    I would really like to see some of those features in VS.

  2. Joe White says:

    Wow… distributed refactorings sound *awesome*. Are you guys going to look into that as a feature for C#?

  3. rjw says:

    How do you write database independent code in .Net?

    1) You have to wrap up all the exceptions, and therefore everything that throws them, because there is no base type SqlException for all providers to inherit from. So either you catch provider specific Exceptions – therefore not independent of providers anymore, must recompile every time a new one comes along. Or do the wrapping nightmare, which, to my knowledge, no one has actually done yet.

    Maybe you just do everything in finally, and pretend that every exception you get is a database failure – Thats pretty broken though.

    2) You have to instantiate some objects via reflection if you don’t want to hard code them. Theres no DriverManager…

    I’ve seen very little .net database code that wasn’t intimately tied to a specific provider, and none that doesn’t suffer from the badly designed exception heirarchy problem.

    The fact that every single example on msdn ties the code to SQL Server probably doesn’t help. The way that all kind of convenience methods are in SQL Server specific classes, rather than provider independent helper classes, directly encourages the code monkeys out there to do the wrong thing – tie themselves to SQL Server utterly.

    Really, I don’t think that this criticism is something Microsofties can act indignant about.

    ADO.net was either designed by people who did not understand JDBC properly ( doubtful ), or by people who wanted to promote creating a hard dependency on one particular database. What a surprise.

  4. Stephen Leach says:

    I have been very disappointed by Eclipse under Mac OS X. I have evaluated it twice now (six months apart). It is a very substandard port of Eclipse, regularly freezing. Colleagues using it under Linux report frequent workspace corruption. My recommendation is to avoid for another six months.

    Of the IDEs I have evaluated on the Mac, only IntelliJ IDEA from JetBrains is viable. Once you get past the bizarre, complicated and frustrating project setup (which cannot even locate the Java VM without your help), discover how to configure it with CVS (doesn’t work properly with SSH2) and get down to writing code it is rock solid and makes writing Java tolerable. That’s an impressive achievement in my book.

    As a baseline comparison, I spent last year writing C++ in Visual Studio (v7) on Windows for a high profile commercial product. IDEA is significantly better in just about every way, including productivity, stability and performance. That’s largely due to Java’s superior design relative to C++, of course – but it will give you some idea of what’s on offer.

  5. Sam Wilson says:

    IDEA is an awesome IDE. The only thing I wish for is that they will abandon Swing so that it will perform better on UI operations.

    MS could learn a lot from this IDE in terms of productivity. It really is a pleasure to use.

Skip to main content