Meet the Individuals Responsible for Tasktop’s Customer Journey

by Neelan Choksi at April 17, 2015 04:15 PM

As part of our growth at Tasktop, it has been critical that we add in key leaders to sustain and facilitate that growth into the future. I’m thrilled to be talking about the new group of sales leaders we have at Tasktop and feel privileged to be working with this outstanding group. Tasktop now has new sales leaders for Americas West, East, Central as well as a new leader for pre-sales.

Jamie Wetzel has been promoted from an individual contributor role to lead Americas West. I think I am most proud of this as I love when we promote from within. Now in his 5th year with the company, Jamie has proven throughout his years at Tasktop that he’s been management material by embodying our culture and frankly being a leader before ever being given the title. I think Jamie has single-handedly attempted to enable every person who comes to Tasktop, and I am glad that we are able to reward Jamie with this promotion. Truth be told, I think the company is getting the larger reward.

We recently hired John Kapral to lead our Americas East and Central regions. I love Kap’s experience, having started his career in inside sales and working his way up into sales management in a diverse enterprise software career that has spanned such stalwarts (and in some cases Tasktop partners) as Splunk, CA, Symantec, BMC and CSC. In just over 2 quarters at Tasktop, I am already finding that I am relying on Kap’s experience and expertise with sales management and can see marked improvements in Tasktop’s Go to Market process and sales execution.

I am also thrilled that this past summer, we hired Maury Cupitt to lead our pre-sales engineers. Maury has been involved with pre-sales engineering for much of his career, which included working for Netscape, AvantGo, Wily, CA, and Blue Stripe. One of my favorite things about Maury is that he has brought back and instituted the ALM Architecture diagrams to be part of our pre-sales and post-sales processes – something that was so critical in our early days, helping us plot and flow our customers’ ALM tools and the information that needed to be passed between them.

Lance Knight has been given the tremendous responsibility of managing our post-sales activities as VP of Customer Success. His team is responsible for getting our customers deployed, delivering product-related services for customers, providing post-sales support, conducting customer health checks, teaching our customers through our extremely well-reviewed training courses, and driving our knowledge management assets. Like everything Lance touches, he has embraced the role of Customer Success. Lance likes to remind us that his job title is a bit of a misnomer since we all are responsible for Customer Success. Regardless, I feel very fortunate to have Lance leading this team as Tasktop continues to grow.

Yes, we have great innovative products. But working for a company is about the people. And I am proud to be working at Tasktop because we have an outstanding staff of intelligent, hardworking, self-motivated team members who love to win. If you read this and are excited by what you are hearing and are interested in exploring career options at Tasktop, check out our careers pages or contact us.


by Neelan Choksi at April 17, 2015 04:15 PM

Buildship on the mission to Mars

by Simon Scholz at April 17, 2015 03:00 PM

2286865364_900e1fe74e_z

Gradleware decided to implement their own tooling solution for building project within the Eclipse IDE and the Buildship project was born.

Selection_103

Since march there are currently 123 on the master branch of the GitHub project, which can be found here: https://github.com/eclipse/buildship

We from the vogella company will be working together with Gradleware and hopefully many other contributors as well.

Therefore we started a new tutorial concerning the Buildship project, which will be constantly updated, when new features will be available. See http://www.vogella.com/tutorials/EclipseGradle/article.html
Detailed information can also be found on GitHub: https://github.com/eclipse/buildship

Here is a little impression for you:

gradle_blog_teaser

As I already “println” in the build script, please help us by contributing to the Buildship project. So make your hands dirty, read the tutorial and give the Buildship project a try.

I’d also like to quote Wayne Beaton (Blog entry concerning Buildship):

Great Fixes for Buildship will qualify for the Great Fixes for Mars Skills Competition!

 

 


by Simon Scholz at April 17, 2015 03:00 PM

JBoss Tools Integration Stack - Luna integration tooling for BRMS/BPMS, Data Virt, SOA 5.x + Early Access Fuse and SwitchYard

by pleacu at April 17, 2015 01:19 PM

The Luna tooling train continues! - Adding JBoss Business Process and Rules development tooling to JBoss Data Virtualization and the SOA 5.x suite plus updates to the early access components.

jbosstools jbdevstudio blog header

What’s an Integration Stack?

JBoss Tools Integration Stack 4.2.1.Final / JBoss Developer Studio Integration Stack 8.0.1.GA

The Integration Stack for JBoss Tools Developer Studio is a set of plugins for Eclipse that provides integration tooling for the following frameworks.

JBoss Business Process and Rules Development

  • BPEL Designer - Orchestrating your business processes.

  • BPMN2 Modeler - A graphical modeling tool which allows creation and editing of Business Process Modeling Notation diagrams using graphiti.

  • Drools - A Business Logic integration Platform which provides a unified and integrated platform for Rules, Workflow and Event Processing.

  • jBPM - A flexible Business Process Management (BPM) suite.

JBoss Data Virtualization Development

  • Modeshape - A distributed, hierarchical, transactional and consistent data store with support for queries, full-text search, events, versioning, references, and flexible and dynamic schemas. It is very fast, highly available, extremely scalable, and it is 100% open source.

  • Teiid Designer - A visual tool that enables rapid, model-driven definition, integration, management and testing of data services without programming using the Teiid runtime framework.

JBoss Integration and SOA Development

Note - the SOA Development tooling category has both released and early access components. Consequently, you will see it in both the release install dialog and the early access install dialog.

  • All of the Business Process and Rules Development plugins, plus…​

  • Fuse Apache Camel Tooling - A graphical tool for integrating software components that works with Apache ServiceMix, Apache ActiveMQ, Apache Camel and the FuseSource distributions.

  • SwitchYard - A lightweight service delivery framework providing full lifecycle support for developing, deploying, and managing service-oriented applications.

