August 21, 2014

EASE - Eclipse Advanced Scripting Environment launched

It's been a while since I last wrote about EASE. Not writing about it does not mean that we were lazy. We applied for an official eclipse project and were busy setting up the infrastructure.

So please welcome the new Eclipse citizen: EASE.


What it does for you

EASE allows to write, maintain and execute scripts right within your IDE. Executed scripts run in the context of the Eclipse JRE, allowing to access all Java classes in your Eclipse universe. Thus you can manipulate and extend your IDE without the need to write plugins, pack them into features, export them into a p2 repository, install, restart, ...

As accessing Java code from script languages is typically an annoying task ("If I could write Java code I would do it in Java, why scripting?") EASE provides extension points to encapsulate typical actions into simple script commands. Basically it allows to create wrappers in the target script language to access Java methods. We already started writing some useful modules. The Modules Explorer view gives a short overview of the available commands (hint: try DND).


You already have a nice API to use? Great, just wrap() it from your script or register it via extension point.

Scripts may include other scripts using URIs. You could even access your scripts using http.To register script locations check your preferences in Preferences/Scripting.

Current UI integration gives access to a nice interactive shell to play around with, script recording and launch support.



Right, where do I get it from?

You find the update site locations on our webpage. We are focusing on Eclipse Luna, so if you are using something older and things do not work as expected, let us know.


Contribute? It's easier than you thought

Contribution is not only about writing code. Just test EASE and let us know what you think of it. Fill the bugtracker with ideas, design icons, write help, provide sample scripts - there are so many things that need a little care.


What's next

This summer we received a great contribution via Google Summer of Code. Martin Kloesch developed a Jython debugger which will be available on the update sites soon.

UI integration to bind scripts to menus and toolbars is basically working, but needs some tweaking.

A set of core modules needs to evolve. Currently we are playing around with the functions, but we need a stable script API for those modules rather soon.

... and I know we have to write lots of help and tutorials to make this project useful for you out there.

Visualize your EMF Model using Sphinx Model Explorer

There is a basic tutorial available on how to get Sphinx working available on https://wiki.eclipse.org/Sphinx/tutorials. But the tutorial is a little confusing for associates who are beginner and get confused on reading the tutorial.




Therefore I intend to segregate the tutorial and make it simpler for people to read thru and finally get the example working for our own EMF Model.

Click Here to Download the Tutorial for Setting Up and Running Sphinx on your EMF Model
Click Here to Download the Source of the Tutorial

You may read other EMF related Articles and Tutorials on ANCIT CONSULTING Website
August 20, 2014

Annotation processing in AJDT

In the recent AspectJ 1.8.2 release annotation processing was properly enabled in the batch compiler (ajc), thanks to a pull request from Sergey Stupin. The natural requirement is then to exploit that in AJDT. The current snapshot builds of AJDT for Eclipse 4.4 now include support for this! In this post we'll take a look at how to use it. You can install it from the snapshot update site: http://download.eclipse.org/tools/ajdt/44/dev/update

Here is my example dumb processor, which creates an aspect for every method it finds in a program that is annotated with @SuppressWarnings. The aspect is a simple piece of before advice on the method:

package example;

import java.io.*;
import javax.tools.*;
import java.util.*;
import javax.annotation.processing.*;
import javax.lang.model.*;
import javax.lang.model.element.*;

