May 08, 2012

Compendium 4.3 and Residential 4.3 published!

After some delays, I am happy to make the Compendium Version 4.3 and Residential Version 4.3 specification documents available for download. Compendium Version 4.3 The Compendium Version 4.3 document adds all the specifications that were introduced in the Enterprise Version 4.2 document including Remote Services Admin JTA JDBC JNDI JPA Web Applications SCA Configuration The Compendium

The Eclipse that Everybody is Looking For…

Our dependence on search technology grows.

A while back, I posted the Top Ten Ways to Say Eclipse. It seems like every few days, I get a new one to add to my list. I get asked about Eclipse cables, Eclipse wire strippers, Eclipse massages, and more. The variety is inspirational.

Most of the people who contact me are pleasant enough. Some acknowledge that they’ve probably contacted the wrong person. Some people are downright nasty. Again, the variety is inspirational.

I’d wager that all of these misdirected missives, are the result of the sender simply typing the name of whatever it is that’s itching them into their favourite browser, clicking the first thing in the list, and navigating our contact links until they find the most promising email address. The eclipse.org pages do pretty well in terms of page ranking on Google, so we’re probably the first hit for anything “eclipse”, and once you get that first hook, it’s only two clicks to the “General inquiries” (EMO) email address.

Oh well… I guess that it only takes a few seconds for me to explain that we’re not the eclipse they’re looking for


Want to get a job after college?


The question I aim to help answer is this: how do I get the skills I need to get an entry-level job that already requires the skills I need?


I have noticed recently from several of my in-town colleagues in the software business that there seems to be a shortage of qualified, interested people seeking open positions. The key word here being “qualified”, with “interested” not being far behind. There is no shortage of applicants, but it seems like well more than half are so unqualified that they are job-seeking for the sake of job-seeking, yet not actually looking for a place to work in return for a paycheck. I know in the minds of many people there is an apparent unsolvable problem where you cannot find a job because you do not have the skills, but cannot get those skills because you can only learn them while on that sort of job. My aim here is to explain what skills those are and how you might go about acquiring them without having true, full-time, paid job experience. Please note that these comments are my own opinion and not those of guidance counselors, hiring managers, or others that are far more in-the-know than I am.


Even before addressing skills, however, there is something to be said about the non-technical parts. Number one is to do a little research. Find out something about the organization you are joining. What sorts of projects do they do? Who are the managers and team leaders, and what are their areas of expertise or research? What is the working environment like? Do people wear jeans and shorts to work or neckties? Seeking an entry-level position, you are not going to get away with looking unkempt, wearing flip-flops and jeans, and still get that contested entry-level position.


Number two is to be enthusiastic. An employer is going to invest in you. They don’t want to hire someone to see them leave after a year or two. Organizations often take six months to a year to really bring someone up-to-speed to start working independently, and until then it’s a loss of productivity in another developer or two. If you don’t care about the work you are doing, you are less likely to want to do it well. Employers can see that when you talk to them, and are more likely to hire someone that wants to be there than someone that does not, despite slightly less experience. Not wanting to be where you are and not caring if you produce quality output is a quick way to kill motivation in a programming team. Prove to your future employer that you will be a benefit.


Now on to the technical skills. The main point to remember is that when starting out, familiarity can be much more helpful than expertise, and broad familiarity even more so than specific expertise. Especially for a new hire, you are likely not to have much exposure to the useful and important day-to-day tools of a professional development team, but your learning curve will be much easier if you expose yourself to some of what you may see. Every shop is a little different, but most have the same basic pieces in place. Get to know some etiquette and get familiar with the types of tools you will be using. My point here is that each organization has their own practices and tools, and you will need to learn how they do things. It is helpful to ask questions and contribute, but don’t expect to have their policies become your policies as a new employee. You will need to learn their way of working, and the faster you do the more productive you will be and the team that got stuck with you as a time sink will like you and respect you more and treat you as an asset sooner.