SOA 5.x Development

  • JBoss ESB - An enterprise service bus for connecting enterprise applications and services.

  • jBPM3 - A flexible Business Process Management (BPM) Suite - JBoss Enterprise SOA Platform 5.3.x compatible version.

All of these components have been verified to work with the same dependencies as JBoss Tools 4.2 and Developer Studio 8.

What’s Been Updated?

Updates have been made to the Business Process tooling (BPMN2 Modeler), Fuse Tooling and SwitchYard. See the JBDSIS 8.0.1 Release Notes

Released Tooling Highlights

BPMN2 Modeler Highlights

Early Access Tooling Highlights

Fuse Tooling Highlights

  • FUSETOOLS-1285: Broken parsing and missing configuration of exchange pattern for ToDefiniton endpoint

  • FUSETOOLS-1271: adding component connectors via context menu broken

  • FUSETOOLS-1269: Node Context Menu>Add option does not include the Components drawer items

  • FUSETOOLS-1268: Cannot view or edit file node in Properties editor after dragging a Filesystem component onto the canvas

  • FUSETOOLS-1267: Properties editor for File endpoint converts relative paths to absolute paths so files are not read

  • FUSETOOLS-1264: JMX Node in servers view doesn’t work if server has secured JMX access via credentials

  • FUSETOOLS-1261: Move connection between components cause problem

  • FUSETOOLS-1260: Cannot run Fuse server with alternate JRE

  • FUSETOOLS-1250: The IDE slows down when a fuse project is deployed

  • FUSETOOLS-1248: Debugger step over resets changed variable value and continues along original path

  • FUSETOOLS-1246: New Server Wizard bug with JMX Bundles plugin only

  • FUSETOOLS-1218: Cryptic error message displayed when trying to connect to Fuse 6.2 server

  • FUSETOOLS-1214: Run Configurations dialog shows launch config types for server adapters for Karaf, SMX, Fuse and Fabric8 which partially don’t work

  • FUSETOOLS-1211: Adding another route to a Fuse Project doesn’t work properly

  • FUSETOOLS-1173: Servers have too many jars on launching classpath

  • FUSETOOLS-1158: fix ugly title when debugging

  • FUSETOOLS-1148: Exception when browsing a BrokerNode in JMX View

  • FUSETOOLS-1138: NPE in karaf server core support after removing a deployed project

  • FUSETOOLS-1123: context id is removed on save

  • FUSETOOLS-1100: New Fuse project does not have properly set-up build-path

  • FUSETOOLS-1085: An endpoint is lost after saving

  • FUSETOOLS-1076: New Server Runtime Wizard - Finish button error

Also see Lars Heinemann’s Blog for more Fuse Tooling insights.

SwitchYard Highlights

The JBoss Tools website features tab

Don’t miss the Features tab for up to date information on your favorite Integration Stack components.

Installation

If you already have JBDSIS 8.0.0 installed…​

Simply start jbdevstudio or eclipse-with-jbds, then:

Select Help > Check for Updates

Select the components you’d like to install from the available updates.

If you’d like a fresh install…​

To install the Integration Stack tools, first install JBoss Developer Studio from the all-in-one installer, bundled and configured out of the box with everything you need to get started. Alternatively, if you already have eclipse-jee-luna installed, you can install JBoss Developer Studio or JBoss Tools from the Eclipse Marketplace via Help > Eclipse Marketplace…​

Eclipse Marketplace - JBDS

Once Developer Studio is installed, restart Eclipse and select the Software/Update tab in the JBoss Central view. The current 8.0.1.GA integration stack is available automatically with the released JBoss Data Virtualization Development tooling. The remainder of the integration tooling is available as Early Access so you must check the Enable Early Access checkbox in the installer window in order to install.

JBoss Central - JBoss Developer Studio Integration Stack
JBoss Central Early Access - JBoss Developer Studio Integration Stack

The standard p2 installer is available for JBoss Developer Studio Integration Stack. Simply start jbdevstudio or eclipse-with-jbds, then:

 Help > Install New Software...
       Add...
       - use this for &aposLocation:&apos for the production integration stack:
         https://devstudio.redhat.com/updates/8.0/integration-stack/
      
       - use this for &aposLocation:&apos for the early-access-components integration stack:
         https://devstudio.redhat.com/updates/8.0/integration-stack/earlyaccess/

The community JBoss Tools Integration Stack installation is easy as well. If you already have eclipse-jee-luna installed, install JBoss Tools from the Eclipse Marketplace via Help > Eclipse Marketplace…​

Eclipse Marketplace - JBoss Tools

Once JBoss Tools is installed, restart Eclipse and select the Software/Update tab in the JBoss Central view. The current 4.2.1.Final integration stack is available automatically with the released tooling. In a manner similar to devstudio, the remainder of the integration tooling is available as "Early Access" so you must check the "Enable Early Access" checkbox in the installer window in order to install.

Select the items you’d like to install:

JBoss Central Early Access - JBoss Tools Integration Stack

The standard p2 installer is available for JBoss Tools Integration Stack. Simply start eclipse-with-jbt, then:

 Help > Install New Software...
       Add...
       - use this for &aposLocation:&apos for the released-components integration stack:
         https://devstudio.redhat.com/updates/8.0/integration-stack/
      
       - use this for &aposLocation:&apos for the early access integration stack:
         https://devstudio.redhat.com/updates/8.0/integration-stack/earlyaccess/