@SupportedAnnotationTypes(value= {"*"})
@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class ExampleProcessor extends AbstractProcessor {

private Filer filer;

public void init(ProcessingEnvironment env) {
filer = env.getFiler();
}

public boolean process(Set elements, RoundEnvironment env) {
// Discover anything marked with @SuppressWarnings
for (Element element: env.getElementsAnnotatedWith(SuppressWarnings.class)) {
if (element.getKind() == ElementKind.METHOD) {
// For any methods we find, create an aspect:
String methodName = element.getSimpleName().toString();
String aspectText =
"public aspect Advise_"+methodName+" {\n"+
" before(): execution(* "+methodName+"(..)) {\n"+
" System.out.println(\""+methodName+" running\");\n"+
" }\n"+
"}\n";
try {
JavaFileObject file = filer.createSourceFile("Advise_"+methodName, element);
file.openWriter().append(aspectText).close();
System.out.println("Generated aspect to advise "+methodName);
} catch (IOException ioe) {
}
}
}
return true;
}
}
To use this in Eclipse I first create a simple Java project, and paste this code in. I then add a new file META-INF/services/javax.annotation.processing.Processor and in that file I place the name of my new processor, as shown here:
Now we package the contents of the processor project into a jar. Select the project, Right click > Export then choose Java > Jar file. Then in the JAR Export dialog simply specify where the jar should go (other settings can all default). Here it is going to be placed in the root of the ExampleProcessor project:
Now we are ready to consume it. Create a new AspectJ project and add a simple source file that will trigger the processor:

public class Demo {

public static void main(String[] args) {
callone();
calltwo();
callthree();
}

@SuppressWarnings("rawtypes")
public static void callone() {
System.out.println("In callone");
}

public static void calltwo() {
System.out.println("In calltwo");
}

@SuppressWarnings("rawtypes")
public static void callthree() {
System.out.println("In callthree");
}
}
Finally, configure the annotation processing settings of this AspectJ project. Open the project properties. In the Annotation Processing tab turn on Enable annotation processing:
then on the related Factory Path page, add the jar that we just created.
After confirming all this the project will rebuild and the processor will have run. Simply run the Demo class and the effect of the aspect can be seen:
And that's it! Notice that the aspects were generated and then woven into the demo code.

Important: Due to the way processors are loaded and run as part of the eclipse compilation, the JVM being used to run eclipse needs to be at least the target level of the compiled processor. So if your processor is compiled using Java 8 source/target, you need to be running your eclipse on Java8. There is still some work to do around advice markers but at least the processors are behaving.

Finally, to run all this outside of eclipse, simply use the processorpath option to ajc:

ajc -processorpath <pathto>/processor.jar -1.8 Demo.java

and it will have the same effect. If you encounter any issues when using this, please raise a bug at https://bugs.eclipse.org/bugs/enter_bug.cgi?product=AJDT

It’s the small things in life…

… like tiny red circles with numbers on them.

badges Its the small things in life...

RAP 3.0M1 (to be published this Friday) consists mainly of internal changes, like getting rid of old API and IE8 support. However, we did have time to add this nifty little feature for the TabItem widget. Called “badges”, these small icons let the user know that there was activity in a view or window that is not currently on screen. It’s trivial to use:

tabItem.setData( RWT.BADGE, "23" );

We are thinking about also adding this feature to push buttons and tool items for 3.0. If you think you have a use case that would require badges on other widgets or in different configurations, let us know. We always appreciate feedback, which we rarely get between Cons and demo camps.


TwitterGoogle+LinkedInFacebook

Leave a Comment. Tagged with eclipse, Luna, mars, milestone, rap, eclipse, Luna, mars, milestone, rap

August 19, 2014

Like to pimp your help, eh?

Assuming you have help content and it comprises more than a couple of sentences, your users will explore it by searching the whole content or by following hyperlink by hyperlink, digging deeper level by level into the table of contents. In Eclipse Help it is also possible to search only part of the content by defining a scope or by selecting a topic and searching its subtopics. But this is rarely used because it is cumbersome. Also the wildcards ‘*’, ‘?’ and the boolean operators NOT and OR are rarely used. Just like with Google or DuckDuckGo people tend to search for keywords only.

Autocomplete, instant search and more

Eclipse Luna Help Demo Page
To make searching easier I developed for Advantest a small JavaScript which Advantest made Open Source. It is used to pimp the Advantest SOC help cover page by a search field with autocomplete, instant search (= search results are shown as you type), book selector drop-down menu and input assistance for complex queries.