Your number one technical skill to build is using a development environment. Many Java developers use Eclipse, perhaps even most developers do. Some use it for everything, fully embracing the integrated nature of the environment, and some use external tools out of preference. Developers for other languages use other environments, such as Microsoft Visual Studio. Some use a system-default text editor and command-line. You don’t need to know about all IDEs, or even be an expert at one. What you must do is know what they are capable of and what benefits they provide. Learn how to navigate around code, outlines, and project explorers; searching all files for a function name by string is a thing of the past. Get used to using shortcut keys. Learn some of the paradigms of the popular IDEs, such as where to find menus and toolbars, whether most things are done via shortcut key or context menu, where to find help documentation, and where to tap in to the user community.


Number two on technical skills is a source code management system. Git is becoming increasingly popular in the open source world due to the workflows it can handle. Subversion is still quite popular. CVS is still used in many environments and being phased out in others. Learn the benefits of source code management and versioning. Learn how to check out, check in, properly annotate a commit message, branch and merge, deal with other developers on the same few files. Learn about patch files. Learn the pros and cons of the most popular systems, and look up why groups are migrating from one to another. Learn some of the ways these systems integrate with IDEs. Learn about the various workflows that are commonly used, such as tiered approaches or having a single central repository.


Number three on technical skills is issue tracking. Bugzilla has been around a while and most commercial and open source developers have at least heard of it. Trac is another popular option that also brings in connections to a repository, code browsing, and Wiki. Again, don’t try to learn them all, or even the names of all the ones out there. Find out what some popular ones are, look at the features they offer, look at how organizations use them, and get some practice. Some open source projects use Bugzilla for a discussion forum as well as defect investigations and enhancement requests. Others strictly use their forums for discussion and then open a ticket when they have good reason to believe it is a new issue. Learn some of the ways organizations use this kind of tool.


For number four I will group the rest of the tools that may be useful. These start to branch out wildly depending on the industry you are in, but the key here is to not be taken completely unaware that something exists. Some examples in no particular order: ANT, word processing, spreadsheets, database systems and SQL, XML, JSON, image editing (e.g. Gimp, Photoshop), email and instant messaging, Skype, javascript, python, differences among web browser engines. Also try to be familiar with some of the pros and cons of operating systems for different needs. Linux, Windows, Mac OS, various smartphone systems, tablets, and how they are tuned for servers, gaming, software development, portability, battery life, photo and video editing, customization, malware control, etc.


Now how do you go about learning all of this useful stuff? If you are at a college or university, find or start a student organization or club. I recommend a game developers organization, which brings together designers, programmers, artists, and musicians. If you are not at a college or want another path, jump on an open source project that interests you. Look on SourceForge, Google Code, github, or see if any software you use is open source and how you might be able to help. Get into a situation where you are working with other developers on a project. Practice using a source code repository and issue tracking system. Practice working with other people on a common task, collaborating and sometimes conflicting. Learn how to resolve conflict. Dive into a project being managed and learn something about project management, deadlines, bug assignment, and just teamwork in general using the tools of the trade to coordinate and communicate.

Eclipse 4 RCP Tutorial updated to M7 and Eclipse 4 book (Early Access Version) soon available

I updated the Eclipse 4 RCP Tutorial to Eclipse 4.2 M7.

This week I’m in the process of delivering a 5 days Eclipse 4 training together with Marcel Bruch and M7 really shines in terms of stability.

M7 contains lots of small enhancements which make adapting Eclipse 4 much nicer, my personal favorite is Bug report: Application.e4xmi should be optional for which Sopot Cela provided a patch. With this patch you can convert an Eclipse plug-in into an Eclipse 4 application without creating manually any extension in the plugin.xml file.

Please give Eclipse 4 M7 a try and report bugs you find in Bugzilla.

I also thinks its about time to release my Eclipse 4 book for the Kindle. This will be an “Early Access Version” due to the fact that Eclipse 4 is still not final and that certains chapters still need some rework but should hopefully be a good reference. I plan to provide updates for this version once Eclipse 4 is released via the Kindle store.

I hope that I will be able to publish this version of the Eclipse 4 book next week. Fingers crossed. :-)

