Jackpot - James Gosling's Latest Project

Pete Bevin writes "Artima has a fine interview with James Gosling, creator of Java, about his latest project. It's called Jackpot, and it treats the parse tree as the program. This makes refactoring much, much more intuitive. The article has some good insights into code visualization, technical writing, and making your programs more understandable."

My opinion?

[jabbadabbadoo]

Gosling + Martin Fowler = Jackpot! If you didn't know, Fowler is THE refactoring guy. They should team up.

Now, put this support straight into emacs and I'll be happy.

Gamma and OO

[schouwl]

For me as along time programmer this feels like moving from C to C++. You can discuss your program on a whole other abstraction level.
GREAT.
Things are getting very interesting in the field of improving the coding process. I still remember Sniff C++ started by Eric Gamma in the early 90-ties. This was the first product to visualize/navigate over large C++ projects that blew me away. One can certainly see this approach in Eclipse - one of the latest projects of Eric Gamma.
A few very smart IDEs appeared - CodeGuide, Eclipse, IDEA.
Eric Gamma was working in an IT research lab in the UBS in Zurich in Switzerland before he became really famouns with his GoF book.
Lars

Link to Jackpot home page

[gwernol]

Not a great deal there yet, but if you're interested in Jackpot then the Jackpot home page [sun.com] would be worth bookmarking for future reference. Their early work on source code metrics is interesting and the published papers listed are a good starting point for more detailed information than can be delivered in an interview.

Re:IntelliJ

[SpryGuy]

No, it is not free nor is it open source. You do, however, get what you pay for. The cost is a factor, though, so it may not be for you.

It's supremely configurable, very keyboard friendly, and has more and better features than its rivals, and runs faster with a better UI.

I personally have not used Eclipse, so I cannot make the judgement myself, but I've read threads debating the merits of the two, and IntelliJ's IDEA seems to come out ahead in the end.

Personally, I like the ease of use and intuitiveness. You don't need to work 'its way', but the more you use it, the more features you learn about, and many times the reward is big enough to warent changing long-time habits. One example:

Type out the word 'new' and the first few letters of the class you want. Then hit the 'code completion' key, and then hit 'introduce variable'. Wham. It completes the entire line, declaring the variable in line. You save a vast amount of typing. Or you can 'program by intention'... just start typing code. If you type a method name or variable that doesn't yet exist, just hit Alt-Enter and it'll let you create it. A simple 'back' button and you're back where you were to continue coding.

Code inspections find potential Null Pointer Exceptions and other common issues and errors; never worry about managing imports again; fold away code you don't want to see; automatically detects out of date or erronious javadocs and flags them; incredible refactoring support (rename variable, method, class; push method or varible up or down the inheritance hierarchy; introduce methods and variables; extract methods from inline code; inline methods; change method signatures; etc); real-time syntax checking and error/warning highlighting (see at a glance if you have any unused variables, private methods, typos, etc); awesome code completion; great code navigation (jump to implementation/declaration, forward/back); intelligently "find usages" of specific variables or methods; call and inheritence hierarchy trees; ....

I could go on forever. Plus, if there's anything you think is missing, or don't like, you can easily write a plug-in to add it or modify the behavior. Many people have. IntelliJ even has a WIKI site for users to post their own plug-ins. They also have an excellent bug reporting system, and they're very responsive.

The Refactoring Browser

[JustAClam]

Most of this stuff isn't new. The first general refactoring tool I ever saw was the RefactoringBrowser built by John Brant and Don Roberts at the University of Illinois at Urbana-Champaign. It uses Smalltalk parse trees to analyze code, perform refactorings, lint checks and code rewrites. It's free and has been incorporated into VisualWorks Smalltalk, Dolphin Smalltalk and Squeak, and is available as an add-on for VisualAge Smalltalk. To see the kinds of refactorings supported, check out: http://st-www.cs.uiuc.edu/~brant/RefactoringBrowse r/Refactorings.html

To see the lint checks available, look at:
http://st-www.cs.uiuc.edu/~brant/RefactoringB rowse r/Lint.html

And to see the parse tree based rewrite tool, go to: http://st-www.cs.uiuc.edu/~brant/RefactoringBrowse r/Rewrite.html

To see how long this has been available and something of it's evolution, check out the HyperNews page at http://st-www.cs.uiuc.edu/HyperNews/get/Refactorin gBrowser.html and look at the dates. People use this free tool set every day.

A commercial Lisp system did this...

[alispguru]

... in 1987. I worked for Xerox AI Systems at the time and was one of the developers for the Lyric release of LOOPS.

LOOPS had:

A single-inheritance object system with GUI support (class, method, and object browsers).

Editing with structure editors that manipulated the parse tree directly. The structure editor was also used as the inspector in the debugger.

refactoring support in the browsers (select a method and move it to another class, etc).

automated global refactoring based on code analysis - this being 1987, it had a pseudo-natural language interface (EDIT ALL METHODS CALLING FOO AND REFERENCING *BAR*...).

LOOPS is one of the primary predecessors of CLOS (the other being Flavors).

Parse-tree-based editing has been around for awhile - Google for "syntax directed editing". Paradoxically, it works much better in Lisp than in other, more syntax-heavy domains; when your editor insists that everything be syntactically and semantically well-formed all the time, it's best that there be very few, very general syntax rules. This is why it also works in Smalltalk.