Introducing the first Ceylon IDE maintenance update

Just after the release of Ceylon 1.2.0, we started managing a maintenance branch of the IDE-related code, that will always be fully compatible with the last release of the Ceylon (Command line distribution and SDK).

This way we've already been able to very easily backport to this branch many bug fixes or enhancements implemented on the main development branch.

As a result, the first maintenance update of the Ceylon IDE plugin for Eclipse, which fixes about 30 issues, has just been published onto the main Ceylon IDE update site.

So if you currently use the version 1.2.0 of the Ceylon IDE Eclipse plugin, simply run the Check For Updates command in the Eclipse Help menu, and Eclipse should propose you to update the Ceylon IDE features.

And if you still don't use the Ceylon IDE Eclipse plugin, just install it and give it a try now.

Source tracking

Of course each maintenance update will be tagged inside the GitHub source repositories.

So as soon as we know the version of the Ceylon IDE feature, visible from the Eclipse About dialog:

we can immediately checkout the precise source code corresponding to a Ceylon IDE installation.

This will help us reproducing more easily, and fixing more quickly, any issue encountered on the production Ceylon IDE.

Maintenance update release notes

Detailed release notes of this maintenance update can be found here, and related commits can be found here.

Issues

Bugs and suggestions may be reported in GitHub's issue tracker.

About Ceylon

Ceylon is a highly understandable object-oriented language with static typing. The language features:

• an emphasis upon readability and a strong bias toward omission or elimination of potentially-harmful or potentially-ambiguous constructs and toward highly disciplined use of static types,
• an extremely powerful and uncommonly elegant type system combining subtype and parametric polymorphism with:
  • first-class union and intersection types,
  • both declaration-site and use-site variance, and
  • the use of principal types for local type inference and flow-sensitive typing,
• a unique treatment of function and tuple types, enabling powerful abstractions, along with the most elegant approach to null of any modern language,
• first-class constructs for defining modules and dependencies between modules,
• a very flexible syntax including comprehensions and support for expressing tree-like structures,
• fully-reified generic types, on both the JVM and JavaScript virtual machines, and a unique typesafe metamodel.

More information about these language features may be found in the feature list and quick introduction.

Ceylon already has a very complete IDE, based on Eclipse, with many features, that we're very happy with. And considering how young it is, it's quite amazing that it already has all these features, but in the race to create the IDE and add all the features we needed to it, we have always pushed back any work in making it work faster. As a result, we're now to the point where the IDE is mostly complete in terms of features, but pretty slow for large projects.

Luckily, pushing back the work on performance doesn't mean we didn't have ideas for how to improve it, and in fact we have a lot of ideas, and today I'm glad to announce that in collaboration with Serli (one of the companies sponsoring Ceylon), David Festal is going to spend the next six months working on fixing all the speed and memory issues we have with the Ceylon IDE. David is already behind a lot of work that went in the Ceylon IDE and has experience with not just the Eclipse APIs and the Ceylon plugin, but also all the Ceylon sub-systems that the IDE integrates, such as the type-checker, the backends and the module system.

Here are the major points David will be working on for the IDE:

• Opening a Ceylon project should only generate Ceylon binaries if their source has changed.
• Load module dependencies using their binaries if it turns out to be faster than using their sources.
• Make the backend compiler use the already parsed and typechecked AST that is available in the IDE.
• Beef up the automated test suite.
• Share the loaded models for the Ceylon language module and the JDK modules across every project.
• Research performance bottlenecks in the typechecker and backend if required.
• Research and fix memory consumption on some architectures.
• Improve incremental build when editing module files.
• Add visual progress reporting of the module system.
• Improve build visual progress reporting.

We believe that with David's availability and experience, all of these issues will be obliterated and we will have an incredibly fast Ceylon IDE even for large projects, at the latest for January 2014. The good news is that David will start this performance run as early as next week, and we will release new versions of the Ceylon IDE as soon as each improvement is stable enough to ship, so we can expect faster releases really soon.

Go David!

Today we would like to introduce a new eclipse plugin that allows you to run ceylon unit tests, and easily monitor their execution and their output.

It offers similar comfort and integration with IDE as JUnit and even more. Finally, it is part of the Ceylon IDE, so no additional installation is needed.