Note: If you installed into your own Eclipse you should bump up the launch resource parameters:

--launcher.XXMaxPermSize 256m --launcher.appendVmargs -vmargs -Dosgi.requiredJavaVersion=1.6 -XX:MaxPermSize=256m -Xms512m -Xmx1024m

Give it a try!

Paul Leacu.


by pleacu at April 17, 2015 01:19 PM

Adding Actions to ToolBar of RCP

by Its_Me_Malai (noreply@blogger.com) at April 17, 2015 01:00 PM


Adding an Action to the ToolBar of an Eclipse Application or RCP. Doesnt that sound really easy. We just need to open up the WorkbenchActionBarAdvisor.java in the application plugin we just build and overried the fillCoolBar(). Like how we write code into fillMenuBar() I would expect to just take the coolBar object and add the action that was created in the makeActions to the coolBar.


But surprisingly that doesnt work. I was amazed and had to reach out to google to figure out why wasnt it working. Then someone pointed that only a toolbarcontributionitem can be added to the toolbar and recommended to look at the Mail RCP that is generated thru the PDE Templates for further information.

I did that out of curiosity and found this code which works.

Then I also understood the background of why I need to create a toolbar in org.eclipse.ui.menus before I can show something on the toolbar.

by Its_Me_Malai (noreply@blogger.com) at April 17, 2015 01:00 PM

Interview with InfoQ on the Internet of Things at Eclipse

by Benjamin Cabé at April 16, 2015 03:21 PM

Benjamin-Cabe

At EclipseCon 2015, I spoke with Alex Blewitt from InfoQ, and gave an update on the cool stuff happening at Eclipse IoT. It is hard to believe that it is only two years since my last interview with Alex – so many new projects and companies involved today!

Check out the interview here.


by Benjamin Cabé at April 16, 2015 03:21 PM

Andmore 0.5-M1 RC2

by kingargyle at April 16, 2015 01:55 PM

Release Candidate 2 is available for smoke testing.   This is mainly some spit and polish to remove the Andmore name from the menus and views, and replace them with more generic labels where it makes sense.

http://download.eclipse.org/andmore/milestone/0.5-M1/

Just add the above to your Install Software, and select the Andmore features to install.  Note that if you have existing ADT projects that you want to work with Andmore, you will need to Configure those to work with the new tooling.  To do so select a project, Configure->Convert ADT project.

If no new big show stoppers are reported by next week, we will do a formal 0.5-M1 announcement with complete change log.



by kingargyle at April 16, 2015 01:55 PM

Reproducible Builds with Docker

by Ian Bull at April 15, 2015 10:52 PM

Wiki’s and Readme files are the most common ways to document a build. While documenting a build is better than not documenting it, Wikis and Readme files have two flaws when used to describe a process: 1) they require humans to read them, and 2) they evolve.

Of course the fact that Wikis evolve is often seen as their biggest strength. However, when trying to reproduce an out-of-date process, up-to-date Wikis are of little help. For example, building J2V8 first requires V8 binaries, and not just any version of V8 either. J2V8 requires V8 version 3.26. Building V8 has changed significantly since 3.26 and the documentation has evolved over time. Finding an accurate set of build instructions — and all the dependencies for V8 3.26 – is a challenge even Stack Overflow can’t help with. Sometimes the documentation was tagged with the release, but setting up a system as it was last year is no easy task. Luckily when we first started this, we recorded the V8 build instructions as a Dockerfile.

docker Reproducible Builds with Docker

By recording a build as a Dockerfile anyone can build your software with a single command. By checking the Dockerfile into your git repository, the build steps for a particular version can be archived forever.

A Dockerfile not only describes the build steps, but also describes the system image required to build the software. This includes toolchain & their versions, libraries, environment variables and even the disk layout.

To experiment with this, clone the J2v8 repository from github and execute docker build from within the v8build directory:

% git clone https://github.com/eclipsesource/J2V8.git
% docker build --rm=true --no-cache -t "eclipsesource/v8-build" .

To make this even easier, the docker build was wrapped in a script that also copies the artifacts from the docker container once the build is completed using the docker cp command:

% docker cp v8build:/data/v8_3_26/out .

The J2V8 Dockerfile

Let’s review the Dockerfile:

FROM ubuntu:14.04
MAINTAINER EclipseSource 

The first line instructs Docker to use Ubuntu:14.04. While V8 may build fine on newer versions of Ubuntu, the key to these instructions is reproducibility, and we’ve done our testing on Ubuntu 14.04. Unless an explicit decision has been made to upgrade the OS, we will stick with this — feature for feature, bug for bug.

# update and upgrade
RUN apt-get update && apt-get upgrade -y && apt-get clean
# install standard toolset
RUN apt-get install -q -y git subversion make gcc bzip2 python g++ libc6-dev-i386 g++-multilib openjdk-7-jdk

A set of system dependencies are then installed — this includes svn (V8 now uses git, but we are building from their historic repo using their old SVN tags). The -y is used so the system doesn’t prompt us during the build.

ADD http://dl.google.com/android/ndk/android-ndk-r10d-linux-x86_64.bin ./
RUN chmod a+x android-ndk-r10d-linux-x86_64.bin
RUN ./android-ndk-r10d-linux-x86_64.bin
ENV ANDROID_NDK_ROOT /android-ndk-r10d

The Android NDK is then fetched, extracted and an environment variable is set.

RUN mkdir /data
RUN cd /data && svn checkout http://v8.googlecode.com/svn/branches/3.26 v8_3_26
ENV CCFLAGS -fPIC
ENV CXXFLAGS -fPIC