Try it!

The Advantest SOC help is for customers only, but you can see the JavaScript eh.js (uncompressed, compressed) in action at the Eclipse Luna Help demo page which I have created. Because in JavaScript cross-domain callbacks (which are required for the instant search) are forbidden, this sample page misuses a proxy which makes it slower than when integrated into your help. To see the content of a topic by hovering a search result you have to allow insecure content: click the shield icon in the address bar:
Click the shield icon in the address bar  to allow insecure content

Get inspired

eh.js can also be used for searching a particular part such as a book or a chapter: Place the mouse over a TOC item link to display a search field for this topic and its subtopics only. Eclipse Luna Help contains 66 books and probably you do not want to get your search results flooded by hits in all of them. Or maybe you will use eh.js as a starting point to develop a complete new user interface for the good old Eclipse Help. What should it look like?

Flattr this


Ignite Talks - EclipseCon France 2014

Contributing to Eclipse ? Yes you can ! - Olivier Prouvost [OPCoach] Forget your Excel worksheets ! The model based safety analysis is coming - Jonathan Dumont The new Metrics Dashboard for Eclipse Projects - Alvaro del Castillo [Bitergia], Jesus M. Gonzalez-Barahona [Bitergia] Neo4EMF : When big models are no longer an issue! - Amine BENELALLAM [AtlanMod research team, INRIA & Mines Nantes], Hugo Bruneliere [Inria / Mines Nantes] Slide:http://fr.slideshare.net/HugoBruneliere/neo4emf-eclipsecon-france-2014-ignite-talks-session Model based Requirements Engineering on the Web build on Eclipse RAP and GMF - Dr. Tom Ritter [Fraunhofer FOKUS] Send Push Notifications to your Connected Objects with Vert.x and the UnifiedPush Server - Sébastien Blanc [Red Hat] Infinitely Scalable, Time-Deterministic Java Services - Jean-Marie Dautelle
August 18, 2014

ECF 3.9 Released

ECF 3.9.0 is released.   The release provides an update to our implementation of the OSGi Remote Services and Remote Service Admin specifications.   For RS/RSA the latest (R6) version of the specification included additions and changes, and this release supports them.

The implementation has been tested against and passed the OSGi RS RS/RSA compatibility test suite (CT).

To download and install go here.  

Note also that we now have a several tutorials focused on developing your own OSGi Remote Services.  A couple of these tutorials show how to use Remote Services with the Raspberry Pi.




August 15, 2014

I have a dream, an Eclipse UI dream.

Humour a madman for a second :).

A few months ago, I was pretty excited about the prospect of Eclipse running against a modern UI framework such as JavaFX. Modern applications have a flow or liveliness to them. They aren’t just a bunch of toolbar buttons and menus that take umpteen clicks to do the things you want to do. They move with animations and effects that make your app feel alive. Not everyone agrees that’s what an IDE needs, but I’d like someday to take the time and experiment to see if it does.

And I’ve seen some of what’s possible. Cole Markham’s talk at EclipseCon this year on using the JavaFX e4 renderers for the RCP apps he was building showed the potential. His apps are beautiful and much thanks to the CSS capabilities and animations in JavaFX. It can be done and it can be good.

But what of the Eclipse IDE? Originally I thought we could port SWT to JavaFX and then introduce JavaFX slowly into the vast collection of IDE plug-ins. From Tom Schindl’s great work on this and his experience with it, I’m not sure either of us, or anyone for that matter, thinks it’ll really work. The paradigms are just too different. Maybe JavaFX can evolve to make it closer (and it is indeed still a young API), maybe not.

Where to then? I sometimes go down a dark path looking to too see where the next revolution in IDEs would come from. Eclipse was quite disruptive back in 2000 and had great success. But have we reached a stagnation point forced on by the architecture and tragedy of commons it has brought onto us (without standards and with uber flexibility, every plug-in has been free to implement their own UX and many have)? Will IDEA lead the way with it’s better funding? Will QtCreator take over the C++ world? Or is everyone just happy with their text editors and command line tools that we’ll regress back to the 1990′s?