May 07, 2012

Oracle vs Google partial verdict on copyright part

Today's news regarding partial verdict on Oracle vs Google trial are almost all wrong.

It drives me mad to read stupid teasers like "Oracle wins" or "Google is guilty".

Read the (FM) Groklaw first!!!

In short: "The judge has stated, pending judgment as a matter of law, that there is "zero finding of copyright liability" other than the 9 lines of code to which Oracle's damages report attributes no value...".

Little things that matter

Installing Eclipse in Fedora is deadly easy. It is enough to type
$ sudo yum groupinstall Eclipse
$ eclipse
to enjoy latest and greatest Eclipse installation, including all major projects (Eclipse itself, EMF, GEF, Mylyn, Git, WTP and others). Now it is time for the small thing - error reporting. Up until now, it was possible to do this using Mylyn:
Eclipse packaged by Fedora is now better integrated with the OS, so it is possible to report errors directly to Red Hat bugzilla.
Delivering feedback couldn't be easier!

Martin Fowler's State Machine DSL with Xtext 2.3


In his book on domain-specific languages, Martin Fowler introduces a small example along which he shows different techniques to implement a domain-specific language. The example goes like this:

Imagine you work for a company specialized on developing and installing systems for secret compartments and you have many customers with very different mechanisms. Mrs. H for instance wants to have a secret panel in her bedroom, which can only be opened after the door has been closed, the second drawer in her chest has been opened and the bedside light was turned on. Also the panel should be closed and locked immediately after someone opens the door - no matter in what state the system is in that case.

Martin proposes the following script as an appropriate definition of Mrs. H's secret compartment system:

events
  doorClosed
  drawOpened
  lightOn   
  reset doorOpened
  panelClosed
end

commands
  unlockPanel
  lockPanel
  lockDoor
  unlockDoor
end

state idle
  actions {unlockDoor lockPanel}
  doorClosed => active
end

state active
  drawOpened => waitingForLight
  lightOn    => waitingForDraw
end

state waitingForLight
  lightOn => unlockedPanel
end

state waitingForDraw
  drawOpened => unlockedPanel
end

state unlockedPanel
  actions {unlockPanel lockDoor}
  panelClosed => idle
end

The script starts with two sections which declare the events and the commands. After that the different states are declared. Some of them execute declared commands as a side effect (the actions block). Also they contain declarations of transitions, i.e. to what state the system switches when a certain event is fired.

As I have already implemented this language with previous versions of Xtext, I'd like to make it a bit more interesting this time. Let's replace the more or less useless declaration of commands with the possibility to write and call real code!

events
  doorClosed
  drawOpened
  lightOn   
  reset doorOpened
  panelClosed
end

state idle
  do { 
    println("opened the door.")
    println("locked the panel.")
  }
  doorClosed => active
end

state active
  drawOpened => waitingForLight
  lightOn    => waitingForDraw
end

state waitingForLight
  lightOn => unlockedPanel
end

state waitingForDraw
  drawOpened => unlockedPanel
end

state unlockedPanel
  do { 
    println("opened the panel.")
    println("locked the door.")
  }
  panelClosed => idle
end