The build directory is created and V8 3.26 is cloned. A few GCC flags are then set as environment variables.

# Build
RUN cd /data/v8_3_26 && make dependencies
RUN cd /data/v8_3_26 && make native i18nsupport=off
RUN cd /data/v8_3_26 && make android_arm.release i18nsupport=off
RUN cd /data/v8_3_26 && make android_ia32.release i18nsupport=off

Finally the build is performed. Newer versions of V8 don’t use this approach as a new build tool is now used. However, 3.26 built the dependencies as part of make dependencies target. This build will result in linux bits as well as Android ARM and Android x86.

Go ahead and give it a try. You can even build this on MacOS or Windows by first installing boot2docker. If you run the v8Build.sh script, the results will be copied from the container afterwards. Next I’ll document how I do the J2V8 build.

For more Tips and Tricks on Eclipse, Tabris.js and updates about J2V8, follow me on twitter.


TwitterGoogle+LinkedInFacebook

3 Comments. Tagged with docker, j2v8, v8, docker, j2v8, v8


by Ian Bull at April 15, 2015 10:52 PM

Mozilla pushes - March 2015

by Kim Moir (noreply@blogger.com) at April 15, 2015 02:18 PM

Here's March 2015's  monthly analysis of the pushes to our Mozilla development trees. You can load the data as an HTML page or as a json file.

Trends
The number of pushes increased from those recorded in the previous month with a total of 10943. 

Highlights
  • 10943 pushes
  • 353 pushes/day (average)
  • Highest number of pushes/day: 579 pushes on Mar 11, 2015
  • 23.18 pushes/hour (highest average)

General Remarks
  • Try keeps on having around 49% of all the pushes
  • The three integration repositories (fx-team, mozilla-inbound and b2g-inbound) account around 26% of all the pushes.

Records
  • August 2014 was the month with most pushes (13090  pushes)
  • August 2014 had the highest pushes/day average with 422 pushes/day
  • July 2014 had the highest average of "pushes-per-hour" with 23.51 pushes/hour
  • October 8, 2014 had the highest number of pushes in one day with 715 pushes 






by Kim Moir (noreply@blogger.com) at April 15, 2015 02:18 PM

LiClipse 2.0 released (Nim, Go and Jinja2 supported!)

by Fabio Zadrozny (noreply@blogger.com) at April 15, 2015 11:16 AM

LiClipse just turned 2.0 -- along with PyDev 4.0 :)

The main highlights for this release are: Nim, Go and Jinja2 are now supported.



Multi-page editors (such as the plugins manifest editor) now also have multiple cursors and vertical indent guides support.