Well, if there is to be a revolution, a new IDE framework that will fix all that’s broken with the existing ones, I’d actually like to look back at Eclipse. Often when I explain why we have Core and UI plug-ins for all our projects, I’ll bring up that maybe one day we’d like to replace the UI with something else, something not SWT. And maybe this is it. Reuse the valuable Core plug-ins we have that support build and debugging and static code analysis and source control integrations, and replace all their UI plug-ins with new ones that use a new UI framework based on JavaFX.

Am I insane or naive to think that would work. Maybe I don’t think that would work. But I can dream. And maybe someone with the resources will think it’s a good idea and make that dream come true. Or maybe not.

e(fx)clipse 1.0 released

The release

I’m happy to announce the 1.0 release of e(fx)clipse tooling and runtime. I’ve already introduced the most interesting new features in the last 2 weeks

… but there are many many other small improvements, bugfixes, … .

We resolved more the 100 Bug/Feature-Tickets, started to see commercial adoption of our runtime and a vibrant community who started contributing back fixes, filed world class bug reports.

As with any release I’d like to thank some people/organizations:

  • BestSolution.at for sponsoring the development
  • External contributors like Christoph Keimel & Sun Volland for their excellent contributions to the runtime platform
  • the OpenJFX-Team to fix bugs affecting e(fx)clipse and accept contributions so that we could implement missing features

The final bits are in place for you to consume:

Sponsoring

I hope you all enjoy the work we’ve done and continue to provide in the next releases to come. Still we could need some help: You might consider sponsoring the project, so that we can provide the services you are used to and provide a reliable tooling & runtime platform you can build your business applications on.

For more information on sponsoring and the packages available take a look at http://efxclipse.bestsolution.at/sponsoring.html or if you need commercial support see http://efxclipse.bestsolution.at/services.html.


August 14, 2014

e(fx)clipse 1.0 – New Features – Consume Non-OSGi-Artifacts from a maven repository

e(fx)clipse 1.0.0 is just around the corner and scheduled to be released on August 15th, while we are polishing the final bits, the Eclipse IP-Team checks our IP-Log, … .

I’d like to introduce you the new and exiting features that we worked on in the last months since we released 0.9.0 in February.

Blog series

Other posts in this series are:

Consume Non-OSGi-Artifacts from a maven repository

All of our runtime artifacts are OSGi-Bundles and we publish them as a p2 repository (in future I also plan to publish an OBR but that’s something for 1.1) nevertheless some of them do not require OSGi at all and can be used in plain JavaFX applications so we decided to publish them as well to a Nexus-Repository so that you can consume the following artifacts (including all dependencies) from there:

  • org.eclipse.fx.ui.panes: Additional layout panes you know from SWT
  • org.eclipse.fx.ui.controls: Adds some custom controls we’ve developed like e.g. a TabPane who supports Drag and Drop, the StyledText control and some more addons
  • org.eclipse.fx.core.fxml: Holds some addons needed when you are using our FXML to Java translator
  • org.eclipse.fx.core.databinding: Integration layer between Eclipse Databinding and JavaFX-Properties
  • org.eclipse.fx.ui.animation: Some basic animations, nothing fancy but a nice addon for your applications
  • org.eclipse.fx.ui.databinding: Integration between Eclipse Databinding and JavaFX UI Components

Useage is fairly simple all you need to do is to add the efxclipse-Nexus repository to your pom.xml, e.g. to make use of our additional layout panes all you need to to is:

<project xmlns="http://maven.apache.org/POM/4.0.0" ....>
  <repositories>
    <repository>
      <id>eclipse-nexus</id>
      <url>https://repo.eclipse.org/content/repositories/efxclipse-snapshots</url>
      <snapshots><enabled>true</enabled></snapshots>
    </repository>
  </repositories>

  <!-- ... -->
  <dependencies>
    <dependency>
      <artifactId>org.eclipse.fx.ui.panes</artifactId>
      <groupId>org.eclipse.fx</groupId>
      <version>1.0.0-SNAPSHOT</version>
    </dependency>
  </dependencies>