As you can see the main change is that you are now able to call Java libraries right from within your state machine. I want these expressions to be statically typed (incl. full support for Java generics) and to keep the code as readable and dense as the rest of the DSL we need to have type inference like in Scala. Feature-wise everything should be supported, from for-loops to conditional logic, from the typical literals to more advanced concepts like lambda expressions (it's 2012 after all). 

But how would we talk to a door resp. panel service in order to open and close them? We could use static methods, but that's bad design since then the application is hardly testable and you cannot easily switch the concrete implementations behind these services. So let's use dependency injection. 
To support that I added a services block to the language where you list all required services. Now we can use these services within the action code :

events
  doorClosed
  drawOpened
  lightOn   
  reset doorOpened
  panelClosed
end

services
  DoorService door
  PanelService panel
end

state idle
  do { 
    door.open
    panel.close
  }
  doorClosed => active
end

state active
  drawOpened => waitingForLight
  lightOn    => waitingForDraw
end

state waitingForLight
  lightOn => unlockedPanel
end

state waitingForDraw
  drawOpened => unlockedPanel
end

state unlockedPanel
  do { 
    door.close
    panel.open
  }
  panelClosed => idle
end

Our language would now be very testable and should integrate nicely with any Java project. 

How Do I Implement Such A Language In Xtext?

To get a full implementation of this DSL, including not only a parser, linker, unparser, etc. but also a compiler generating readable and executable Java code as well as having nice integration in Eclipse, you need to create a fresh Xtext project, using the wizard and define the following grammar:

grammar org.xtext.example.mydsl.MyDsl with org.eclipse.xtext.xbase.Xbase

generate myDsl "http://www.xtext.org/example/mydsl/MyDsl"

Statemachine :
  {Statemachine}
  ('events' 
    events+=Event+ 
  'end')?
  ('services'
    services+=Service*
  'end')?
  states+=State*;

Service :
  type=JvmTypeReference name=ID;

Event:
  resetEvent?='reset'name=ID;

State:
  'state' name=ID
    ('do' action=XBlockExpression)?
    transitions+=Transition*
  'end';

Transition:
  event=[Event] '=>' state=[State];

I don't want to go into a detailed explanation of the grammar language, since that is explained in the documentation. But note, that in order to be able to write full Java types in the service declaration we refer to a library grammar rule (JvmTypeReference). The same applies for the expressions: The library grammar 'org.eclipse.xtext.xbase.Xbase' predefines the full expressions and all we have to do here is to import the grammar in the first line and call the rule XBlockExpression within the rule State.

Now that we have defined the syntax of our language, we need to tell how it is translated to Java. For that matter we write some code, which creates a Java DOM out of the state machine DOM produced by the parser. To make this very readable and concise Xtext comes with an internal DSL implemented in the programming language Xtend. The actual code looks like this:

 def dispatch void infer(Statemachine stm, 
                         IJvmDeclaredTypeAcceptor acceptor, 
                         boolean isPreIndexingPhase) {
   
   // create exactly one Java class per state machine
   acceptor.accept(stm.toClass(stm.className)).initializeLater [
     
     // add a field for each service annotated with @Inject
     members += stm.services.map[service|
       service.toField(service.name, service.type) [
         annotations += service.toAnnotation(typeof(Inject))
       ]
     ]
     
     // generate a method for each state having an action block
     members += stm.states.filter[action!=null].map[state|
       state.toMethod('do'+state.name.toFirstUpper, state.newTypeRef(Void::TYPE)) [
         visibility = PROTECTED
         
         // Associate the expression with the body of this method.
         body = state.action
       ]
     ]
     
     // generate a method containing the actual state machine code
     members += stm.toMethod("run"newTypeRef(Void::TYPE)) [
       
       // the run method has one parameter : an event source of type Provider 
       val eventProvider = stm.newTypeRef(typeof(Provider), stm.newTypeRef(typeof(String)))
       parameters += stm.toParameter("eventSource", eventProvider)
       
       // generate the body
       body = [append('''
         boolean executeActions = true;
         String currentState = "«stm.states.head.name»";
         String lastEvent = null;
         while (true) {
           «FOR state : stm.states»
             if (currentState.equals("«state.name»")) {
               «IF state.action != null»
                 if (executeActions) {
                   do«state.name.toFirstUpper»();
                   executeActions = false;
                 }
               «ENDIF»
               System.out.println("Your are now in state '«state.name»'. Waiting for [«
                 state.transitions.map[event.name].join(', '].");
               lastEvent = eventSource.get();
               «FOR t : state.transitions»
                 if ("«t.event.name»".equals(lastEvent)) {
                   currentState = "«t.state.name»";
                   executeActions = true;
                 }
               «ENDFOR»
             }
           «ENDFOR»
           «FOR resetEvent : stm.events.filter[resetEvent]»
             if ("«resetEvent.name»".equals(lastEvent)) {
               System.out.println("Resetting state machine.");
               currentState = "«stm.states.head.name»";
               executeActions = true;
             }
           «ENDFOR»
           
         }
       ''')]
     ]
   ]
 }


That's all you need. With just the grammar and the Xtend code above you have implemented the full language! I've pushed the full project to github.
This is what the Java code generated for Mrs. H's controller looks like.

What Do You Get?

As already mentioned the expressions are feature complete and statically typed. The compiler can be run from any Java process (e.g. ant, maven, gradle, command line). Also the tooling is just like you would expect: content assist, coloring, hovers, refactorings, dead code analysis and even debugging work out of the box:


Content Assist For Expressions

Call-Hierarchy Integrated in JDT
Content Assist For Types

Dead Code Analysis






May 05, 2012

Eclipse Juno Milestone 7, available for download

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:

icon Eclipse Juno Milestone 7, available for download

Content assist in in package-info files

content assist pkg info Eclipse Juno Milestone 7, available for download

and enhanced static analysis of case statements:

switch missing default Eclipse Juno Milestone 7, available for download

Checkout the entire new and noteworthy or download the milestone and try it out:

http://download.eclipse.org/eclipse/downloads/drops4/S-4.2M7-201205031800/

May 04, 2012

It’s the small things that matter

It was at EclipseCon NA 2012 when I run into Denis Roy and mentionned that there’s a small thing that drives me crazy all time it comes to milestone weeks.

The none release builds are not mirrowed and so downloading a build to verify my bugs is takeing for hours because they are throttled. My suggestion was to provide developers privileged access to downloads from Eclipse.org servers to solve the problem and so Denis asked me to file a bug. It was fixed in less than one week.

So if you are an eclipse committer next time you go to download.eclipse.org pay close attention to the download site:

Yes it is the small things that matter!


May 03, 2012

Subwords completion

Not so long ago I was fairly happy with JDT's content assist, and then I started using Subwords completion from Code Recommenders project and now it is fair to say that I cannot write code without it! :-)

The idea is simple enough - you should not have to type a name from the beginning to find a match in the content assist popup. It really helps when I do not know if I have to 'find' an element or 'get' an element.

The feature is sophisticated enough to understand a rough shorthand e.g. dclr for declaration.


It is also sophisticated enough to understand that a method or type name in Java is composed of several words e.g. 'ty + dclr' finds all 'type' + 'declarations'.

Mylyn hidden gem - finding tasks to read.

We all know that feeling, having a dozen or so of incoming changes in Mylyn tasks, and a few hundreds of them in the list. Scrolling the whole list just to find those changed tasks may be a real pain.


I was wondering how it is possible that Mylyn does not offer filtering incoming changes. But quick look into Mylyn user guide revealed, that it is possible, but you need to switch to 'Scheduled' mode:


And then all dates will be visible - and some scheduling categories appear - and 'Incoming' tasks. That's what I was looking for:


I do not think this is a good idea to have such an important functionality so hidden - I have filled bug 378334: Make focusing on incoming tasks easier.

JDT 3.8/4.2 M7 - New and Noteworthy

As usual we devoted most of our time in M7 towards polish and performance, nevertheless we managed a few new and noteworthy items.

Firstly a word about bracket matching. So far, a matching bracket was found when the caret was placed immediately 'after' a bracket. This caused confusion because a user can also think in terms of placing the caret 'inside' or 'outside' a bracket pair, see bug 9503. We tweaked this during M6 so that the start bracket was highlighted when the caret is before (not after) the end bracket, i.e. bracket matching now worked when the caret was 'inside' a bracket pair. We realized that this was still not ideal, and also that the old behavior was broken which some of users were already accustomed to.

All this has been improved and now a matching bracket is found both when the caret is placed either immediately before or immediately after a bracket i.e. now bracket matching just works in all cases a user might expect it to work.
You can hover over a closing curly brace and see the source near the matching opening brace in a hover. This is helpful when you want to see the code near the start of a long code block. The hover also tells the number of lines in the code block.


The hover is also useful to temporarily 'highlight' a code block.

In M6 we had tweaked the warning on enum based switch statements, unfortunately the tweaks were not ideal and resulted in a bit of activity on bugzilla. This has been improved and new compiler options have been added to take care of all cases.

Those who are using null annotations will also discover that there are a few new quick fixes to help you a little bit.  One set of quick fixes help to quickly setup a project to use null annotations, i.e. appropriately add the annotations jar to the build path. The second set of quick fixes help you fix problems with respect to incorrect usage of null annotations, missing annotations etc. This second set is not yet perfect, see bug 337977

As always, feedback is greatly appreciated especially in the form of bug reports!

In other news, during this milestone I also earned commit rights on Platform/Text project :-)
May 02, 2012