Getting started with your first ceylon unit test

The new test framework is in the Ceylon SDK module ceylon.test, though this is still an early version and contains only basic functionality, because we need annotations and meta-model support to make it really flamboyant.

So let’s start by importing the ceylon.test module in our module descriptor and writing our first test.

module com.acme.foo '1.0.0' {
    import ceylon.test '0.4';
}

import ceylon.test { ... }

void shouldAlwaysSuccess() {
    assertEquals(1, 1);
}

void shouldAlwaysFail() {
    fail("crash !!!");
}

These tests can be run like any ordinary ceylon application with the following code:

void run() {
    TestRunner testRunner = TestRunner();
    testRunner.addTestListener(PrintingTestListener());
    testRunner.addTest("com.acme.foo::shouldAlwaysSuccess", shouldAlwaysSuccess);
    testRunner.addTest("com.acme.foo::shouldAlwaysFail", shouldAlwaysFail);
    testRunner.run();
}

Which outputs:

======================== TESTS STARTED =======================
com.acme.foo::shouldAlwaysSuccess
com.acme.foo::shouldAlwaysFail
======================== TESTS RESULT ========================
run:     2
success: 1
failure: 1
error:   0
======================== TESTS FAILED ========================

Now let’s see the IDE integrations!

Launch configuration

Once you have created your tests, you can create a Ceylon Test Launch Configuration. In this dialog you can specify the tests to run, their arguments, run-time environment, etc…

In the launch configuration you can directly add test methods or whole containers, like classes, packages, modules, or entire projects.

As you would expect, a quick way to run ceylon tests is to right click in the Ceylon Explorer or in open editor and select Run-As → Ceylon Test.

Viewing test results

The Ceylon Test View shows you the tests run progress and their status. The toolbar has familiar functions:

• show next/previous failure,
• collapse/expand all nodes,
• filter to only show failing tests,
• scroll lock,
• buttons for relaunching or terminating,
• test runs history, and
• menu for view customisation (show elapsed time or show tests grouped by packages).

Comparing test results

In Test Runs History you can review test runs history and switch between runs.

But the real killer feature here happens if you open Compare Test Runs dialog, where you can see which tests have regressed, which tests have been fixed and which tests have been added or removed between two test runs, making it extra easy to get an idea of what your recent work did to the test suite.

Try it now

You can try it right away by downloading one of our Ceylon IDE development build.

Gavin, Sjur and Tomáš have been hard at work all summer to deliver a much-improved version of the Ceylon IDE. This release support exactly the same language constructs and features the same JVM backend compiler as the M3.1 release, so it's 100% compatible with it. But while the backend is the same, the UI is much improved, as you can see from the following change log and screen shots.

No more dependence on IMP

We recommend removing IMP from your Eclipse installation.

Ceylon Explorer view

The Ceylon Explorer View presents packages as children of the containing modules. You should reset your Ceylon Perspective after updating the IDE on order to get the Ceylon Explorer in place of JDT's Package Explorer.

Awesome documentation hover

Hover over the name of a Ceylon or Java declaration to see the gorgeous new hover info. Click in it to browse to other related declarations.

Code popup

Ctrl-P, or "Show Code" pops up an information control containing the code of the referenced declaration. Ctrl-P again opens an editor. Hyperlink navigation from the Code popup is also possible.

Hierarchy and Outline popups

As before, Ctrl-T and Ctrl-O open the popup Hierarchy and Outline views. These now look a lot prettier, and they are also more functional. You can filter the contents by typing inside them, and they remember their bounds. The Hierarchy View is also much better integrated with Java stuff. Ctrl-T inside the open Hierarchy View cycles between Hierarchy View, Supertypes View, and Subtypes View. These popups have configurable background colors.

Auto-addition of needed imports

Refactorings, quick fixes, and autocompletions now add any needed imports to the top of the source file. In addition, autocompletion will propose declarations from any imported module, even if the package is not imported in the current unit.

New Quick Fixes/Assists

Thanks to Sjur and Tomáš, we now have some new quick fixes and assists:

• convert if/else to then/else, then/else to if/else
• invert if/else
• add type constraint to type parameter

Clean Imports

Clean Imports now automatically fills in missing imports if unambiguous, and prompts the user to choose a declaration to import if ambiguous.

