Ian is an Eclipse committer and EclipseSource Distinguished Engineer with a passion for developer productivity.
He leads the J2V8 project and has served on several Eclipse technical committees.
Ian holds a Bachelor and Master’s degree from the University of Waterloo and a PhD from the University of Victoria.
I have started writing about my experiences with Kubernetes and the PicoCluster. The PicoCluster is a set of inexpensive boards (10 Rock64 boards in my case), housed in a single cluster with a network adapter, fan and power supply. They have been pre-configured with Ubuntu and Kubernetes. The cluster is in my basement, plugged directly into my router.
In this article, we will look how we used the GitHub API for querying users and repositories of an organization. In particular, we will look at how promises were combined to make the data retrieval easier.
Cloud native, highly available, web-scale, coordinated containerized applications! Wow, that’s a mouthful, but what does it mean?
Ok, it’s not one of the two hardest problems in Computer Science, but adding authentication to your web-based application is non-trivial. In addition to the security concerns involved, you are also required to maintain account information, registration, and identity management, which most users are tired of. Nobody wants Yet Another Password To Remember (YAPTR).
JavaScript has been used as a client side language for over 20 years and as a server side language for close to 10. In the past 3 years, JavaScript has emerged as a language of choice for mobile app developers, especially those looking for a cross-platform solution. Technology stacks such as React Native and Tabris.js are the obvious choices, but some engineers are rolling their own runtimes with tools such as J2V8.
In preparation for the Tabris.js 2.0 release, we started counting down the 10 features of Tabris.js 2.0 that we’re most excited about. We reached the halfway point, which means that the release is almost here and we have 4 features left to go. Feature Number 6: Binary Fetch is a pretty exciting technical feature, especially for me because it required the implementation of shared memory regions in J2V8; but first, what is Binary Fetch.
After over a year of development, Tabris.js 2.0 is almost here. To help celebrate this, the Tabris.js development team is counting down some of the features we’re most excited about.
AES (Advanced Encryption Standard) is a symmetric-key encryption algorithm. Symmetric-key algorithms are algorithms for cryptography that use the same cryptographic keys for both encryption of plaintext and decryption of ciphertext. In this tutorial we will demonstrate how to encrypt plaintext using the OpenSSL command line and decrypt the cipher using the OpenSSL C++ API.
Code signing and verification is the process of digitally signing executables or scripts to ensure that the software you are executing has not been altered since it was signed. I previously outlined how to perform code signing and verification with OpenSSL, using both the command line and OpenSSL API.
Tabris.js is a cross platform mobile toolkit that enables application developers to target multiple platforms from a single JavaScript code base. Unlike some other cross-platform toolkits, Tabris.js does not rely on WebViews, but instead produces native applications. This is achieved by providing a cross-platform API in JavaScript and linking that API to the platform specific widgets. Additionally, Tabris.js also includes a build service. This service enables our users to easily produce mobile apps (apks and ipas) by simply linking their GitHub repository to the service.
Code signing and verification is the process of digitally signing executables or scripts to ensure that the software you are executing has not been altered since it was signed. Code signing helps protect against corrupt artifacts, process breakdown (accidentally delivering the wrong thing) and even malicious intents. We have recently started implementing code verification in J2V8. Code verification has been implemented in the native code using OpenSSL.
Mobile software development is hard. Before you can even write your first line of code you must: download, install and configure the IDEs and SDKs, configure the emulators or connect a device to your machine, build the application archives (apks / ipas) and install these archives on your device. With Tabris.js we set out to eliminate most of the technical hurdles users face when developing mobile applications.
I returned home late the other night, and saw this tweet in my timeline:
Memory management in J2V8 has never been easy. Because J2V8 bridges V8 and Java, three different memory models are in play. Both Java and JavaScript provide a managed memory model with their own GC. JNI / C++ which sits in the middle is completely unmanaged. This leads to a complex situation since both JavaScript and Java will free memory if they think it’s unused, but have no knowledge of each other. To manage this, J2V8 puts the onus on the Java developer to specify which objects should be kept and which objects can be released.
When J2V8 was first released, all callbacks from JavaScript to Java required a registered Java method. That is, all Java methods that you wished to invoke had to be first registered with J2V8. For some applications this was fine, but it made for a complex programming model. Furthermore you could not use anonymous inner classes or Java 8 lambdas. With J2V8 4, this has changed.
Last week I finally published the Node.js bindings for Java. These bindings allow developers to embed the Node.js runtime directly onto the JVM through the Java Native Interface. In March I gave a pre-release presentation at EclipseCon on this work, which was recorded by InfoQ.
When J2V8 was first released, all Java characters passed between Java and V8 were converted to 8bit C-Style strings. For many applications this was just fine, but if your JavaScript contained 16 bit Unicode characters, then you were hosed.
J2V8 provides the technology to link V8 and Node.js with the JVM. Using JNI, Java developers can directly call V8 and Node.js APIs. This seamless integration brings improved JavaScript performance, NPM modules and the Node.js APIs to the Java ecosystem. An alternative approach could have been to invoke two separate processes (Java and Node.js) with a service protocol between them. However, one of the advantages of the single process approach is the ability to share memory between JavaScript and Java. In this article we will explore how we use TypedArrays to provide a shared memory space between V8 and the JVM.
After over a year of development, I am very excited to announce that J2V8 4 is publicly available on all supported platforms. J2V8 is a set of V8 bindings for Java. This means that you can embed V8 (Google’s ultra fast JavaScript engine) into your Java applications. J2V8 4 is built on Node.js, which means you can also integrate Node.js with the JVM (On Windows, Mac and Linux).
Gone are the days of single vendor lock-in, where one technology stack is used across an entire organization. Even small organizations and hobbyists will find themselves mixing technologies in a single project. For years, Java reigned king on the server. Today Node.js is everywhere.
Symmetric cryptographic algorithms are algorithms that use the same key for both encryption and decryption. That is, a Code + Key will produce a Cypher, and the Cypher + Key will produce the Code.
Tabris.js was designed to help developers build native cross-platform apps using a single JavaScript codebase. We offer many tools to boost efficiency - like the Tabris.js developer app and the cloud build service. With Tabris.js 1.8 we’ve introduced a new enhancement that will make a major difference when it comes to getting things done - an interactive debugger.
Earlier this year Microsoft released ChakraCore – their powerful next generation JavaScript engine – as an OpenSource project under an MIT license. Microsoft also announced that they would be integrating Chakra with Node.js on Windows.
The best way to predict the future is to invent it
Just in time for Christmas, J2V8 3.1 is now available. It ships as standard JAR from Maven Central, an Android Archive (AAR) for your Android developer friends, and now as an OSGi bundle. Here is the official New and Noteworthy for J2V8 3.1.
J2V8 is a set of Java Bindings for V8. I’m happy to announce that with the 3.1 release, we now ship J2V8 as an OSGi bundle. This means that you can easily use J2V8 on your favourite OSGi runtime, or as an Eclipse plugin. To make it even easier to consume, we’ve also made J2V8 available in a p2 repository. Because J2V8 contains native code (and a copy of V8), there are several bundles available – one for each available platform.
October 2015 marked my 7th anniversary with EclipseSource. For s_even__years I’ve been working remotely for an amazing company!_ For those of you who don’t know me, I live and work in Victoria British Columbia (Canada), an 18 hour trip – across 9 time zones – to the EclipseSource headquarters in Karlsruhe (Germany), where most of my team works. Obviously I don’t make this commute very often.
J2V8 enables developers to embed Google’s V8 JavaScript engine in their Java applications. V8 is entirely implemented in C++ and we enable this embedding by creating a thin JNI (Java Native Interface) layer which exposes the V8 API to Java. The very first problem we faced while implementing this was how do you reference C++ objects from Java?
We built J2V8 to bring highly performant JavaScript to Java in general, and to the Android platform in particular. By exposing Google’s V8 JavaScript API in Java, developers can now embed V8 into their Java applications on Windows, Linux, MacOS and Android. The approach has worked very well both for Tabris.js as well as many other consumers of J2V8.
Like many other operating system vendors, Microsoft provides a store from which users can install apps from. Stores such as the Apple App Store, the Google Play Store, and the Windows Store make it very easy for users to discover and install content. Like traditional marketplaces, app stores provide a number of advantages to both consumers and producers, but also like traditional marketplaces, the rules and regulations can sometimes be hindrance.
One of the most common mobile views for displaying information is the collection view. The collection view is a scrollable list often used for presenting data as a series of rows and has been part of Tabris.js since the beginning. Previously Tabris.js required that all rows be styled the same, but with Tabris.js 1.1 you can now style each item separately.
J2V8 is a set of Java bindings for V8. J2V8 brings the V8 API to Java developers. We developed J2V8 to help with the performance of Tabris.js, our cross-platform, mobile development toolkit.
Last month I spent 10 days in Germany. I spent time at the EclipseSource headquarters in Karlsruhe, where I enjoyed schnitzel, good beer and a few strange sights.
Eclipse Mars is here! Over the past 10 days I’ve been counting down the Top 10 Eclipse Mars features I’m most excited about.
By this time tomorrow, Eclipse Mars will have shipped. We will be enjoying many of the new features including improved Git support, docker tools, and a number of Java tool enhancements. But before Eclipse Mars ships, I still have two more entries in my Eclipse Mars 10 Top Features list.
After 12 months of work, almost 80 projects, 380 committers, 352 contributors, and 65 million lines of code, we’ve finally arrived at Eclipse release week. Eclipse will ship on Wednesday June 24th, and that means we’ve arrived at the Top 3 Features in my annual Eclipse Top 10 List.
Eclipse Mars is just around the corner. As the Eclipse team is hard at work putting the finishing touches on everything, I’m traveling Europe, presenting about Tabris.js and J2V8 and counting down the Top 10 Eclipse Mars features I’m most excited about.
Eclipse Mars will ship on Wednesday June 24th. While Eclipse can be used for C, C++, JavaScript, PHP and many other languages, many people still consider Eclipse a Java IDE, and a pretty darn good one too. As we inch closer to the release, and I continue my countdown of the Top 10 Eclipse Mars features, we finally come to Java improvements.
Eclipse Mars ships in 1 week, and that means that we are at the half-way point in my Eclipse Mars Top 10 List. Number 6 on my list is a feature that’s been in development for a while now and long overdue. In 2012 Eclipse launched a new application model called e4. The application can be designed through a series of UI models, styled using CSS and dependencies are managed via DI.
With just over one week until Eclipse Mars ships, I’ve been counting down the Eclipse Features I’m most excited about.
We all hate waiting! The good news is that Eclipse Mars is only 1 1/2 weeks away and to help you while you wait for this great release, I’m reviewing the Top 10 Eclipse Mars features that I’m most excited about.
As we push towards Eclipse Mars I’ve started my annual tradition of counting down the Top 10 Eclipse Features that I’m most excited about. Number 9 on my list is Platform Improvements.
10 Years ago, while studying at the University of Victoria, I developed Zest: the Visualization Toolkit for Eclipse. The goal of the project was to define APIs and Eclipse based implementations for a visualization library. 10 Years ago I attended my first EclipseCon. Back then I didn’t know Doug Schaefer, nor did I know about the EclipseCon late night… now it appears Doug and I are responsible for locking up. 10 years ago I had hair. 10 years ago I became an Eclipse committer.
J2V8 is a set of Java bindings for Google’s popular JavaScript engine, V8. It was developed to bring highly efficient JavaScript to Android and is the workhorse behind Tabris.js. J2V8 also runs on Windows, Linux and Mac OS. In the previous tutorial we looked at how to execute JavaScript using J2V8. In this tutorial we will demonstrate how to register Java callbacks with J2V8. Java callbacks allow JavaScript to invoke Java methods.
J2V8 is a set of Java bindings for the popular V8 JavaScript engine. In this tutorial we will explore how to use J2V8 as a JavaScript engine on Heroku.
While long overdue, I’ve finally written the Getting Started Guide for J2V8.
On April 30th 2015, Tabris.js 1.0 was released. Tabris.js is a mobile framework which enables developers to write cross-platform, native, mobile applications entirely in JavaScript. Unlike other frameworks, with Tabris.js there is no webview and no cross-compiling. JavaScript runs directly on the device and renders the UI using the platform’s native widgets. The uptake has been amazing and Tabris.js apps have started to appear in the App Stores. To celebrate the release, I’ve been counting down the Top 10 Tabris.js features.
J2V8 is a set of Java bindings for Google’s popular JavaScript engine, V8. As we push towards J2V8 3.0, the focus has been on multithread support. We’ve already discussed how to use multiple threads with V8. In this tutorial we will show you some new API coming in 3.0, and how this can be used to implement web workers.
Tabris.js makes it easy to build native, cross-platform, mobile applications. Since its release on April 30th, I’ve been highlighting many of the features of Tabris.js 1.0. Many of these features – such as native look & feel, the JavaScript API and Cordova plugin support – enable developers to rapidly build high-quality, beautiful, mobile applications using the tools and technologies they are already accustomed too. When it comes to deploying your application to the different App Stores, Tabris.js can help you there too.
For the past two weeks I’ve been celebrating the release of Tabris.js 1.0 by counting down the Top 10 Tabris.js features that I’m most excited about; and I’ve finally made it to the Top 3. Tabris.js is a mobile app development framework that enables you to develop cross-platform mobile apps in JavaScript, from a single codebase.
When we built Tabris.js, our goal was to provide a cross-platform, mobile development toolkit that developers love to use. We set out to make mobile development easy and accessible to everyone. From the JavaScript API and module support to native widgets, gestures and performance, we’ve exceeded our expectations. However, we realized that we could never provide every native integration ourselves. In order to meet the needs of today’s mobile app developers and provide extensions for the future, we integrated the Cordova plugin model with Tabris.js.
Tabris.js is a mobile app development framework that gives you the tools to develop your mobile apps entirely in JavaScript. Tabris.js 1.0 was released on April 30th and to celebrate the release, I’ve been counting down the Top 10 Tabris.js 1.0 Features. JavaScript is ubiquitous, and according to one study, it’s currently the most popular programming language in the world. It is also a very powerful language, and by leveraging a fluent API and the thousands of existing libraries, very little JavaScript is often needed to write complex applications.
For the past week I’ve been celebrating the release of Tabris.js 1.0 by counting down the Top 10 Tabris.js features that I’m most excited about. Tabris.js is a mobile app development framework that enables you to develop your mobile apps entirely in JavaScript. Performance is key to any successful app, and keeping Tabris.js highly performant was the goal from day one.
J2V8 provides a tight binding between Java and the V8 JavaScript engine. Using JNI, you can execute JS scripts on V8, get and set values, register callbacks and invoke JavaScript functions – all from Java. However, because of the subtleties related to multiple threads, J2V8 requires that all interactions happen from the same thread. Because JavaScript itself is single threaded, this works out ok.
To celebrate the release of Tabris.js 1.0, I’m counting down the Top 10 Tabris.js features that I’m most excited about. Tabris.js is a mobile framework which enables developers to write cross-platform, native, mobile applications entirely in Javascript; and unlike most mobile app development, Tabris.js is extremely easy to get started with. In fact, with our Mobile Developer App, you can write your first mobile application in less than 10 minutes without the need to install custom tools or SDKs.
On April 30th Tabris.js 1.0 was released. Tabris.js is a mobile framework which enables developers to write cross-platform, native, mobile applications entirely in JavaScript. To celebrate the release, I’m counting down my Top 10 Tabris.js features.
I’m happy to announce the availability of J2V8 2.2 (2.2.1 actually). This release adds two important features: 1) Typed Arrays and 2) 64 Bit Windows support.
When working with JNI, sooner or later you will need to track references to native objects. This came up in J2V8 pretty quickly. With J2V8 we need to keep a handle to the V8 Isolate (an isolated V8 runtime for executing Javascript on). All JNI calls to V8 need to first acquire the isolate, and then perform operations such as executeScript, getValue, setValue, callFunction, etc… The challenge, acquiring the isolate.
On April 30th Tabris.js 1.0 was released, providing developers with the tools to write native mobile applications entirely in Javascript. To celebrate the release, I’ve been counting down the Top 10 Tabris.js features.
On April 30th 2015 we released Tabris.js, and so far the reception has been remarkable! Building beautiful, high quality, native mobile applications – written entirely in Javascript – is a real game changer. To help celebrate this release, I’m counting down my Top 10 Features of Tabris.js 1.0.
In this tutorial we will show you how to debug a Tabris.js application running on your Android phone using the Over the Air debug protocol. To get started you will need:
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.
Tabris.js provides cross-platform access to native gestures and controls through Javascript. In recent articles we have explored images, swipe to dismiss, user input and even parallax scrolling. Today we will explore another native control, The Navigation Drawer.
The EclipseSource team has landed in San Francisco and many of us are hard at work finalizing our presentations.
Last year I announced J2V8, a new JavaScript engine for Java that wraps V8 with a set of Java Bindings. We have been using this technology to power Tabris.js on Android – giving us much better performance than Rhino could. While J2V8 was very stable, it wasn’t very easy to consume. Today I’m happy to announce that J2V8 2.0 has shipped, and it’s much easier to embed in your Java Applications.
If you are an Eclipse committer and planning on attending EclipseCon 2015, we need your help!
If you have three minutes and access to an iOS or Android device, you can develop your first cross platform, native, mobile application with JavaScript, using Tabris.js.
Over the past 4 months I’ve been working on integrating Java and JavaScript in a highly efficient manner. Rhino and Nashorn are two common JavaScript runtimes, but these did not meet our requirements in a number of areas:
The EclipseCon 2015 submission deadline is Monday November 17th. Of course we are looking for great Eclipse / OSGi / RCP content, but we are also looking for talks on really cool Java technologies, Cloud Development, Languages and Tools, Modeling or anything else you think the Eclipse community would be interested in. EclipseCon is being co-hosted with FOSS4G this year, so if you’re developing geospatial software using Eclipse technologies this would be especially cool.
On Saturday June 28th Yoxos celebrated a pretty big anniversary, Yoxos turned 10! Yoxos is the original Eclipse ‘distribution’, born with Eclipse 3.0 in 2004. Yoxos originally brought a variety of Eclipse plugins together and shipped them on a single CD. Below is the first Yoxos print ad, which appeared in November 2004. An early ISO Image from Yoxos (based on Eclipse 3.1.2 for Windows) is available on our website [800Mb].
Eclipse Luna is here! 10 years after the first Eclipse annual summer release shipped, the Eclipse team is still shipping quality software on-time and on-budget. Eclipse Luna contains 76 different Eclipse projects and over 10 million lines of new code was contributed this year.
Eclipse Luna ships tomorrow and that means we’ve made it to number 2 on the Eclipse Luna Top 10 Features That I’m Excited About. Number 2 is a feature enhancement that was first requested in 2002. Over 200 people voted for this enhancement and 181 comments have been posted on Bugzilla! The bug even celebrated a 10 year anniversary. Of course I’m talking about bug 8009: Split Editors, and with Eclipse Luna, Split Editors are finally here.
Eclipse release week is here and Eclipse Luna will be available on Wednesday June 25th. Eclipse release week also means that we are into the Top 3 Eclipse Features on my traditional Eclipse Top 10 List. Number 3 on my list is from the Eclipse Git (EGit / JGit) project. EGit and JGit are arguably one of the most important projects for Eclipse. Self hosting your own tools, or eating your own dogfood, is an important part of the Eclipse development story. If you do not use your own tools, then how can you expect others to use them? EGit started in 2009, and as the project matured the Eclipse team was able to migrate all the source code from CVS to Git. Every year since 2009, EGit has greatly improved.
When Eclipse 3.0 shipped in 2004 it brought a new look to the workbench. Now, 10 years later, an entirely new Dark Theme is launching. Eclipse Luna will ship in less than a week and to help mark the occasion, I’m counting down the Top 10 Eclipse Luna features that I’m really excited about.
Code Recommenders is one of the most exciting and innovative plug-ins available for Eclipse. With standard content-assist, Eclipse will show you all the method calls, variables uses, template options, etc… for the current context. Most of these options are irrelevant, and if you’re learning a new API, all these options can be confusing. Furthermore, listing the code completion options in alphabetical order provides very little value. Code recommenders aims to fix this by displaying the available completion options according to their relevance.
Eclipse Luna will ship in 1 week. While some of the development teams are putting their final bits in place, many committers have decided to celebrate by going to EclipseCon France. Toulouse is a long way from British Columbia, so I’m celebrating the Eclipse Release by counting down the 10 Eclipse Luna Features that I’m most excited about. Number 6 on my list is all the great improvements to the RAP Project that were completed over the past 12 months.
For 10 years Eclipse has set the gold standard for on-time software delivery. Eclipse Luna is just over 1 week away and this year’s release is going to be great. To help celebrate the Eclipse release, I’m counting down the 10 Eclipse Luna features that I’m most excited about.
Eclipse is obviously known for its great Java tooling, but the real power of Eclipse comes from the thousands of plug-ins that integrate seamlessly. No project exemplifies this more than the Eclipse Modelling Project. As we get closer to the Eclipse Luna release, I’m counting down 10 new features that I’m most excited about. On Friday we used Eclipse Sirius to create a model for the FIFA World Cup of soccer. From this model we created a series of graphical editors. Today we will create automatically generated forms from that same model using Number 8 on Luna Top 10 List: EMF Forms.
As we get closer to the ship date of Eclipse Luna, I’m counting down the 10 features of Eclipse 2014 that I’m most excited about. Number 9 on my list is a feature that’s close to my heart, graphical modelling. The Sirius project combines modelling and graphical editors – an area that I spent several years of my life studying. Using Sirius, you can create graphical editors and a modelling workbench for your domain specific language. Instead of explaining this with acronyms and several levels of indirection, let’s go straight to an example.
Seven years ago Eclipse Europa was released. PDE ‘Brought Sexy Back’, CTRL+Awesome shipped and EMF pushed ahead with the brave new world of Java 5. Seven years ago I also wrote my first Eclipse Top 10 List. While a lot has changed in seven years, Justin Timberlake is still on top of the pop world and Eclipse is still shipping quality software, on-time and on-budget.
When committing changes to your source control system, it’s considered good practice to only resolve a single task with each commit. There are several advantages to this approach:
I’ve been using Eclipse for over 10 years now but today I discovered something new. You can configure problem severity directly from the problem markers themselves. Let me explain through the use of an example.
Today I was investigating Bug 427148. The problem is when you update on Windows it sometimes fails if the executable is being updated. This is because the file is locked, and you cannot overwrite it with a new version. The exciting part is that sometimes it works! In fact, we’ve had very little luck finding someone who can reliably reproduce the problem.
Java8 was released in mid-March and the Java 7 End Of Life plan has already been announced. In a perfect world we would all be pushing forward with Java 8, but in reality, other requirements often get in the way. Many developers I talk to say that their production environments (or more likely, their customer’s production environments) are very conservative, and are not approved for Java 7 deployment yet, let alone Java 8.
Last week Java 8 was launched and moments later the Eclipse support for Java 8 was announced. To help celebrate the launch, we had an entire Java 8 Day at EclipseCon 2014, which included sessions from both Java and Eclipse engineers. Highlights for me included hearing Alex Buckley describe the Road to Lambda, listening to John Arthorne talk about API Design in Java 8 and watching the Eclipse Java Development Tools (JDT) Team present all the great work they did on Java 8 Tooling in Eclipse.
EclipseCon 2014 is less than 6 weeks away and I’m getting pretty excited. The schedule has been published and the diversity of talks is really what makes this such a fun conference. While I helped pick the program, the real thank-you goes to the great program committee I worked with. John, Cedric, Dave, Andrew, Shawn, Pascal, Eike, Lars, Gunnar and Tom – working with you was awesome. I learned a lot, and had blast too!
The final submission deadline for EclipseCon 2014 is here! If you haven’t submitted your talk, now is a GREAT TIME!
Last week was the early-bird deadline for EclipseCon 2014 and I was extremely impressed with the quality of submissions. It was very hard to pick just five, but lucky for me, I have an excellent Program Committee helping!
Now that everyone is recovered from EclipseCon Europe – and has plenty of Halloween candy to snack on -- why not spend a few minutes and submit a EclipseCon 2014 talk.
Well I’m going out west where I belong where the days are short and the nights are long
The annual Eclipse release typically indicates the beginning of summer. And if the back-to-school commercials aren’t an indication that summer is winding down, the restarting of the Eclipse milestones builds certainly is. Even with vacations and sunny weather, the Eclipse and Equinox teams have managed to put together the first milestone for the Eclipse Luna release.
Eclipse Kepler, the 2013 Eclipse release, is here! This year there are 71 projects, simultaneously shipping 58 million lines of code.
As many of you know, Eclipse Kepler is coming out on June 26th 2013. As we prepare for this release, we will be pushing some of the release candidates (and eventually the final release) to our production servers. However, for a variety of reasons you may not be ready to upgrade. Maybe the plug-ins you need are not available with Kepler yet; or maybe they don’t work for your use-case.
Eclipse Kepler is 8 days away and I’m into the Top 3 Features in my Annual Top 10 List. Number 3 on my list is the Eclipse Platform – arguable the most important component for anybody using Eclipse.
In one week, on June 26th 2013, Eclipse Kepler will ship. To prepare for the release I’m counting down the Top 10 most interesting features according to me. Number 2 on my list is close to my heart – the Eclipse Provisioning Platform (p2) – and the new features it supports.
As we approach the release of Eclipse Kepler, I’m counting down the Top 10 Features I’m most excited about. Number 4 on my list is RAP 2.x. Powerful, stable and well thought-out APIs is a common theme among Eclipse projects. From the early days of Eclipse, there has always been a focus on API development and RAP continues exemplifies this.
The Eclipse Kepler release is just over 1 week away, and to help celebrate the release I’m counting down the Top 10 Kepler Features I’m most excited about. Number 5 on my list is the much improved integration between Maven and Eclipse.
Since 2001, Eclipse has been setting the standard for Java Development Tools, and with Eclipse Kepler, the JDT team has shipped another top-quality release. As we get closer to Eclipse Kepler, I’m counting down the Top 10 Eclipse Kepler features that I’m looking forward to most. Number 6 on my list is the improvements to the Eclipse Java Developer Tools.
A common theme among Eclipse tools is that they keep you focused on your task by keeping you in the IDE. Linux Tools, which is number 7 on my Eclipse Kepler Top 10 List is no different. Linux Tools keeps C/C++ developers (and other Linux developers) focused on their work by bringing all the tools they need into Eclipse.
As we move closer to another Eclipse Release, I’m counting down the Top 10 Eclipse Kepler Features that I’m most excited about. Number 8 on my list is Mylyn Reviews with Gerrit integration.
As we approach another Eclipse release, I’m counting down the Top 10 Eclipse Kepler Features that I’m most excited about. A lot has changed during my 10 year involvement with Eclipse, but nothing bigger than the migration to Git. The migration was a giant undertaking, but in addition to the code migration the team needed to learn a whole new revision control system. Luckily for us, the JGit / EGit team built excellent Git tools for Eclipse.
This year marks a special milestone for me as it’s my 10 year anniversary with Eclipse. I started using Eclipse in 2003 as a PhD student at IBM. Eclipse was using CVS, PDE/Build and all plug-in dependencies were specified in a plugin.xml (BTW, if you’re still doing this, STOP!). There was no Eclipse Foundation and Eclipse 2.x was the latest and greatest! The first project I ever got involved with was GEF (I found my first ever interaction with the Eclipse community) and it was encouragement from that project that brought me deep into the Eclipse community.
For most people, p2 is simply the Install Software Dialog in Eclipse. While this is certainly true (or at least the Install Software Dialog is built with p2), p2 is much more than this. The Eclipse Provisioning Platform (p2) is a general purpose platform for provisioning everything and nothing in particular.
Spring has certainly sprung on the west coast of Canada, and that means we are into the Eclipse Kepler endgame.
This article describes how to install Eclipse plug-ins from an update site (p2 repository) that is hosted on an HTTP(s) server with a self-signed (SSL) certificate.
EclipseCon 2013 Starts next week, and from my twitter feed it seems the Eclipse community has already started their pilgrimage to Boston.
Just in time for the IDEs of March (@wayne gets the credit for that one), the Eclipse and Equinox teams are happy announce that Eclipse Kepler Milestone 6 is now available for download.
Yoxos is a great way to manage your Eclipse installs. With over 2,000 plug-ins to choose from, you can create your Eclipse, your way. But what if your favorite plug-in is not available in the Yoxos Distribution?
Today, while fixing some Unicode characters support in Yoxos, I noticed that the Eclipse console was not rendering the unicode characters properly.
Luckily this is really easy to fix. In the Launch Configuration dialog, choose the output encoding on the Common tab.
It’s hard to believe that we’re already 1 month into 2013 and that means that Eclipse Kepler release is less than 5 months away. This is also a great time to get involved and help out (especially with testing) if you rely on the Eclipse project. Today, the Eclipse and Equinox teams are proud to announce Eclipse Milestone 5 is now available for download.
EclipseCon 2013 is fast approaching. This year EclipseCon is on the east coast in Boston, MA from March 25-28th. EclipseCon brings together experts from dozens of Eclipse projects along with leaders from the ALM (Application Lifecycle Management) and OSGi communities. I’m really excited about this years program. Here are 5 talks that I can’t wait to see:
Analyzing and understanding the memory use of an application is challenging. A subtle logic error can result in listeners never being disposed, ultimately leading to the dreaded OutOfMemory error. Even if your application is properly disposing of all unused objects, it may still be requiring 10 or 100 times more memory than necessary.
For those of you who were procrastinating and waiting for the last minute to get your EclipseCon 2013 submission in, your last chance is here. The EclipseCon submission system will be shutdown at the end of day today (November 19 2012). The EclipseCon program committee will start reviewing the submissions tomorrow, so this really is a hard deadline.
Today I travelled from Victoria B.C. to Vancouver B.C. to attend the Eclipse Hack-a-thon. It was a great event and I met some really interesting people. I also had a chance to catch up with some old friends. There were several Eclipse vetrans in attendance including Andrew Eisenberg (famous for his work on Groovy and Grails tools), Andy Clement (of AspectJ Fame), David Green, Lucas Panjer, and Shawn Minto from the Mylyn team and Deepak Azad from the JDT UI Team. Ian Skerrett from the Eclipse Foundation also made the trip all the way from Ottawa. There were also a number of students from both UBC and SFU.
I was struggling to track down an NPE in the Yoxos Launcher that only happened on MacOS. To help others avoid this, I thought I would share the problem (and solution). The stack trace was as follows:
The EclipseCon program committee has voted on the early bird selections. Congratulations to these five speakers.
In many parts of North America we turn our clocks back one hour this weekend. If you’re looking for something to do with all this extra time you’ll have, why not download the latest Eclipse SDK 4.3 Milestone and try it out. Head on over to https://download.eclipse.org/eclipse/downloads/drops4/S-4.3M3-201210312000/, and grab the one for your platform. Here you’ll find some new cool features such as:
Wednesday October 31st is Halloween, an evening where children go door to door looking for a treat (candy) – at least in North America.
One of the things I love about working at EclipseSource is that we get the opportunity to work on tools that help developers. Many of us were drawn to Eclipse because we could pitch-in and help-out with Eclipse development – meaning our efforts had a significant impact on other software developers.
There was a small problem when Eclipse Juno SR1 was released late last month. While I won’t bore you with the details (you can read about it on bug 390756), the crux of the problem is that the metadata for MacOS specified the launcher name with a capital ‘E’ (Eclipse) vs. eclipse. This was a mistake in how the metadata was written and this lead to Eclipse installs with missing ini files.
There are several good reasons to use a Rebase Workflow with Git, such as the ability to keep a linear history. However, when I started using the Git Plugin for Eclipse I was unsure of how to follow this workflow. To help others, I’ve put together a short Tutorial that demonstrates how to use the Rebase Workflow with EGit.
What happens when you mix one of the best open source communities with some awesome open source software in a really cool city like Boston Massachusetts? You get the making of one amazing conference.
There are only two hard things in Computer Science: cache invalidation, naming things and off by one errors. (reference)
When new developers join a team, or existing developers move quickly between projects, setting up a development environment can be a real headache. Most software teams will (hopefully) share a set of instructions on a wiki that include:
If you’re using Eclipse and sharing your code (and issues) on GitHub, you really should take a look at the variety of Eclipse Plugins for working with Git. The most obvious plugin is EGit, the Eclipse Git Plugin. EGit (and the underlying JGit) plugins have improved a great deal over the past 2-3 years. I find myself turning to the command-line less and less, which really keeps me in the flow.
Eclipse is an extensible IDE, giving users lots of freedom (and opportunity) to customize the tool for their own use. However, sometimes you run up against a barrier and the only way to get around it is to download and modify the source code yourself.
In June I discussed how to programatically configure Eclipse proxy settings. This is useful if you are using Eclipse APIs (such as ECF) for your communication. However, in some cases you may also use your own transport implementation, or something like Apache HTTP Components. In this case you’ll want to query the proxy configuration settings and use those when setting up your http connection.
Most web architectures make use of several machines working together to serve content. In Yoxos, we use a front end web-server, multiple Database servers, and extra compute servers to calculate all the dependencies between p2 Installable Units (IUs). Often you want only expose certain ports to the outside, but still allow all these machines to have unfettered access between each other. With AWS, and in particular EC2, this is very easy.
In 2004 a new Major Version of the Eclipse platform was released: Eclipse 3.0. This release delivered a universal platform for application delivery and included the OSGi runtime. Now, 8 years later, the Eclipse release train has moved to the next major version. Eclipse Juno has been released and it is the first simultaneous release to be built on Eclipse 4. In preparation for the release, I’ve been counting down the Top 10 Eclipse Juno Features that I’m most excited about:
The original architects of Eclipse knew that developing a single IDE that met everybody’s needs was an impossible task. Instead of trying to boil the ocean, the team opted for an extensible model, in which others could help contribute by writing interesting plugins. If Eclipse could provide a solid foundation, then others could help drive innovation forward – and we all benefit. Number 2 on my Juno Top 10 List – code recommenders – is an example of great innovation on top of a fantastic platform_._
Eclipse Juno, the simultaneous Eclipse release for 2012 will be available in 3 days. Three days left until Juno means that I’m into the Top 3 Eclipse features in my Juno Top 10 List. During the past week I’ve talked about how Eclipse can be classified as ‘top-notch Java tooling’, a ‘general purpose tooling platform’, a ‘runtime technology stack’, and really a ‘platform for everything and nothing in particular’. There is another very important classification for Eclipse technology, Eclipse as a vast array of powerful modelling tools and technologies.
And now for something completely different… or maybe not.
Since I first got involved with the Eclipse ecosystem (in 2003) I’ve struggled to come up with a common theme among all Eclipse projects. They are all written in Java (except for those that aren’t, lots of native code in Eclipse). They are all related to Java (except for those that aren’t: such as C/C++ tooling). Everything is designed as OSGi bundles (and runs on OSGi), except that isn’t true either? I took solace in knowing that the majority of the Eclipse projects moved towards a common goal of providing cross-platform native runtimes, and tools to help build both those runtimes and applications. However, number 4 on my Eclipse Juno Top 10 List – Eclipse Orion – threw a wrench into my classification.
There is less than 1 week to the Eclipse Juno release and I’ve been busy counting down The Top 10 Juno Features that I’m most excited about. Over the past 10 years Eclipse has been classified as many different things, a tools platform, a Run-time Platform and an ALM enabler. However, throughout the past decade one thing has remained constant: Eclipse is a state-of-the-art Java Development Environment. Number 5 on my Juno Top 10 List is the enhancements to the Eclipse Java Development Tools.
Designing and delivering a piece of software that has a lasting effect on almost all software developers is hard. Doing it twice, that’s almost imposible. In the early 1990’s, Linus Torvalds gave us the Linux Kernel. The Linux Kernel is arguably one of the most recognized examples of Open Source software. The existence of Linux has shaped much of the technology world, but I believe that Linus’ second great accomplishment, Git, is even more important. Git is a distributed version control system that completely changes the way software developers interact with and manage their source control repositories. The system is ideal for open source projects because it makes it very easy to fork and merge projects.
Many Eclipse projects follow a common theme of extensible platforms with exemplary tools. Eclipse projects are often designed with a high degree of extensibility in mind, allowing consumers to use the technology in ways never imagined by the original developers. The RAP project is excellent example of this type of extensibility integrated with Eclipse. Instead of targeting the desktop (Rich Client Applications), RAP provides a platform on which Web-Based (Rich Ajax) applications can be built. By simply replacing the SWT / Platform bundle with RAP, you can reuse your RCP based code-base in a web-based scenario.
As we often say, Eclipse is a platform for everything and nothing in particular. And while this is certainly true, the most common use of Eclipse is as a state-of-the-art Integrated Development Environment (IDE). Over the past 10 years, IDEs have evolved from a tool used by single developers to highly collaborative software development environments. The industry seems to have gravitated towards the term Application Lifecycle Management (ALM) to mean collaborative process of managing the life of an application. ALM includes tools to help manage the requirements, architecture, coding, testing, issue tracking and the release. The Mylyn project is the home of ALM related technologies at Eclipse.org.
As Eclipse sprints towards another release – Eclipse Juno – I’m counting down the Top 10 Features that I’m most excited about. As I mentioned yesterday, this is the 5th time I’ve compiled my Top 10 List. I put these lists together for two reasons. The first reason is to let the community know about the New and Noteworthy things in Eclipse this year. The second reason is a selfish one; it forces me to learn about exciting projects in the Eclipse ecosystem. Number 9 on my Top 10 List, Lua Development Tools and the Koneki Project, certainly falls into the second category.
Eclipse has provided high-quality tools to millions of developers for over 10 years, for free. For the 7th consecutive year, Eclipse will ship a simultaneous release. A simultaneous release is a single, coordinated, release containing dozens of related Eclipse technologies. And for the 5th time, I’m assembling a Top 10 List of Eclipse features that I’m excited about. I’ve done this for:
CouchDB is very powerful, NoSQL database that uses JSON for Document, JS for Map/Reduce queries and HTTP for an API. Since all communication with CouchDB is done via HTTP requests, CouchDB can easily act as a webserver serving data as HTML pages. The CouchDB show function is responsible for taking a document and rendering it in different formats. I’ve used CouchDB to render documents as p2 repositories, HTML pages and simple text.
Lately the p2.index file (or lack thereof) has caused a serious problem for the Eclipse foundation infrastructure. Denis highlighted the problems the file causes, but I thought it might help us architect a solution if we better understood the why. Some people have suggested we just remove the file, or combine all the p2 related files into a single file (site.xml?). While this might plug the current leak, it will most likely lead to problems elsewhere. Like most things, the introduction of this file was done to solve a problem. Of course the road to hell is paved with good intentions.
If you use Eclipse and the Eclipse provisioning platform (p2) behind a proxy, then you´re no doubt aware of theNetwork Connection Preference Dialog.
As Pascal mentioned yesterday, on a Mac, Eclipse based applications can now be shipped with the standard Mac layout. For those not familiar with the problem, if you structure your Mac application in a certain way (follow a particular convention) then your entire application appears as a single executable to the user. This means thatRCP applications can be easily deployed to the Applications folder and users can interact with these applications using finder, spotlight, and other Mac tools. From a technical perspective, all the resources (plugins, images, launchers, etc/) live beneath the root folder. From a user perspective, the root folder looks like a single file (application) which can be copied, launched, etc/
Each year Eclipse publishes 7 milestone releases before starting the endgame. Today the Eclipse and Equinox teams are proud to make Eclipse 3.8/4.2 (Juno) Milestone 7 available for download. There are a number of notable features including shiny new icons:
Yoxos not only provides you with a way to pool all your plugins in a single directory, but you can also configure that location. Eclipse/p2 bundle pooling means that different applications (different Eclipse configurations for example) can share the same set of bundles. This saves both time and disk-space as you don’t need to download the same bundle more than once.
Next week I’ll be at EclipseCon in Reston, Virginia. EclipseCon has always been my favorite conference and if my math hasn’t failed me, this will be my 6th one.
EclipseCon is just around the corner (1 week away).
The Eclipse provisioning platform (p2) has a pretty awesome resolver (the planner) that computes all the requirements when you try to install something. It’s this awesome resolver that let’s you install something like the “Eclipse C/C++ Development Tools” without worrying about all the dependencies you need.
I’ve just pushed 1900+ Eclipse plugins to amazon cloud front for fast delivery to Yoxos users. This includes Eclipse Indigo SR2 plus hundreds of add-on components. In addition to this, I’ve just released Yoxos 5.5 – a new launcher with some powerful features. The most notable feature is the ability for Yoxos to co-exist with standard p2 repositories.
Shipping Eclipse each year is a lot of work. The SDK contains code from 3 Top level projects (Eclipse, RT and Tools (Orbit)). There are 4+ Products (Platform, JDT, PDE , Equinox + Releng) and close to 20 Components (SWT, Text, UI, UA, etc…). Once the SDK is built, the release train starts bolting on other projects (Mylyn, EGit, CDT, Birt, WPT, etc..). Getting all these bits in the right place at the right time isn’t easy (although Kim and David sure makes it look easy).
There have been a discussion about build naming conventions lately. SNAPSHOTS, nightly, milestone, GA, maintenance, integration, stable, etc…
Eclipse has two annual conferences, EclipseCon (North America) and EclipseCon Europe. These are great venues to learn about what’s happening in the Eclipse eco-system, explore up-and-coming technologies and get to know the wonderful people behind Eclipse.
Eclipse sure has made a splash over the years. In celebration of the 10th anniversary of Eclipse, I pulled all the Eclipse splash screens from Git and put them all here (I skipped a few when there were only minor updates to the copyrights, etc…).
Inspired by David Orme’s retrospective on Eclipse – and with the 10th anniversary of Eclipse almost upon us – I though I would share my personal history with the Tool, Platform and Community.
EclipseSource now has a 2 day course that focuses entirely on the p2 API. Like our other courses, our p2 course reinforces the theoretical concepts with hands-on exercises. The course covers a wide variety of concepts, including:
Pascal Rapicault, DJ Houghton and I have been hacking on a new feature for p2. Since p2 has been migrated to Git, we created a new branch and started hacking away. We were not very concerned about each individual commit since this work was mostly experimental. We took some wrong turns, performed a few quick and dirty hacks, and generally left our branch in rough shape. However, during the process we learned a lot and finally got feature working, but we certainly didn’t want to merge this hack into master.
With summer behind us and autumn almost here (in the northern hemisphere), you can feel the change in the air.
Eclipse is turning 10 this fall! My first experience with Eclipse came 8 1/2 years ago when I started building visualization tools on top of GEF. I was an IBM CAS Student while doing my PhD at the University of Victoria. Over the years I’ve attended several demo camps, presented Eclipse content at the local Java User Group, delivered presentations and tutorials at numerous EclipseCons and even attended the occasional Eclipse stammtisch. However, I’ve never attended an Eclipse conference in Europe :-(.
Lately I’ve been adding Git support to the Yoxos Workspace Provisioning. This should be done in time for Eclipse Indigo SR1 and this will mean you can easily share your Git configurations in your Yoxos profiles.
While I’ve been enjoying some time-off in Northern Ontario, many Eclipse committers have been keeping busy.
A number of people in the Eclipse community have been trying out Google+ and some good Eclipse related discussions are starting to happen there. Since many of us have multiple Google accounts (maybe your company uses google apps, or you have your own google apps for a custom domain), switching between accounts starts to become a real problem.
It’s interesting to see how Eclipse projects change over time. As projects ramp up, hit heavy development and finally start to mature, the flurry of activity changes. Git makes it very easy to pull out this information. I wrote a small script that shows the number of commits per person, per year (and the total number of commits for that year). I defined a year to basically be an Eclipse release (July 1 - June 30).
The Eclipse Packaging Project defines pre-configured Eclipse distributions. If you are developing in C/C++ there’s a package for that. If you need to create RCP applications there’s a package for that. Using p2 or the Eclipse Market Place you can customize your install until your heart’s content.
As you may know I live on the Canadian west coast (In Victoria British Columbia). We are 3 hours behind Easter Time, which means that the Eclipse release was supposed to happen at 6:00am for me.
After 12 months, 62 projects, 46, 000, 000 lines of code, over 400 committers and 1 Top 10 List: Eclipse Indigo is available on eclipse.org (Or use the new Yoxos launcher to install Eclipse from AWS CloudFront). For the past 10 days I’ve been counting down the 10 most exciting Eclipse Indigo features according to me:
We are one day away from the Eclipse Indigo release, and that means we are into the Top 2 Features On My Eclipse Indigo Top 10 Feature List. Number 2 on my list has been part of the Eclipse EcoSystem for years, but it’s actually a newcomer on annual release train: Window Builder.
There is no question that the mobile market is huge and practically growing by the second. There is some excellent mobile development tools built on top of Eclipse, however, each mobile platform requires Yet Another Language and Yet Another Set of APIs. Developing an enterprise application with a Web, Android, IPhone and Rich-Client interface requires several dedicated development teams, each one specialized in a different technology stack. For this reason, most vendors simply choose a subset of platforms to support and hope their clients are too dissatisfied.
The C/C++ Tooling for Eclipse is old Mature! In fact, the first bug report filed against the CDT was opened on January 14th 2002, Only a few months after Eclipse 1.0 shipped. If my trivia knowledge is correct, the CDT is the oldest Eclipse project (next to the Eclipse IDE itself) and it has grown into a first class C/C++ IDE.
The Eclipse Indigo release is now less than 1 week away, which means I’m into the Top 5 Entries in my Eclipse Indigo Top 10 List. Number 5 on my Top 10 List is near and dear to my heart as I started using some of this technology 5 years ago when it was hosted at openArchitectureWare. In fact, I spent 5 1/2 years of my life studying Model Driven Development, and I find the entire Model-2-Text and Text-2-Model fascinating.
In one week we will be waking up to a new Eclipse release – Eclipse Indigo. I’m using this opportunity to count down my Top 10 Favorite Indigo Features.
As we approach another Eclipse release – this time with over 46 million lines of code – I’m counting down the 10 Indigo features that I’m most excited about.
As we count down the days until June 22nd – the day Eclipse Indigo will ship – I’ve been counting down the top 10 Indigo features, according to me. In my previous article I talked about OSGi and how modularity plays a central role for all Eclipse projects. With over 46 million lines of code and 62 projects, we could not ship on-time without a rock solid module system. But modularity is not easy! Lucky for us Eclipse developers, Eclipse also ships with first class tooling for OSGi. For historical reasons this tooling is called the Plug-in Development Environment (PDE).
When most people think about Eclipse they think of a kick-ass IDE. While this is true, Eclipse is so much more. Did you know that Eclipse hosts a top-notch webserver (Jetty), a framework for building Rich Internet Applications (RAP), a Java persistence solution (EclipseLink) and a foundation for building multi-tier enterprise client / server applications (Riena). In fact, there is an entire top level Eclipse project dedicated to Eclipse RunTime technologies.
As frequent readers of my blog know I’ve been transitioning to git lately. I actually think CVS (with the Eclipse Team Support, local history management and Mylyn) makes a solid source control management solution. However, now that I’ve spent a few weeks with Git, I’m having trouble going back.
June is my favorite time of year. Not only is summer starting (in the northern hemisphere), but it’s Christmas time for software developers. On June 22nd, the annual Eclipse release train will arrive. And, for the 9th year in a row, the train will arrive on-time and on-budget. While the official release – name Indigo – is not due to arrive for another 10 (business) days, I’m going to use this opportunity to highlight my 10 favorite features of this release. This is becoming somewhat of an annual tradition for me.
It’s always a great idea to use a Source Control Management (SCM) system – even when you are working on personal projects, without any collaborators. However, once you start to work with others and multiple streams / branches start to emerge, you need an SCM system that can handle a variety of different merge cases. In this article I will describe a few different ways you can merge two branches using Eclipse Git (EGit).
A severed head is never fun, and in git this is no different. In fact, a detached head can cause quite the headache. In this article I will discuss what a detached head is, how it can happen, and most importantly, what you can do about it. But before I begin, let’s rehash a bit about how git works.
I’m proud to introduce the newest member of our family, Maggie Anne Bull. Maggie and Mom are at home and both doing well.
For those of you wondering what to get Will and Kate for a wedding gift, what about a nice, new, shiny version of Eclipse. As predictable as the changing of the guard, Eclipse has put out yet another milestone.
Another EclipseCon has come and gone. As an Eclipse user, community member, contributor and committer, EclipseCon is a chance for me to make new contacts, renew old friendships and help payoff my beer debt. There are many people who helped make EclipseCon a great event. The program chair (Chris Anz… no wait… Aniz.. Aniszczyk!), the program committee, conference chair (Donald Smith), the foundation staff (See bug 300500) and the wonderful people at MeetGreen. However, one of the most important groups at EclipseCon are the sponsors. They’re the ones who give us all that free beer at 7:00pm.
On Tuesday, Pascal and I presented “p2, your savior or your achilles heel? Everything an Eclipse team needs to know about p2” where we talked about the 10 most common pitfalls developers face when using p2. More importantly, we talked about how you can avoid them.
Have you used p2? Have you tried to replace plug-in with an updated version, only to find p2 doesn’t find it? Have you removed an unused plug-in and suddenly Eclipse stopped working?
Just in time for EclipseCon, the Eclipse and Equinox teams have delivered another milestone. This time, Eclipse 3.7 (and 4.1) Milestone 6 are available for download.
What’s the latest version of Eclipse? Which version of Mylyn works well with Eclipse 3.6.2? How do you configure a toolchain for a project that was developed with Eclipse 3.5?
In p2, if you’ve ever tried to write to the same artifact.xml (artifact repository) from two different processes, you will quickly learn that this fails. In fact, both processes will start corrupting each others data and you will likely end up with an unusable artifact repo. This limitation is of particular concern if you wish to use proper bundle pooling (a single bundle pool for all your Eclipse installs). Of course, you could implement your own bundle pooling technology, but I’ve set out to fix this at the p2 level.
For anyone who follows the Eclipse developer mailing lists, you might notice the weekly e-mails regarding the tagging process. The e-mails usually describe which bundles have been tagged and which changes are included in the build. In this post, I’m going to describe a little more about this process and why it’s important to the Eclipse build.
Well here we are just over half way through the NHL season and the norther hemisphere is in the middle of winter. For those of you who don’t plan on spending the weekend watching the NHL All-Star game, you’ll be happy to know that Eclipse 3.7M5 is now available for download.
If you were looking for something to give that hard-to-buy-for person on your Christmas list, what about Eclipse 3.7 Milestone 4? That’s right, just as planned, another Milestone has shipped.
There are only a few guarantees in life, death, taxes and an Eclipse milestone every 6 weeks. And just like 6 weeks ago, the Eclipse platform team has put out another milestone towards the Indigo release. This milestone includes both the Eclipse 3.7 and 4.1 platforms. There are some pretty exciting new features including:
Well summer is finally over (Autumn is almost officially here), but it doesn’t mean that everyone has been slacking. Over the past few months the Eclipse Platform team managed to ship Helios (on time of course), ship Eclipse 4.0 (Early Adopter Release), and start-up the Eclipse 3.7 (Indigo) work. In fact, Milestone 1 shipped over a month ago, and now Eclipse 3.7 Milestone 2 is here.
I know Eclipse ‘Help’ is not a very exciting topic, but today I found myself working with a little known secret of Help. Most people know that you can setup context sensitive help (Press F1 and bring up help for the specific workbench part under focus). However, did you now you do the opposite? That is, activate code in your RCP application from a link in Help?
If anybody is going to be in Dublin next Thursday (Sept 9th), I’ll be talking about OSGi, Software Modularity and Single Sourcing. Details of the event can be found on the course page. If anybody is going to be in the area, let me know. I’d love to catch up with some Eclipse folks over a few frosty beverages.
What do the following people have in common:
They were the original 8 feeds on PlanetEclipse. If you are interested in some of the first posts checkout this link. Or, you can browse through time on web.archive.org.
Two weeks ago I asked you to think about high quality software that has been consistently delivered on-time. Think about software that is used by millions of people world-wide, built by hundreds of developers, free to use and open to everybody and anybody. Think about software that spans domains, runs on the smallest of devices and powers the worlds largest enterprises.
Well here we are, it’s release week. Eclipse 3.6 – Helios – will be available on Wednesday June 23rd. It also means that I’m into my Top 3 features for this years release. For the past 7 days I’ve been presenting some of the New and Noteworthy features of the years release.
As most of you know, Eclipse Helios will be released next week. For regular readers of my blog (and PlanetEclipse.org), you know that I’ve been counting down some of the new features available in the release. During this series I have received comments (both in the comment fields, and on places like twitter) that essentially read: I really like Eclipse except it doesn’t have an editor for XYZ. Or, when I get the following package, it has feature ABC which I don’t want. Obviously we can’t please all the people all of the time.
The official Helios release is less than 1 week away, and we are now into the Top 5 Features that I’m most excited about. Over the past week I’ve been highlighting some of upcoming features of the Eclipse Helios release. These features include: improvements to the Java Development Tools, Plug-in Development Environment, API Tools and the Eclipse Platform. Number 5 on my Top 10 List is: p2 API and the b3 Aggregator.
There are three large groups of artifacts that play a key role while writing software. There are the tools you use, the code you write and the libraries you depend on. There is a large body of research studying the cognitive support provided by software development tools. There is also a number of tool centric development models. Facilities like Yoxos and the Eclipse Market Place help you manage these tool chains.
As Eclipse committers, we spend lots of time emphasizing that Eclipse is not just an Integrated Development Environment. Eclipse is a framework, a tooling platform, a collection of run-time technologies, an eco-system, etc… However, at the end of the day, an IDE is the primary use of Eclipse for many people.
I’ve been thinking a lot lately about what defines an Eclipse project? Not in the literal sense (a project hosted at eclipse.org that follows the EDP), but rather, what technical qualities do all Eclipse projects share.
Yesterday I asked you to think about high-quality software that has been consistently delivered on-time for eight straight years. To make this quiz more challenging, this software should be installed on millions of users’ desktops.
Pop quiz: Can you name any ‘high quality’ software that has been consistently delivered on-time, for 8 years in a row?
It’s been overcast and raining here in Victoria B.C. (Canada) over the past 2 weeks. It’s a long way from the dog days of summer, but a good time to focus on docs. In fact, the Eclipse team has been focusing on documentation during this final release candidate. In particular, the p2 team is putting some docs together on our new API (Yes, p2 has “real” API now).
Eclipse developers are in the middle of the ‘End Game’. Half way through the release candidates and getting ready for another major release. All the API is in place, the features are ‘complete’ and we are working through the last of the major bugs.
There are a lot of very good reasons for developers to get on board with Open Source Software (OSS). Businesses are making use of OSS both because of the cost savings and the excellent quality of the code (not to mention the open development model which makes it very easy for them to get involved). Whether you are student looking for your first job or a senior engineering looking at the strategic direction for your company, open source can play a key role in your career.
At EclipseCon I had the pleasure of presenting an introductory tutorial on p2 with an awesome co-presenter Kim Moir.
I realize that Helios isn’t even out the door yet, but some people are already looking ahead to next years release. The planning council has been taking suggestions for the name of the Eclipse 2011 release and has come up with a short list of names:
Last summer when Galileo was released, I wrote a series of blogs in which I discussed my top 10 favorite features of the release. Somebody at the Eclipse Foundation must have enjoyed the read because I won a free conference pass to EclipseCon 2010. I thought it would only be fitting to share my top 10 moments from EclipseCon 2010 with all of you. These are roughly in the order in which they happened (roughly).
One of the key aspects of Agile Software Development – or any iterative software development process – is keeping your customer in-the-loop. In order for customers to have a voice in the software development process they must continually consume your software, provide feedback, and witness the results of that feedback. In a small setting this might not be to hard. But when you mix in a variety of different configurations, distributed development teams, and distributed customers – delivering and updating software can become a challenge.
As I mentioned a while back, Eclipse Helios M5 was made available for Download. There are number of New and Noteworthy features, but one really big feature was omitted from the N&N. The Eclipse provisioning platform, p2, finally has API! Really, go take a look at the code… all those internal.provisional packages are now gone! This was actually a huge milestone for the p2 team, and Pascal did a great job steering us towards the API.
Traditionally the Eclipse community has used the mailing lists, newsgroups and an aggregation of blogs to stay connected. Mailing lists and newsgroups have generally been more technical, while the blog-o-sphere has everything from tutorials to highly opinionated views. Over the past year and a half, many of those in the Eclipse Community have also emerged on Twitter.
Eclipse 3.6 M5 is now available for download. There are lots of new and exciting features, like the ability to open and file directly from the command line. You can also use the synchronize view to compare patches:
I spent part of today trying to debug a Linux specific issue in which wizard pages are not being shown properly. Actually, the content of some wizard pages are not showing up at all (Bug 298805 if you’re interested).
Just in time for the Holidays, the Eclipse platform team has made Eclipse 3.6 Milestone 4 available.
There has been a lot of talk lately about what the Eclipse community is and is not doing. While I have no intention of going anywhere near that conversation, I did want to highlight something that makes me very proud to be part of this great community. This month, the Eclipse community raised over $3,000 for men’s health issues, and that’s awesome!
Lately I have been working on (and committing) a repository analyzer tool for p2. It is meant to help you validate your repository against known problems and common mistakes (missing version numbers, two IUs with the same ID/Version, etc…). After cleaning up the code I finally committed it. Within a few minutes of committing it, Andrew starting pinging me to let me know I introduced a compile error. (Thanks Andrew).
Recently I had the pleasure of updating the way Yoxos is built. Like a lot of Eclipse based applications, the Yoxos build was feature based and we naturally use the normal headless PDE/Build scripts to do this. To make things a little easier to extend, I decide to use the new product based builds (new is relative, as product builds have been around since about Eclipse 3.2).
Have you heard about OSGi but are not sure about the details? Are you wondering what this brand new Java technology is all about? Are you concerned that its footprint is too large for your specific application? Are you not sure if OSGi solves a problem you have? Is OSGi a no go for you because you don’t use the Standard Widget Toolkit (SWT) or any other Eclipse technology?
As most of you know October is coming to an end. This means that M3 is due out soon, ESE is over, and the very early EclipseCon registration deadline is approaching. It also means that Movember is starting. Movember is a month dedicated to changing the face of men’s health, and it’s all about the Mo (the Mustache). This year I thought we could try and get an Eclipse team together to help with this worthy cause.
e4 0.9M5 is now available for download. One of the things that excites me about this work is the web based form editors that Boris Bokowski has been working on. The form editors have always tried to mimic a web look and feel, but now they are using real web technology.
Yesterday I spent the day working on examples of how PDE Build can be used to build OSGi bundles. I was setting up builders, copying files from my workspace to my builder, and running builds. Early in the morning I was faced with the follow:
Today is the big day! Eclipse 3.5 – Galileo – is available for the general public. To count down the final push towards Galileo, I have been reviewing the Top 10 features that I’m most excited about. There are tons of other great features – such as the SWT port to Cocoa – that I personally don’t make use of, so if you disagree with my Top 10 list, I encourage you to publish your own.
As many people have already said, Galileo is available for Friends of Eclipse. As Chris pointed-out, one of the reasons Eclipse is able to ship quality software, consistently on-time, is because of the modularity offered by OSGi.
Software development can be characterized by the management of two separate, yet equally important groups of artifacts. The source code you write and the libraries you depend on. Much of our education, tooling, and software engineering literature focuses on the first part – this post focuses on the second.
As I mentioned yesterday, tools such as the Memory Analyzer demonstrates just how dominant Eclipse is in the IDE space. And while Eclipse has many useful tools, nothing has changed the face of the IDE as much as the Mylyn project. Mylyn is more than just a cool plug-in for Eclipse, it completely changes the way developers work, bringing your productivity to a whole new level.
With all the great work going on in the Eclipse Run-time space, like the EMF Runtime, RAP, Birt Charting Engine, ECF, Jetty and of course Equinox, I sometimes forget that Eclipse started as an excellent platform for tools. The Eclipse Memory Analyzer project reminded me just how good Eclipse tools are.
As readers of my blog are no doubt aware, I have been counting down the Top 10 Galileo features that I’m most excited about. Galileo is the name of this years “Eclipse Release Train”, the simultaneous release of 33 Eclipse projects. Galileo will available for download on June 24th, but “Friends of Eclipse” get it sooner. Friends of Eclipse is a donation program setup by the Eclipse foundation.
The next feature on the Top 10 Galileo Features (according to me) comes from the Eclipse Modeling Project. The Eclipse Modeling Project is arguably one of the most diverse, yet well focused, top level projects at Eclipse.
Just 1 week until the Galileo release, and I’m using this opportunity to count down the top 10 features in Galileo that I’m really excited about. Previously I talked about the improved tooling support in the compare editor, and the enhancements to the Java 2 JavaScript bridge. Number 8 on my top 10 list is the new RAP Look and Feel.
With Eclipse 3.5 – Galileo – just around the corner, I am counting down the top 10 features I’m most excited about. Number 9 on my list is the improved Java 2 Javascript bridge available in the SWT Browser widget. The SWT Browser now supports both calling Javascript from Java and calling Java from Javascript. Leveraging the growing number of “Web Widgets” (Google maps for example) in your rich client applications is now very easy.
The Eclipse 2009 Release – codename Galileo – will be available in about 10 days. To help countdown the final push, I have decided to review my Top 10 Galileo features. I need to stress that these are my top 10 features. On a daily basis I make heavy use of the Eclipse SDK, Mylyn, Modeling and RAP, so my top 10 comes from these projects.
Last week I presented the publishe, the tool used to put your deployable entities (e.g., bundles) into a p2 repository. The publisher can be used in 4 different ways
There has been a lot of talk lately about p2. Using p2, you can:
One of the things I really like about my job is that I get to spend time working with students. As a software engineer working at EclipseSource Victoria, I spend part of my time at the University of Victoria helping master’s and PhD students with their research. I have also taught and TA’d a few course at both the University of Victoria and the University of Waterloo.
Never judge a man until you have walked a mile in his shoes. This advice can be applied to the art of writing software. At a high-level software seems so easy, but when you start working on a project, truly understand the requirements and start writing code under a variety of constraints, the true nature of the beast reveals its ugly head.
Have you had the experience of creating an interesting application, exporting it, generating a p2 repository, connecting to your repository, and *BAM*, nothing there! The reason this happens is because you likely didn’t categorize your repository. Consider the following:
20 Eclipse projects were accepted this year for Google Summer of Code and you can see the complete list here:
As everyone should now know, the application process for Google Summer of Code is well underway. Students are actively putting together their proposals and mentors are busy giving feedback and helping students solidify their ideas.
This week should be “Go Time” for all students. This is the week students from across the globe are submitting their applications for Google Summer of Code. Students, you have until this Friday (April 3rd) to submit your application. While you may think that’s plenty of time, think again!!! Some students have already begun submitting their applications, and mentors have already starting reviewing / commenting on them. If you don’t get your application in early, you are less likely to get any help with it. (And less likely to find a mentor). The best advice I can give is to submit early!!!
As I left EclipseCon I was a little surprised there wasn’t the famous +1, -1, 0 buckets outside the Hyatt. I wanted to cast my vote for the entire conference. I had a great week and I learned a lot, although there were 2 things that disappointed me.
I have been working on one of the most requested Zest features, custom figures, and by EclipesCon it will be finished. Now you are no longer stuck with those little blue rounded rectangles. You can construct all sorts of custom figures, or even make use of an ImageFigure.
The “conversation” around #eclipsecon is really starting to pick up. If you are following the blogs but not twitter, then you are only getting half the news.
For those of us in Canada, it can be hard to think about summer. Even in Victoria we had a late blast of winter, which makes it feel like summer will never come. However, for open source developers, summer is just around the corner – Summer of Code that is. The Google Summer of Code program provides funds and the infrastructure to enable students to work on open source software from May to August. This is the 5th year Google is putting on this program and they just opened up the the application for member organizations. Once again, Eclipse will be applying for participation.
As I mentioned previously, Wayne Beaton from the Eclipse Foundation paid a visit to Victoria this week. Wayne is currently on a west-coast road trip visiting a number of schools out here. I had a chance to catch up with Wayne as he stopped by both the University of Victoria, and the Vancouver Island Java User Group.
Over the past week I have ignored my daughters, gave-up on work, haven’t seem my wife, and managed to create a web-enabled version of Zest. Ok, most of what I said is lie, however, I did manage to create a web-enabled version of Zest while still spending quality time with the family (and getting some “real work” done).
Somebody asked me a great question the other day, can p2 be used in non-eclipse systems? This is a great question because I think it highlights the fact that we don’t always make newcomers aware of the great power contained in the Eclipse components. Most of the Eclipse bundles are not designed simply for the IDE. In fact, for almost all the bundles in the IDE, thought is given for how they can be generalized. The IDE is just an example of how the bundles can be used. When developing software using the Eclipse IDE keep this mind, and you will start to see reuse opportunities everywhere! Of course – getting back to the original question regarding p2 – the answer is a resounding YES!!!
On Monday March 23rd at EclipseCon, I’m helping to deliver a tutorial on one of the most significant platform-level changes made in the Eclipse Ganymede release. The tutorial is on p2, the new provisioning platform. The tutorial is being prepared and presented by many of the core p2 developers, including Pascal Rapicault (p2 team lead), Jeff McAffer (Equinox co-lead and Eclipse PMC member) and Andrew Niefer (King of PDE Build). As the new-kid-on-the-block, I hope to bring a different spin to the tutorial. Over the past 3 months I have been learning the ins-and-outs of p2, understanding the difference between and UIs and IUs, and even hacking code in the IU UI :). I understand how daunting new technology can be, especially technology littered with acronyms and unfamiliar metaphors.
I saw this presentation today InfoQ. In this video, Erich talks about the Eclipse Way process and how the Eclipse development process evolved over the years. As well, he talks about the importance of API, components and shipping on time. There is bit of information on Jazz (the last 15 minutes), but the first 45 minutes is a great retrospective on Eclipse over the past 7 years.
Anybody building plugins / products / tools based on Eclipse, Milestone 5 is a pretty important time. The API should be stable, most of the features should be spelt out, and the new splash screen is here :-).
Yesterday I stumbled upon a pretty interesting google code project, the Google Visualization API. The Google Visualization API enables you to expose your own data through a number of Visualization Widgets, which are made available as a service.
There are a number of different ways to grab changes from a remote Git repository and bring them into your local repository. The most common way is to simply do a pull. By default this will do a ‘fetch-and-merge‘, but you can configure this to do a ‘fetch-and-rebase‘ instead. You can also do an explicit ‘fetch and merge’ or ‘fetch and rebase’. There are a number of good articles on the difference between merge and reabase. Alex Blewitt covered this on his Git Tip-of-the-week series.
p2 is a provisioning platform for Eclipse / Equinox based applications. The p2 platform itself is highly modular, meaning it can be carved and assembled in different ways depending on the task at hand. One such separation is the split between the Metadata (description of what can be installed) and the Artifacts (actual bytes that are laid down on disk).
J2V8 is a set of Java bindings for Google’s popular JavaScript engine, V8. It was developed to bring highly efficient JavaScript to Android and is the workhorse behind Tabris.js. J2V8 also runs on Windows, Linux and Mac OS. In this tutorial we will demonstrate how to execute scripts with J2V8.