RAP mobile 0.5.7 – New and Noteworthy

Once again we are releasing a new version of RAP mobile. This latest release 0.5.7 brings with it a very cool new feature that we call the “Client Canvas”. This extension of the classic SWT Canvas allows you to draw freehand on your screen with your stylus or even your finger.

Additional Features and API

Client Canvas

The client canvas provides you with basic freehand drawing options, allowing you to sketch with your stylus or your finger.  Like a regular drawing program, you can choose your color, brush size and opacity. And, you can step through the history of your drawings to undo/redo certain steps. To implement this feature we built upon the SWT Canvas object that allows us to change the pen properties via the established Canvas API. To get started with drawing you’ll just need to instantiate the com.eclipsesource.rap.mobile.widgets.ClientCanvas instead of the regular SWT Canvas. To demonstrate the Client Canvas we have created a sample where you try out a little draw-by-numbers.

client canvas RAP mobile 0.5.7   New and Noteworthy photo 1 RAP mobile 0.5.7   New and Noteworthy

Android

Browser

browser android RAP mobile 0.5.7   New and NoteworthyThe RAP mobile Android client is catching up with iOS on browser support. We now support the SWT Browser widget, allowing you to show full websites or custom HTML snippets inside your RAP mobile application. We also support the Browser.evaluate() and Browser.execute() methods to execute javascript in the browser on the Android device and to make it possible to send execution results back to server. The screenshot to the right shows examples that display a full website, an HTML snippet and the execution of a custom javascript function.