The JavaScript editor had improvements in the syntax highlighting and its code-formatting settings can now be tweaked (http://www.liclipse.com/customize_javascript.html has more details).

Different jshint.js and beautify.js files may be specified in preferences > LiClipse > JavaScript.

From this release onwards, besides providing standalone binaries and a downloadable update site, LiClipse provides an actual online update site: http://update.liclipse.com/latest -- note that I still recommend users to use the standalone as it's easier to get started and it also provides updates to the underlying eclipse SDK, but the update site is now available if you have a working Eclipse version which you don't want to change.

This was also the first time where I transferred some technology from LiClipse to Eclipse (to make improvements so that the trees in the dark theme in Eclipse on Windows actually have arrows you can work with: https://bugs.eclipse.org/bugs/show_bug.cgi?id=434201 -- and hopefully I'll still be able to make time to integrate another one to improve the selections on trees/tables for the next Eclipse release: https://bugs.eclipse.org/bugs/show_bug.cgi?id=434309).

A note for existing users: a renew license currently has a 50% discount over the price of a full license http://www.liclipse.com/buy.html -- thank you for helping in keeping LiClipse going strong!



by Fabio Zadrozny (noreply@blogger.com) at April 15, 2015 11:16 AM

Refine diagrams with interpolated colors

by Steve Monnier at April 15, 2015 08:32 AM

This article is part 4 of a series covering cool features of Sirius and tips to create advanced modelers. See http://melb.enix.org/category/sirius/ for the complete series.

Today we will present how diagrams can be refined to display information using interpolated colors.

Diagrams with meaningful colors

In your Viewpoint Specification Model (VSM), the specifier is not limited to use the provided colors but can define a palette with custom colors. A color can be defined using a RGB code (Red/Green/Blue).

However, using this new color in a mapping will paint every mapping candidates to this color. As our goal is giving colors a meaning, it needs to be defined by an expression. Sirius provides two solutions: Computed Colors and Interpolated Colors.

Note that RGB codes are defined with three integer values between 0 and 255. If the value is over 255, Sirius will use it as a 255 value.

Diagrams with computed colors

Computed colors are alike RGB Colors but instead of choosing an int value for the Red/Green/Blue fields, an expression will be given.

On this sample the color is computed depending on the depth of the package to represent. As this information is far from a RGB value transposition, the expressions are unfortunately not really natural to write. The Interpolated Colors will offer a more natural conversion.

Diagrams with interpolated colors

An Interpolated Color is defined by an expression and several Color Steps. The expression should return an integer value. Here is an example where the expression calculate the depth of the current element using the ancestors() service.

A Color Step is the association of a color and an integer value. Note that the color selection is not limited by the provided color, but can also be a custom color. In this sample, the selected colors are RGB Colors.

Depending on the return value of the expression, a color will be created between the defined Color Steps. As close the return value is of a Color Step, as close the result color will be to this Color Step.

On the previous example, the interpolated was used in order to display EPackage element with a graduation of color depending on the depth because both steps where different tint of a similar color. Of course, the Color Steps can be of different colors and the number of steps is not limited.
On the next example, we want to present the EPackage again but this time the yellow color graduation will depend on the number of contained EClasses. Moreover, we decide that for future refactoring/cleaning purpose, the empty EPackage should be white. Furthermore, the recommended EPackage size is between one and eight EClasses and should be displayed yellow with a tint darker the more contained EClasses there are. Twelve or more EClasses is seen as too many and should be displayed as red. To represent this as an Interpolated Color we have:

  • An expression computing the contained Eclasses number: [eContents()->filter(EClass)->size()/];
  • A first color step defined as white for value 0;
  • A second color step defined as light yellow for value 1;
  • A third color step defined as dark yellow for value 8;
  • A fourth color step defined as red for value 12.

On this sample:

  • p1121 and p1123 are empty and displayed as white;
  • p112 has 1 EClass and is displayed as light yellow;
  • p1 has 3 EClasses and is displayed as a slightly darker yellow;
  • p111 has 8 EClasses and is displayed as dark yellow;
  • p1122 has 10 EClasses and is displayed some kind of orange/brown as a result of beeing a mix of dark yellow and red;
  • p12 has 16 EClasses and is displayed as red.

Interpolated colors are an easy way to display meaningful information and an alternative from text display. Furthermore it can produce beautiful diagrams using nice colors that can be created using simple tools like www.colourlovers.com or colourco.de.

The sample code from this example is available on github: https://github.com/mbats/sirius-blog/tree/master/interpolated-colors


by Steve Monnier at April 15, 2015 08:32 AM

Devoxx France 2015 – Building the Internet of Things with Eclipse IoT

by Benjamin Cabé at April 14, 2015 12:50 PM

Last week I gave a presentation at Devoxx and shared the floor with my esteemed colleague Wayne Beaton. While he covered some of the very cool feature being baked into the Eclipse IDE for the upcoming Mars release, I did talk about the Eclipse IoT technology portfolio, in particular what is available for Java Developers.

Check out the slides below, and expect the video recording to be made available shortly on Parleys, too.


by Benjamin Cabé at April 14, 2015 12:50 PM

Open IoT Challenge: Winners announced

April 14, 2015 08:48 AM

This has been a difficult call, but we are happy to finally be able to announce the three winners of our Open IoT Challenge!

April 14, 2015 08:48 AM

Screenshot of the Week: Markdown Editor

by waynebeaton at April 13, 2015 04:25 PM

You can edit Markdown, along with other types of wiki markup, directly in Eclipse. Here’s a screenshot of the Markdown editor in action:

Edit Markdown directly in Eclipse

Edit Markdown directly in Eclipse

Note the “Preview” tab which will show you what the page looks when rendered.

This support is provided by the Mylyn Docs project’s WikiText component. You can also edit Confluence, MediaWiki, Textile, TracWiki, and TWiki formats. There’s a patch in the works to add AsciiDoc support as well.

WikiText is included in the Eclipse IDE for Java Developers and other packages.



by waynebeaton at April 13, 2015 04:25 PM

Manage all the things, small and big, with open source LwM2M implementations @ FOSDEM 2015

by Benjamin Cabé at April 13, 2015 03:03 PM

Here is the recording of my presentation on Device Management with LwM2M at FOSDEM’15.

Abstract: LwM2M is a standard for device management that solves many of the issues M2M and IoT solutions makers have faced in the past (or, let’s be realistic, are still facing), with custom protocols or even standards like OMA-DM: complex workflows, high bandwidth usage, lack of open-source implementations… Join this talk to get an overview of the LwM2M protocol, and to learn how you can start managing an embedded device with Eclipse Wakaama (yes, it fits in an Arduino, and yes, there will be a live demo!), or build your own device management server with Eclipse Leshan.


by Benjamin Cabé at April 13, 2015 03:03 PM

Collaborative Modeling with Papyrus, EMF Compare and EGit

by Maximilian Koegel and Jonas Helming at April 13, 2015 10:04 AM

The collaborative modeling initiative is a joint effort in providing a high-quality, open-source tool that supports efficient collaboration and teamwork on EMF-based and Papyrus UML models. To achieve this we will leverage model comparison as well as merge functionality based on EMF Compare and distributed model versioning support based on EGit.

Important questions in this regard are, of course, how does a simple workflow of collaborative modeling look and how does it work in the actual tools? We try to answer these questions in a video tutorial including explanations to basic git concepts that are important for the workflow.

If you are interested in this initiative, follow us on Google+, get more information on the web page or contact us for more information!


TwitterGoogle+LinkedInFacebook

Leave a Comment. Tagged with egit, emf, EMF Compare, Papyrus, egit, emf, EMF Compare, Papyrus


by Maximilian Koegel and Jonas Helming at April 13, 2015 10:04 AM

Little trick with SWTBotTree manipulation if it returns an IllegalArgumentException

by aurelien.pupier at April 13, 2015 08:02 AM

I came across a strange issue with manipulating SWTBotTree, and it took me few hours to find a workaround. I found no exact match with my issue during my research, so let's keep a trace here while waiting for a better understanding of the issue and a fix in SWTBot.

The issue

In a SWTBot Test, calls to SWTBotTreeItem.contextMenu() or SWTBotTreeItem.select() might lead to the following exception:

  1. Caused by: java.lang.IllegalArgumentException: Argument not valid
  2. at org.eclipse.swt.SWT.error(SWT.java:4422)
  3. at org.eclipse.swt.SWT.error(SWT.java:4356)
  4. at org.eclipse.swt.SWT.error(SWT.java:4327)
  5. at org.eclipse.swt.widgets.Widget.error(Widget.java:476)
  6. at org.eclipse.swt.widgets.Tree.setSelection(Tree.java:4986)
  7. at org.eclipse.swt.widgets.Tree.setSelection(Tree.java:4948)
  8. at org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem$10.run(SWTBotTreeItem.java:362)
  9. at org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable$4.doRun(UIThreadRunnable.java:196)
  10. at org.eclipse.swtbot.swt.finder.finders.UIThreadRunnable$1.run(UIThreadRunnable.java:89)

Quite an obscure message... what is happening? How can I solve my issue?

The workaround

Easily applicable - but hard to guess - the workaround consists of simply calling SWTBotTree.setFocus() before manipulating the SWTBotTree. For instance:

  1. final SWTBotTree tree = bot.tree();
  2. tree.setFocus();
  3. final SWTBotTreeItem cssNodeFile = tree.expandNode("application", "css", "bonita_form_confirm.css");
  4. cssNodeFile.contextMenu("Open").click();

Technical details

If we look closer in Tree.setSelection method , the exception is due to a disposed TreeItem:

  1. TreeItem item = items [0];
  2. if (item != null) {
  3. if (item.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
  4. ...
  5. }

The thing which is strange is that the SWTBotTreeItem is calling setFocus before calling the setSelection, as you can see here in SWTBotTreeItem.select():

  1. public SWTBotTreeItem select() {
  2. assertEnabled();
  3. syncExec(new VoidResult() {
  4. public void run() {
  5. tree.setFocus();
  6. tree.setSelection(widget);
  7. }
  8. });
  9. notifySelect();
  10. return this;
  11. }

If someone understands the issue better than me, please share your ideas in the bug report: https://bugs.eclipse.org/bugs/show_bug.cgi?id=458975


by aurelien.pupier at April 13, 2015 08:02 AM

How to hot reload Java script-like source for e.g. plug-ins through isolated ClassLoader/s

by Michael Vorburger (noreply@blogger.com) at April 12, 2015 04:50 PM

When my son asked me why he had to restart the local Minecraft server for every change made to his first "Mod" (Java-based Minecraft Plug-In), he got me thinking about modularity and hot reloading in Java. As I looked around a bit, I could not find any modern pragmatic and very simple Java Modules/Plug-In mini framework with HOT Class reloading to support dynamic script like source code that I liked - so I built one, check it out this in this demo video:



PS: Specifically related to Minecraft modding, ScriptCraft uses JavaScript interpretation to achieve a similarly "dynamic" experience (no Server restart required) - but do you really want your kid to get introduced to programming using JavaScript? ;-)

by Michael Vorburger (noreply@blogger.com) at April 12, 2015 04:50 PM

Eclipse Hackathon Hamburg – 2015/04/24

by eselmeister at April 12, 2015 11:33 AM

Folks,

the next Eclipse Hackathon will be in Hamburg, Germany soon :-). Feel free to join:
https://wiki.eclipse.org/Hackathon_Hamburg_2015_Q2


by eselmeister at April 12, 2015 11:33 AM

Eclipse-Databinding for Vaadin

by Florian Pirchner at April 10, 2015 04:13 PM

A while ago we (Lunifera GmbH) have implemented Eclipse-Databinding for Vaadin. Two different databinding approaches that perfectly work together.

In this blog i’d like to talk about the two different ways of databinding and how these worlds can be tided together.

Vaadin comes with an integrated databinding capability. Databinding in Vaadin means, that UI elements (components) are bound to so called containers, items and properties. So the data of components can be abstracted from the component itself. But Vaadin defines no common way to bind these containers, items and properties to each other.

There the eclipse databinding comes into play. Eclipse databinding provides a common way to bind so called “observable values” to each other. An “observale value” is an abstraction above the “data related to its source”. Eclipse databinding comes with an implementation for POJOs, Beans (POJOs with PropertyChangeSupport), SWT-Widgets, JFace-Components, EObjects (Eclipse Modeling Framework – EMF) and the EMF-Edit-Commands. These implementations allow you to bind “observable values” from different domains (one of mentioned implementations) to each other.

In combination Vaadin databinding and Eclipse databinding are working properly together.

Vaadin Databinding

Vaadin databinding consists of 3 concepts for different use cases:

  • Property – An abstraction for a type and value. Used to bind fields like TextField to the property
  • Item – A collection of properties. It represents a row in a table. Each property inside the item has a unique propertyID
  • Container – A collection of items. It represents a data-table. Each item inside the container has a unique itemID

Property, Item and Container are expressed by interface. And Vaadin comes with a lot of proper implementations for different usecases.

datamodel-sml

Image: “Book of Vaadin 8.1″ – Copyright 2015 Vaadin Ltd [1].

Property

// Create a property
ObjectProperty property =
    new ObjectProperty("Florian", String.class);
        
// Create a text field
TextField nameField = new TextField("Firstname");
        
// Bind nameField to data
nameField.setPropertyDataSource(property);

See also: “Book of Vaadin 8.2.1″

As soon as the property is set to the field, you may use the property to read and write values.

Item

Dealing with items is really similar to properties.

PropertysetItem item = new PropertysetItem();
item.addItemProperty("firstName", new ObjectProperty("Florian"));
item.addItemProperty("age", new ObjectProperty(36));
        
// create a form
Form form = new Form();
form.setItemDataSource(item);

See also: “Book of Vaadin 8.3.1″

In this case an item is prepared and set to a form. Forms are special components that show defined properties of the given item.

There are different ways to define items. The example above uses a PropertysetItem which allows you to define all properties manually. But there are also more comfortable way for pojos.

// Create an instance of the bean
Person bean = new Person();
        
// Create a bean item configured for type Person.class
BeanItem<Person> item = new BeanItem<Person>(bean);

// Set the item to the form
Form form = new Form();
form.setItemDataSource(item);

Sample: “Book of Vaadin 8.3.2″
To automatically create an item for a bean, that holds each bean-property, you just may use the BeanItem.

Container

// set a personContainer to the table
Table table = new Table("Persons");
table.setContainerDataSource(personContainer);

See also: “Book of Vaadin 8.5″

For containers there is also a generic way to define the container properties (the columns of the container). And also a lot of very useful implementations like the BeanContainer or BeanItemContainer. Based on the JPAContainer you can connect your Vaadin components to JPA really quickly.

For details about BeanItemContainer see: “Book of Vaadin 8.5.4″

Eclipse Databinding

The Eclipse databinding follows a more general way and tries to abstract bindings in general.

Unbenannte Zeichnung (1)If you would like to use Eclipse databinding, you have to deal with some concepts.

  • ObservableValue (ObservableList) – it is defined by an interface and is an abstraction above a data-endpoint.
  • UpdateValueStrategy – defines how source-to-target and target-to-source updates will be processed.
  • Binding – binds the observable values (or lists) to each other. BindingStrategy can be used.
  • DatabindingContext – It is a common state for all contained bindings.
  • Realm – It is responsible to synchronize updates with the environment

Observable Values

Similar to the Vaadin databinding, an obervable value defines the type and value the instance deals with. The observable value knows how to access the underlying “target-element”. This “target-element” may be anything, as far there is an implementation for it. For now the”target-element” may be a pojo, a bean, an EObject, a SWT-widget,… The observable value will register all required listeners at the “target-element” to get notified about changes. If the value of the “target-element” is changed, then the “obervable value” will notify the Binding, which updates the value at the opposite side of the Binding.

UpdateValueStrategy

The UpdateValueStrategy may be used to define how values are updated.They can be defined for “source-to-target” and “target-to-source” updates. The UpdateValueStrategy is also responsible for data conversion.

It comes with 3 policies:

  • POLICY_NEVER – Values in the “observable value” will never be transferred to the opposite end of the binding.
  • POLICY_ON_REQUEST –  Values in the “observable value” will only be transferred to the opposite end, if requested by a method call.
  • POLICY_UPDATE – If the “observable value” becomes notified about changes in the “target-element”, then the value will be automatically transferred to the opposite of the binding.

ValueBinding

The ValueBinding connects the Source-ObservableValue to the Target-ObservableValue according the UpdateValueStrategy-Policy. It also offers methods to validate and update model-to-target or target-to-model (Model is a synonym for Source) operations.

DatabindingContext

The databinding context manages all bindings. Also List- and Set-Bindings. The granularity about the instances of DatabindingContexts depends on the underlying application. In general i would say, that all bindings that should be validated in a common context, should be added to the sames context. If you have different views as part of your system, each view may get its own context. But it depends on you.

Lifecycle

When you are using Eclipse databinding, you need to be aware about its lifecycle. If a view is closed, a timeout occurs,… you must ensure, that the databinding context is #disposed(). There is a method for it. Otherwise the Vaadin components will receive value updates, even if the UI is already closed.

Realm

For instance if you are doing a long running operation as an async operation in a different thread and you expect that the async operation updates your UI properly, you need a way to sync your UI with this thread. In SWT you have to update the UI in the SWT-Ui-Thread. In Vaadin you need to call UI#access(…).

The realm is specific for each databinding implementation. The source- and the target-observable-values may have their own Realm. So it would be possible to bind a SWT-UI to a Vaadin-UI. I never tried to do so, but i am pretty sure, that it will work properly.

Eclipse-Databinding for Vaadin

We have prepared an eclipse databinding implementation for Vaadin. You can find it in this github-repo. There is also a P2-Updatesite located here: Lunifera-P2-Repo.

Realm-Activation

Before you create the DatabindingContext, you need to activate the Realm for VaadinDatabinding.

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Even if you would like to add new Bindings in a different Thread, you need to activate the realm. Otherwise databinding does not know anything about the current UI-instance.

In real projects you won’t have to call the activation on certain places again and again. So there is a perfect place to do so.

You have to override the VaadinServletService and add following method:

public UI findUI(VaadinRequest request) {
	UI instance = super.findUI(request);

	// activate the realm for the current ui and thread
	VaadinObservables.activateRealm(instance);

	return instance;
}

Then every time, Vaadin is looking for the current UI-instance, the realm will be activated automatically.

 

 

Examples

Now lets start with some examples demonstrating how to use the eclipse databinding for Vaadin.

1 Binding components –> #value

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();
	
// Create the Vaadin components
TextField sourceField = new TextField();
sourceField.setImmediate(true);
Label targetField = new Label();
	
// Create the observable values
IObservableValue sourceOV = VaadinObservables.observeValue(sourceField);
IObservableValue targetOV = VaadinObservables.observeValue(targetField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the value of the textField to the value of the label. If the value of the textField changes, the label is updated.

2 Binding components –> #enabledState

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// Create the Vaadin components
CheckBox checkbox = new CheckBox();
checkbox.setImmediate(true);
TextField textField = new TextField();
		
// Create the observable values
IObservableValue sourceOV = VaadinObservables.observeValue(checkbox);
// observe the enabled state of the textfield
IObservableValue targetOV = VaadinObservables.observeEnabled(textField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the value of the checkBox to the enabled property of the textfield. If the checkbox is checked, then the textField is enabled. Otherwise it is disabled.

3 Bind components to beans

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Person person = new Person();

// Create the text field
TextField textField = new TextField();
textField.setImmediate(true);

// Create the observable values
IObservableValue sourceOV = BeansObservables.observeValue(person, "firstname");
IObservableValue targetOV = VaadinObservables.observeValue(textField);

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

This sample binds the “firstname”-property of the given bean to the value of the text. If the value of the textField or the value of the bean changes, then the change is updated at the opposite site.

4 Reuse the Vaadin property

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

Person person = new Person();

// Create the text field
TextField textField = new TextField();
textField.setImmediate(true);
textField.setPropertyDatasource(new ObjectDatasource());

// Create the observable values
IObservableValue sourceOV = BeansObservables.observeValue(person, "firstname");
textField.setPropertyDataSource(new ObjectProperty<String>("", String.class));

// bind the values to each other
dbc.bindValue(sourceOV, targetOV);

In this sample, an ObjectProperty was set to the textField. The Vaadin databinding implementation internally tries to get the property datasource before binding. If it is available, then the property will be bound. Otherwise the field itself is bound. So it is your choice whether you want to work with properties or not.

5 Bind the multiselection of table-1 to the input of table-2

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// Create the Vaadin components
Table table1 = new Table();
table1.setMultiSelect(true);
table1.setImmediate(true);
Table table2 = new Table();

// observe the multi selection
IObservableList table1OV = VaadinObservables.observeMultiSelectionAsList(table1, Person.class);
// observe the content
IObservableList table2OV = VaadinObservables.observeContainerItemSetContents(table2, Person.class);
	
// bind the values to each other
dbc.bindList(table1OV, table2OV);

This sample binds the multi-selection of table1 to the input of table2. So table2 shows the selected items of table1. Note, that this kind of binding uses ObservableLists.

 

6 Bind a table to a WritableList

// Activate the realm
VaadinObservables.activateRealm(this);

// Create databinding context
DataBindingContext dbc = new DataBindingContext();

// create a table
Table table = new Table("Persons");
layout.addComponent(table);
table.setContainerDataSource(new BeanItemContainer<Person>(
			Person.class));
		
// create a writable list as model
final WritableList model = new WritableList();
		
// observe the table container content
IObservableList tableOV = VaadinObservables
		.observeContainerItemSetContents(table, Person.class);

// bind the lists to each other
dbc.bindList(model, tableOV);

// create a button to add records
Button button = new Button("Add person");
layout.addComponent(button);
button.addClickListener(new Button.ClickListener() {
	@Override
	public void buttonClick(ClickEvent event) {
		Person person = new Person();
		person.setName("My first name");
		person.setName2("Another name");
		person.setAge(43);
		person.setBirthday(new Date());
		model.add(person);
	}
});

This sample binds a WriteableList as a model to the container contents. If a Person is added to the model, the table will update it’s contents.
The Button is used to add new records to the model.

7 Bind a table to a nested list in a bean or pojo

// Activate the realm
VaadinObservables.activateRealm(this);

final DataBindingContext dbc = new DataBindingContext();

// create a table
Table table = new Table("Persons");
layout.addComponent(table);
table.setContainerDataSource(new BeanItemContainer<Person>(Person.class));

// create the model
final Person father = createPerson("Father", 43);
father.addToChildren(createPerson("Child 1", 17));
father.addToChildren(createPerson("Child 2", 19));

// observe the table container content
IObservableList tableOV = VaadinObservables
		.observeContainerItemSetContents(table, Person.class);
// observe the nested children list
IObservableList childrenOV = BeansObservables.observeList(father,
		"children", Person.class);

// bind the lists to each other
dbc.bindList(tableOV, childrenOV);

// create a button to add records
Button button = new Button("Add person");
layout.addComponent(button);
button.addClickListener(new Button.ClickListener() {
	@Override
	public void buttonClick(Button.ClickEvent event) {
		Person person = new Person();
		person.setName("Child 3");
		person.setAge(23);
		father.addToChildren(person);
		// Update the targets
		dbc.updateTargets();
	}
});

This sample binds a nested children list located in Person.class as a model to the container contents. The Button is used to add new records to the model.

Attention: If a person is added to the children list of the bean, the table is not updated automatically. This happens since the PropertyChangeSupport does not really support notifications for changed collections. So you need to call dbc.updateTargets() or binding.updateModelToTarget().
If you are using the Eclipse Modeling Framework, then also changes in Sets and Lists are automatically transferred to the table, since EMF can deal with notifications for collection changes.

Attention2: If the person bean does not provide PropertyChangeSupport, then you need to use PojoObservables#observeList to create the model observable.

 Conclusion

With “Eclipse Databinding for Vaadin” can bind Vaadin components to other components, beans, pojos,… very quickly. The databinding implementation ensures, that values are treated properly. Using “Eclipse Databinding for Vaadin” developers can save a lot of lines of code.

See also

The examples in these additional sources may also be used for the “Eclipse databinding for Vaadin”. The core concepts are always the same.

[1]  Copyright 2015 Vaadin Ltd, licensed under a Creative Commons CC-BY-ND License version 2.0



by Florian Pirchner at April 10, 2015 04:13 PM

Hear about the results of the IoT Developer Survey & celebrate the IoT Day with Eclipse IoT

by Eclipse Foundation at April 09, 2015 03:36 PM

We have been collecting interesting data on the current trends in IoT, and we want to celebrate the Global IoT Day with you all and share some of our key (and sometimes surprising) findings.

by Eclipse Foundation at April 09, 2015 03:36 PM