Terminate Statement

Ctrl-2 adds any necessary semicolon, closing parens, and closing braces to terminate the statement at the current line. This feature is almost magical in how good it is at guessing where the closing punctuation needs to go.

Mark occurrences

Occurrence marking is now enabled by default and works like JDT (the declaration to highlight is the one under the caret).

Proposals popups

Completions proposals and quick fix/assist proposal popups now have syntax highlighting. Typing a "." automatically activates the completion proposal window. When only one completion proposal is available, it is automatically applied.

Select Enclosing/Restore Previous Selection

Ctrl-shift-up expands the selection to the containing expression or program element. Ctrl-shift-down takes you back to the previous selection.

Also Ctrl-Shift-P takes you to the matching bracket and Show In now works.

Outline View

There is now a popup context menu on Outline View nodes. The selected node now follows the editor caret location.

Tomáš added a toolbar to the Outline View, letting you filter out local declarations and expand/collapse all nodes.

Open Ceylon Declaration / Open Type

The default keyboard binding for Open Ceylon Declaration is now Ctrl-Shift-O instead of Ctrl-Shift-C. This is more ergonomic and works even inside the Java editor. Inside the Ceylon perspective, Ctrl-Shift-T opens the Open Type dialog, which lets you choose between Ceylon and Java types in one dialog (a very slow-to-load dialog, but hey...).

F3 (Open Selected Declaration) now handles Java declarations.

Support for multiple module repositories

The New Project wizard and Ceylon Preferences page now let you configure multiple module repositories for a project.

Backend errors

Errors from the compiler backend now show up in the Problems View and vertical ruler, and compiler progress is visible in the Progress View and status bar. The 80s-style scrolling console is gone.

Progress

Building the completion proposals and hierarchy for the first time is now expensive because it involves trawling the whole JDK. You get a nice progress bar in the status bar of the main window.

Parser lifecycle

Code is lexed/parsed synchronously on every keypress, and lexed/parsed+typechecked synchronously on every keypress when the completions proposals window is open. This results in much more responsive syntax highlighting and fixes some wierd behavior in the completion proposals window. When the completions proposal window is not open, typechecking still happens in a background job as before.

Download it today

The Ceylon IDE is available today from our update site or from Eclipse Marketplace:

Ceylon IDE

Eclipse Indigo

drag and drop into a running Eclipse workspace

After installing, go to Help > Welcome to Ceylon to get started.

Today, we're proud to announce the first official release of the Ceylon IDE.

This release is fully compatible with the already-released Ceylon M1 "Newton" command line distribution which contains the compiler, documentation compiler, language module, and runtime. On the other hand, Ceylon IDE can be used as a standalone Ceylon development tool, even if the full Ceylon distribution is not already separately installed.

You can install Ceylon IDE from our Eclipse plugin update site. The welcome page is a gentle way to get started with Ceylon.

Main features

A full list of features with screenshots can be found here.

Among the features that have greatly enriched the IDE since its first pre-release builds, the following stand out:

• A Ceylon perspective, welcome page, and cheat sheets.
• Wizards to create new Ceylon projects, modules, packages, and units.
• Cross-project dependencies and navigation: add another Ceylon project on the build path, and dependencies are automatically handled.
• Full integration with the Ceylon module architecture: resolve dependencies in an external module repository, and easily export your Ceylon project as a module to a selected repository.
• Enhancements to refactorings, including the ability to refactor even in dirty (unsaved) editors.
• New quick-fixes: for example, when an identifier is unknown, automatically create a new file containing a stub for the missing declaration.
• Improved autocompletion: proposals are now sorted to prioritize those which are assignable to the expected type, as well as those which are declared nearby.
• Customization: easily configure your own colors for syntax highlighting.
• And, of course, many adjustments and bug fixes to provide a stable release.

About Ceylon

This page provides a quick introduction to the language. The draft language specification is the complete definition.

Source code

The source code for Ceylon, its specification, and its website, and its IDE is freely available from GitHub:

https://github.com/ceylon

Issues

Bugs and suggestions may be reported in GitHub's issue tracker.

Community

The Ceylon community site includes documentation, the current draft of the language specification, the roadmap and information about getting involved.

http://ceylon-lang.org