Support for various SWT Shell style flags

SWT offers many ways to customize the appearance of a shell via the style flags passed to the Shell constructor. These flags are also important to create SWT Dialogs. We now support the additional SWT shell styles TITLE, BORDER and *_MODAL. The following screenshots demonstrate the various style combinations.

dialogWithTitleAndIcon RAP mobile 0.5.7   New and Noteworthy dialogWithTitle RAP mobile 0.5.7   New and Noteworthy dialogWithoutTitle RAP mobile 0.5.7   New and Noteworthy dialogDefault RAP mobile 0.5.7   New and Noteworthy

Bugfixes

We are constantly working towards a high level of stability and solid performance, and in this release, we squashed some bugs which deserve special mention:

  • Fixed an issue where selecting elements inside a vertical ScrolledComposite was not possible
  • The GraphicalContext used android APIs not available on the supported basline version android 2.1 (API level 7).

iOS

You’re probably already enjoying the browser support on our RAP mobile iOS client, and can now also take the Client Canvas for a test drive.  Two other things that you might notice in this release are a new UI hint to show how to enter the developer SystemMenu and improvements to modalShell rendering and animation.

Video interview with Dave West on joining Tasktop as Chief Product Officer

I recently sat down with Dave West and Mik Kersten in Austin, TX in order to discuss the significance of Dave joining Tasktop. I think it comes across in the video but for me personally, one of the best things about Dave joining is that we are going to have a lot of fun while we transform the world.

Read more in Dave’s post, Mik’s post and my post on the topic.

Follow-up on the 2nd Cloud Workshop

The second OSGi Cloud Workshop was held during EclipseCon/OSGi DevCon 2012 last March. It was a very interesting morning with some good presentations and some great discussion. You can still find the presentations linked from here: http://www.osgi.org/Design/Cloud. We learned that people are already widely using OSGi in Cloud environments, and part of the morning was spent discussing what OSGi
May 01, 2012