</project>

August 13, 2014

Validation on steroids: high speed for very large scale EMF models

French Social Security is currently effecting a major change in its data collection system and EMF and Eclipse are at the heart of the technical solution designed to implement the electronic data interchange (EDI) channels involved. Data has been collected directly from payroll services by the various social security agencies for some time now. This is done through several different EDI channels. The rework aims at grouping all EDI channels into a single one (named DSN, for nominative social declaration), thus simplifying the data collection overall infrastructure, and also limiting the number of different transmission systems payroll services have to handle (preparation of these transmissions tend to be dreaded moments in the life of a payroll service bureau). One of the main difficulties of this business area lies in ever changing requirements in specifications. Indeed, transmissions formats have to support every new regulation. Given that these specifications routinely handle up to 900 field definitions and 700 consistency rules, reducing time to production and development costs has become a major concern. To face this challenge, the CNAV (French national agency for retirement pensions) department in charge of developing the transmission control software envisioned a form of domain specific approach combining: The specification of consistency rules in a textual DSL (these are first order logical assertions including domain specific predicates and variables); The modeling of transmitted data using a domain specific model and the associated editor. The overall goal was to give business experts the possibility to elaborate the specification for the EDI system in such a way that: the model and rules editor is able to generate the EDI normative documentation from these specifications; the model editor is able to generate an executable validation tool from these specifications (that is, a tool which validates the transmitted data’s compliancy with the standard made of all the requirements expressed in the normative documentation).​ This approach removes the need for a tedious development cycle, especially dangerous when it depends on a protracted requirements elicitation process, and all the misunderstandings it may entail. It is vital to ensure the needed reduction in time to production and development costs. ‘Domain Specific Modeling‘ and ‘generative programming’ were ideal candidates to attain these goals. The technical architecture of the tools which have been developed in collaboration with the company Obeo relies heavily on Eclipse and EMF. The resulting generated validators are currently used in the early phases of the DSN which some compagnies already adopted as an EDI channel to transmit payroll data to social security agencies. In this talk, we aim at bringing a return on this experience to the Eclipse and EMF community. We intend to explain how the EMF tooling allowed us to define a clever data modeling meta-model that provides the right level of abstraction to business experts yet fulfilling their needs. We also intend to mention the numerous pitfalls we encountered over the course of this work, some of which may prove useful to improve and enhance EMF and Eclipse.

PolarSys in Real Life

Slides: http://prezi.com/qjhbwcdctgei/eclipsecon-france-2014-polarsys-in-real-life/ In this talk we will explain how PolarSys technologies dramatically changes the way architects can work on complex systems. By using the PolarSys and Eclipse Modeling stacks (Sirius, GenDoc, Acceleo, Polychrony, OCL, ...) industry solutions can be created which fully fit the needs of architects (design, analysis, verification, simulation, etc.) in many domains (Transportation, Space, Insurance, Telecom, etc). This talk will be illustrated by many case-studies. For example: how a space agency has defined a new approach to develop embedded software for satellites or how a provider of aeronautics systems performs early validation of complex architectures.

One Week until #MesosCon 2014 (and LinuxCon)

Over the last couple of years I’ve been heavily involved in open source infrastructure technology by way of the Mesos project, which my team and Twitter have helped grow outside its humble beginnings as an academic project. As a result, I’m really looking forward to the first #MesosCon next week (co-located with LinuxCon) which my team at Twitter helped put together in collaboration with the awesome Mesos community and the great folks at the Linux Foundation. It was interesting as we put together the conference in a fairly transparent fashion, but that’s a topic for another blog post.

mesoscon

 

 

 

 