Transparent and Open

The term “open and transparent” rolls off your tongue. While somewhat more cumbersome to say, I tend to prefer reversing the order: “transparent and open”. I prefer this because I believe that transparent precedes open; and far more open source projects are transparent than are open.

In my experience most people seem to understand transparent. “Transparent” means that you do things in a way that others can watch. Making source code available to anybody who wants a copy is one way of being transparent. Holding project-related discussions in a mailing list with an archive that’s accessible to anybody with an Internet connection is another way of being transparent. There are many more examples, like making your issue tracker available, hosting public discussion forums, and more.

Transparent does not mean open.

Open is a little harder. “Open” means that you do things in a way that others can participate. It means that you provide a level playing field: everybody participates using the same set of rules. Being transparent is easy; being open is hard.

Being open is more than just accepting code patches, and permitting outsiders to create bug reports.

Being open and having a true level playing field is hard because it requires that you give up absolute control. In an open project, control is shared. When the playing field is truly level–with the same set of rules applies to everybody–it’s possible that somebody can arrive at your project and change the way that you do things. This is not to say that anybody can show up and start making arbitrary changes to the code. Rather, it means that there exists a set of rules and conditions by which anybody can earn the right to participate as an equal member.

The rules need not be explicit or quantitative. Though, it does help if they are.

Take a look at the developers on your project. Do they all work for the same employer? When was the last time you added a new developer to the project? Do you accept contributions from “outside” contributors? How hard do you work to convert those “outside” contributors into full participants and decision makers on your project?

Operating in an open manner, actively courting participation to turn outsiders into insiders increases the diversity in the project and in so doing increases its strength and durability.

Transparent is good. Transparent and open is better.


Eclipse Community Survey: Give Us Your Feedback

For the last 3 years we have done a survey of the Eclipse community to better understand what developers are doing with Eclipse and open source.  The survey results have provided some interesting insights into the trends of the general software development community.

We have now launched the 2012 edition of the Eclipse Community Survey.   I’d like to invite everyone in the Eclipse community to complete the survey.   The survey should take 5-10 minutes to complete so it shouldn’t be too time consuming.   As an extra incentive, participants can enter a draw to win a pass to EclipseCon Europe 2012 or EclipseCon NA 2013 and some Eclipse SWAG.  In June, we will publish a complete report of the survey results.

Thank you in advanced to everyone that does fill out the survey.  The deadline to complete the survey is May 15, 2012.


Eclipse is happening in the Netherlands

In 2012, the first Eclipse Day will take place in the Netherlands on 27 September, 2012. It will be held at the Congress Center of the Delft University of Technology.




This year, the Eclipse Day in Delft will focus on tools and techniques to support the software development process, including software maintenance.

Call for Contribution
Call for papers is now open!If you would like to present your exciting tools or techniques to support software development or maintenance, or share an experience report at the Eclipse Day Delft 2012 please send your proposal by June 27, 2012 to eclipsedaydelft@gmail.com. For more details on the proposal format and requirements see the Call for papers.
April 29, 2012

Hanging up my fedora

Two weeks shy of ten years ago, I joined Red Hat as an intern on the Red Hat Database team. I was incredibly lucky to have gotten that internship and then to have been hired on full time 2 years later. I’ve had a great time working at Red Hat but have made the very difficult decision to leave. My last day is tomorrow, Monday April 30th.

Red Hat has provided me with many things: innumerable learning opportunities, career growth, exposure to open source communities, public speaking opportunities at conferences, and more. Most importantly, though, I’ve been given the chance to work with a lot of really amazing people both inside Red Hat and in a variety of vibrant Free Software and Open Source communities.

The Eclipse community has been my home for a few years now. It’s full of some of the most talented and passionate software developers I’ve ever met. I plan to remain involved in the Eclipse world and am looking forward to getting Linux Tools 1.0 released as a part of Juno and what comes after that!

I’ve excited for my new job but have a few weeks of down time in between where I hope to largely be AFK. I’ll write a blog entry here when I start my new job. I’ll still be around the open source world and if you’d like to contact me I’m reachable here on my blog or via various social networks. I wish everyone continued success both personally and professionally. Thanks for everything and I’ll see you around.

OpenChrom 0.6.0 “Synge” released – the open source chromatography and mass spectrometry software

I proudly announce the official OpenChrom release version 0.6.0 “Synge”.
Note, that Java 7 is required. The documentation is in progress and will be extended. Several improvements are available now, e.g.:

  • Varian *.SMS converter (experimental)
  • Basic mzXML support for the 3.1 and 3.2 specifications
  • Peak identification batch support for peaks modelled by PARAFAC/MCR algorithms
  • Chromatogram database plug-in
  • PDF and ZIP chromatogram export capabilities
  • Export chromatogram peaks to *.msp format, which can be loaded by the NIST-DB
  • Better process feedback
  • Completely reworked marketplace
  • Full update functionality

Go there, get it:
http://www.openchrom.net/main/content/downloads.php


April 27, 2012

1.0.2 released

i'm pleased to announce the 1.0.2 release of perlipse.

here's what's new and noteworthy:

  • java 1.6 is now required
  • updated plugin versions to use a 'qualifier'
  • added 'branding' plugin
  • no longer uses deprecated dltk methods*
  • parser bug fixes and AST work
  • ppi4j parser is now the default parser on new installations
  • issue 26 has been fixed and a new preference introduced to set the color of back tick strings

the thing i am most excited about in this release though are the new icons provided by new project contributor, james lauer!

head on over to the project page for more details.

* the one exception to this is code folding which is going to require an entire re-write.

Hosted Continuous Integration

Chris blogged about Travis CI a while ago, a site which provides free CI for github projects. Unfortunately, Travis is for github projects only. So, I was wondering if there are other hosted CI solutions available. Here are the results a short google session, some tools are also suggested at stackoverflow:
SiteCI systemBuild systemVCSTriggerNotificationPricingDeploymentComment
Travis CI Travis Maven, Ant, and others git (github only) github: Travis hook email free for OS no still alpha
CloudBees, FOSS free Jenkins Maven git, SVN, and others github: Jenkins hook ? free for OS ?
FaZend Hudson Maven, Ant, and others SVN ? email free ? still beta
CodeBetter TeamCity Maven git, SVN, and others github: TeamCity hook email, Jabber, and others free for OS ?
Shining Panda Jenkins Maven git, SVN, and others github: Jenkins hook email €0.36 / hour ? Focused on Python
Jenkins Hosting (Bubbleware Technology) Jenkins ? git, SVN ? ? free for OS (+ Amazon EC2 fees) ?
continuous.io/ ? ? ? ? ? free for OS (+ Amazon EC2 fees) ?
I focused on support for Java projects and Maven/Ant support. Some remarks:
  • Trigger: This means how the build is triggered. This is of course not a feature of the CI system itself, but of the source code repository. Github or Bitbucket provide some hooks, unfortunately, EclipseLabs (GoogleCode) doesn't, or does it?
  • Notification: This means how the system does notify the user of the build result. After a successful build, one probably want to somehow deploy the created artifacts.
  • Deployment: Actually, I'm looking for a solution of copying the artifacts, which actually are a P2 repository, to some download or update site. Of course, this could be achieved by Maven plugins or Ant tasks, however, the crucial point is how to pass some credentials (user name, pass word) to the build system. Especially if you are building an open source project, you do not want to write this information into the maven script. Seems as if this is a common problem. If this problem were solved by Travis, it would be the best solution, at least for github projects.

Actually, it is very hard to determine the features of the different solutions. Many projects seem to be in a very early stage, and some projects announced are already gone (e.g., Mike CI). Most projects are cloud based, some use Amazon EC2 and users need their own Amazon EC2 account. For open source projects, it is often required to fill out some request form, and I don't know whether all projects are accepted.

Leave me a comment if you have any experience with a solution listed above, or if you know of other hosted CI systems.

Inactive Blogs