The schedule looks great and covers a wide variety of infrastructure usage:

The final day we also have a Hackathon where committers and Mesos community members will be available to drive the project forward based on community interest (basically who shows up).

Also, right before #MesosCon there will be a Docker Meetup in Chicago which will have a talk about running Docker containers on Mesos.

Look forward to seeing everyone in Chicago, feel free to reach out to me if you would like to meet up and chat open source over a frosty beverage.

August 12, 2014

e(fx)clipse 1.0 – New Features – Integration of JavaFX source and property JavaDoc

e(fx)clipse 1.0.0 is just around the corner and scheduled to be released on August 15th, while we are polishing the final bits, the Eclipse IP-Team checks our IP-Log, … .

I’d like to introduce you the new and exiting features that we worked on in the last months since we released 0.9.0 in February.

Blog series

Other posts in this series are:

Integration of JavaFX source and property JavaDoc

JDT in Luna added an extension point e(fx)clipse makes use of to contribute the location of the JavaFX source code when the JRE System Library is initialized. The nice effect this has for developers is that they e.g. can debug through JavaFX source code without any manual configuration.

debug

Unfortunately adding the source produces a problem one does not notice when only the HTML-JavaDoc is attached to the JRE. The JavaFX team is lazy and does not JavaDoc all of the 3 Property-Methods (get*/set*/*Property) but does it only once and the JavaDoc-Tool has an UNDOCUMENTED switch to procude HTML-JavaDoc for all 2 of them.

Now that Eclipse has the source it would not have shown JavaDoc for the methods because it didn’t know about this secret JavaDoc-Feature. We contributed the needed magic to JDT and the JDT-Team accept and polished our contribution.

javadoc

If you look closely to the right you notice that there’s no JavaDoc on all those methods so without the fix in JDT you would have seen fairly no JavaDoc JavaFX-Property accessors.


August 11, 2014

Highlighting Breakpoints Like in Zend Studio 5.5

Looking at the feedback we receive, it seems that lots of our long-time users feel nostalgic to the pre-Eclipse era of Zend Studio. Here is one hint how you can bring the look and feel of the latest Zend Studio a little bit closer to the one experienced with the legendary Zend Studio 5.5.

In Zend Studio 5.5 when adding a breakpoint the complete line was highlighted in pink color. In later releases of Zend Studio this was replaced by the usual way of the Eclipse Platform - a blue bullet appears in the marker area on the left side of the editor's line.


Luckily, this can be configured in the same way it was in Zend Studio 5.5, following these steps:

  1. Call Window > Preferences from the main menu.
  2. Navigate to the General > Editors > Text Editors > Annotations preference page.
  3. Select "Breakpoints" in the list of annotation types.
  4. Select the "Text as" checkbox.
  5. Select "Highlighted" from the drop-down list.
  6. Change the color to #FFC0CB.
  7. (Optional) If you want to remove the blue bullet then deselect the "Vertical ruler" checkbox.
  8. Click the OK button.

Note. You need to upgrade to the latest Zend Studio 11.0.1 Early Access build or wait for the official 11.0.1 release (due in a week) to take advantage of this hint. There was a bug in the PHP editor that prevented breakpoint highlighting in previous releases.

Book “Contributing to the Eclipse Project” published

I’m happy to announce that the final version of the “Contributing to the Eclipse Project” book has been released as paper version.

Contributing to the Eclipse Project

To purchase it, see for example Amazon.com or Amazon.de or see Contributing to the Eclipse Project book page for all possible sources.

A huge thanks to my reviewers: Dirk Fauth, Matthias Sohn, Sopot Çela, Hendrik Still, Thanh Ha, Wim Jongmann, Aurélien Pupier, Holger Voormann and Steven Spungin for their detailed feedback on the content of this book. I’m also very grateful to John Arthone for writing the foreword.

I triggered also the update of the Kindle version, the new version should be available soon to new and existing readers of the ebook version.

Inactive Blogs