Subscribe: Planet Eclipse
Added By: Feedage Forager Feedage Grade B rated
Language: English
code  debug protocol  debug  eclipse org  eclipse  find  java  language  lsp  new  open  protocol  server  set  tools 
Rate this Feed
Rate this feedRate this feedRate this feedRate this feedRate this feed
Rate this feed 1 starRate this feed 2 starRate this feed 3 starRate this feed 4 starRate this feed 5 star

Comments (0)

Feed Details and Statistics Feed Statistics
Preview: Planet Eclipse

Planet Eclipse

Planet Eclipse -


Kichwa Coders: Beware diversity-led marketing (& three cheers for these companies doing diversity right)

Fri, 17 Nov 2017 11:10:49 +0000

There’s an increased level of discussion on improving diversity in tech communities. Or maybe it was always there and I just started paying attention. Either way, it’s a really good thing. But in the mix there is definitely a certain amount of diversity-led marketing e.g “We need more women-in-tech! Women, sign up for this tech course here…”.  Some are more obvious than others. What about tech conferences? Take the case of a tech conference getting some promotion off the back of free diversity tickets. Is that just diversity-led marketing and a bad thing? After all it’s great to get underrepresented folks into conferences, right? The answer is if it is done in isolation then it is probably just self-serving marketing and pr. Underrepresented folks aren’t merely props for your agenda Diversity is complicated. It’s easy to get it wrong and end up like the conference organizers who violated their own code-of-conduct and had a speaker cancel their talk.  Or fall into the Google case of  trying to inspire teen girls to code while simultaneously systematically limiting the careers of women in your company.  Again diversity is complicated, so we all want to focus our energies on those doing it the right way. Open source has a worse record than most when it comes to diversity.  At this year’s Eclipsecon Europe, as with every tech conference I attend, I did my own evaluation of what’s being done well and not so well. This year, I noticed a few companies who are doing something right as evidenced by the women and underrepresented minorities that are in leadership positions. IBM – IBM had a noticeably improved presence at this year’s conference. I learnt that they actively encouraged speaker proposals. If a talk is accepted, there are good company policies in place to ensure speakers can travel and attend the conferences. As a result we had four awesome women speakers from IBM, not just any speakers, but experts in their respective fields: Eclipse JDT leads Noopur Gupta and Sarika Sinha, Eclipse SWT committer Lakshmi Shanmugam and Eclipse Microprofile committer Emily Jiang. OBEO – OBEO specialize in graphical modelling and are well respected in the community. Melanie Bats is one of the rockstars in the community, doing terrific and imaginitive tech talks and also recently took over as the Eclipse Planning council lead. OBEO recently promoted Melanie to CTO, which is written about beautifully here: Zero-to-CTO. BREDEX – BREDEX specialize in testing and are well represented at EclipseCon by the indefatigable Alex Schladebeck. Alex can be found leading the highly enjoyable Kahoot quiz at EclipseCon as well as heading up the Project Quality day. Doing great things in the testing world, it was great to learn that Alex has been promoted to  ‘Head of Software Quality and Test Consulting’ at BREDEX. #IBMers at #EclipseCon — Noopur Gupta (@noopur2507) October 29, 2017 These three companies set a great example for the rest of us, not to mention make us better at our work as a community. Which brings me to the picture at the top of this blog post. I like to get setup really early before I do a tech talk, especially one in a huge room with a massive screen. So while getting setup, Jonah Graham of Kichwa Coders and Sarika Sinha of IBM got into a discussion about debugger protocols and threading issues. To discuss the finer points my laptop was commandeered and out came the code. It was one of those serendipitous moments and I didn’t want my pre-talk nerves to stop them. So I took a seat and took pictures while taking deep breaths. I think my talk went well anyway. That one conversation really informed our thinking on our work on the future of debuggers. And really it reminded me in a powerful way how things are always better the more different types of people you get involved. And little moments like these make it all worthwhile, and worth doing right, in the best way possible. [...]

Donald Raab: Preposition Preference

Wed, 15 Nov 2017 21:53:23 +0000

What’s up? A preposition.Photo taken at Grounds for Sculpture in Hamilton, NJA friend of mine at Rutgers University would always respond to the question “What’s up?” with the consistent witty response: “A preposition.” I fell into this trap far too many times.Have you ever thought about how much we use prepositions in our Java APIs?We use several different prepositions in APIs in Eclipse Collections. Each one conveys a different meaning. Some prepositions that appear in Eclipse Collections multiple times are “with, of, by, as, to, from, into”. When we use a preposition in an API, it should help convey meaning clearly. If it doesn’t, then we would have been better off without it.Two prepositions enter. One preposition leaves.At JavaOne this year, I described a battle we once had between two prepositions for naming our collection factory methods in the Eclipse Collections API. The battle was between of and with.MutableList list = Lists.mutable.of("1", "2", "3"); vs.MutableList list = Lists.mutable.with("1", "2", "3");After an intense debate, we wound up with both options for our collection factory classes. We thought this was one place where we could provide multiple options to allow developers to use their own preference. This however was not the end of the story. Sometimes there is more than just a single battle to be won.The prepositions of and with both work well for naming factory methods for creating collections. I personally prefer with, mostly because this is what was used with Smalltalk. In Smalltalk, I would regularly write the following:|set|set := Set with: ‘1’ with: ‘2’ with: ‘3’.The following is the equivalent using Java with Eclipse Collections.MutableSet set = Sets.mutable.with("1", "2", "3");If you prefer, you can also create a collection using the of factory method.MutableSet set = Sets.mutable.of("1", "2", "3");There are also forms that take an Iterable as a parameter. These are called ofAll and withAll.In java.util.Collection, there are methods for adding and removing elements to and from collections. They are named add, addAll, remove and removeAll. These four methods return boolean. This makes them unsuitable for writing code fluently.We have our own Mutable interfaces in Eclipse Collections, so we knew we could fix the fluency problem by using a one of the two prepositions. We decided to go with with, because with has a natural opposite named without.Set set = Sets.mutable.with("1", "2", "3") .with("4") .without("2");Assert.assertEquals(Sets.mutable.with("1", "3", "4"), set);This naming pattern also worked well when adding elements via an Iterable.Set set = Sets.mutable.with("1", "2", "3") .withAll(Lists.mutable.with("4")) .withoutAll(Lists.mutable.with("1", "3"));Assert.assertEquals(Sets.mutable.with("2", "4"), set);As you can see, we have with, withAll, without and withoutAll as instance methods directly on our mutable collections. Instead of returning boolean like add or remove, these methods return this, which is the collection that the method is operating on. These methods have good symmetry with the existing methods on Collection that return boolean, and also with each other.We extended this pattern to our immutable collections as well.ImmutableSet set = Sets.immutable.with("1", "2", "3") .newWithAll(Lists.mutable.with("4")) .newWithoutAll(Lists.mutable.with("1", "3"));Assert.assertEquals(Sets.mutable.with("2", "4"), set);In the mutable case, the withAll and withoutAll methods mutate the existing collection. In the newWithAll and newWithoutAll cases, a new collection is returned each time, thus preserving the immutability of the original collection.Attack Of the ClonesThe preposition of lost the battle of the instance-based collection factory methods in Eclipse Collections, because there is no good natural opposite[...]

Mike Milinkovich: Help Pick the New Name for Java EE

Wed, 15 Nov 2017 16:29:03 +0000

This blog post is based on the text of Eclipse EE4J’s very first GitHub Issue. Please join the conversation over there! We need a new brand name for the set of specifications that will be created by the new community process. This brand name will also become a certification mark in the industry for compatible, independent implementations. The open source projects that fall under the Eclipse EE4J top level project will be one such implementation. In short, we need a new name to replace “Java EE”. Much like the OpenJDK project implements the Java SE Platform specification, the EE4J projects will provide implementations of a set of specifications that we today call Java EE: we need a brand name for this set of specifications. With this in mind, we are initiating a community process to select the brand name. This process will be managed by the EE4J Project Management Committee (“PMC”) with assistance from the Eclipse Management Organization (“EMO”). The name that is selected by this process must pass legal and other trademark searches to ensure that the names are available for use. As a result, it is possible that the favoured selection will not be the ultimate choice. The final decision will be made by the EMO Executive Director (“EMO(ED)”) in consultation with the PMC. The process is described in greater detail below. Nominations Names can be nominated by anyone in the community via this GitHub Issue record. Nominations will be open from November 15 until November 30, 2018. Naming Guidelines All suggested names must conform to the following: They must conform to Oracle’s trademark usage guidelines. Amongst other things this means that the name cannot start with the word “Java”. They must conform to the Eclipse Foundation trademark guidelines. They must not be obscene, sexist, racist, controversial, etc., and they must not be frivolous (e.g. we’re not going to choose Boaty McBoatface or the like.) Any suggested names which fail to meet the above criteria will be rejected. Name Selection Process The process will be executed as follows: Members of the community will be invited to enter their nominations into the specified channel; At the end of the nomination period, the names suggested by the community will be reviewed by the PMC to identify those which meet the criteria specified in the by the naming guidelines (depending on response, the PMC may decide to further reduce the list to a manageable size); The PMC will then initiate a community vote using the CIVS system (which will produce an overall ranking of the choices); and The results of the vote will be delivered to the EMO(ED) who will engage in the required legal and other trademark searches to ensure that the names are available for use, and consult with the PMC to make the final decision. Since we have no idea what sort of community response to expect, it is difficult to time box anything other than the initial nomination process. But this will be an open and transparent process, and we invite the community to engage in all aspects of it. There is a great deal of legal, marketing, and community thought that goes into selecting an industry brand, so it’s important that we get this right. This may take a little time.Filed under: Foundation [...]

Eclipse Announcements: Open IoT Challenge 4.0 | Extended Deadline Nov 20

Wed, 15 Nov 2017 10:30:00 +0000

One last week to submit your open IoT solution idea. You can then work on it until March 15. Submit now!(image)

Christopher Guindon: Say Goodbye to the Eclipse Foundation Nova Theme

Wed, 15 Nov 2017 00:00:00 +0000

The Eclipse Foundation is planning on removing a few deprecated components from in an effort to reduce our code base for We are using Bug 526827 - Fall clean up of to track the following tasks: Bug 468336 - Remove support for the Nova theme in Bug 526824 - Remove yui from Bug 526825 - Remove Services_JSON from Bug 526826 - Remove JQuery from I believe this “clean up” exercise is our first step towards the execution of my long term plan for migrating our code base to follow recommendations from the PHP Framework Interop Group. I will be writing about this subject in a future blog post but for now, you can take a look at Bug 496514 - PHP sites maintained by the EF should follow recommendations from the Framework Interop Group. Bug 468336 - Remove support for the Nova theme in During the summer of 2014, my team was responsible for implementing the redesign of via Bug 432342 - Website Redesign 2014. We created a new look and feel called Solstice and since then, we’ve been busy migrating all of our web properties. Today, I am happy to announce that it’s finally time to retire the Eclipse Nova theme. We are planning on removing the Nova theme from on December 5th, 2017. The Solstice look and feel will become the default theme for all web pages that are currently being served with Nova. This change will be affecting the following websites: Celebrating 10 years of Eclipse Agent Modeling Platform PEL Designer Project BPMN2 Modeler CDO Eclipse CDT (C/C++ Development Tooling) Damos EGF EMF Refactor Equinox EMF Facet FMC - Fundamental Modeling Concepts GEF3D Gemini Gemini DBAccess Gemini JPA Henshin Java Workflow Tooling (JWT) Libra Maven Integration for WTP Mangrove - SOA Modeling Framework Model to Model Transformation (MMT) Graphical Modeling Project (GMP) Model Development Tools (MDT) Marketplace Client OSEE: The Open System Engineering Environment Pulsar R4E RT Skalli SOA Platform Project The Spatiotemporal Epidemiological Modeler (STEM) Project Tigerstripe Tycho - Building Eclipse plug-ins with maven UOMo Vex - A Visual Editor for XML Please use Bug 468336 - Remove support for the Nova theme in to discuss any concerns regarding this change.[...]

Kichwa Coders: Debug Protocol: Coming soon to an IDE near you

Tue, 14 Nov 2017 11:43:35 +0000

Our absolute favourite type of talk to do is one where we’ve been working on something so cutting-edge that we don’t have all the answers yet. This was the case with our work on the debug protocol and our talk at EclipseCon Europe. We got to take where we’d gotten to and present it to a room full of smart people who were generous enough to show up, ask questions and give us their insightful feedback. The talk gives an overview of the debug protocol then demonstrates it working in: VS Code Eclipse IDE Eclipse Che We demo 7 different types of debug functionality as supported by the protocol: Launch Source lookup Call stacks Breakpoints Variables Run control (step, continue, etc) Termination Full house for Tracy and Jonah's Debug Server Protocol talk in the last slot of the conference. The IDE evolves. — Doug Schaefer (@dougschaefer) October 26, 2017 @JonahGrahamKC and @tracymiranda demonstrating the potential of Microsoft’s Debug Protocol at the @EclipseCon — Andreas Rytina (@andyrytina) October 26, 2017 Another great discussion about tooling protocols. Debug Server protocol is coming in #EclipseChe and desktop IDE. @kichwacoders #EclipseCon — Stevan Le Meur (@stevanLM) October 26, 2017 OK, so we are amazing at building debuggers but we are completely hopeless at repeating questions so you can hear them in presentation talk recordings. And the questions we were asked were really good, so here is my attempt to record them, as well as repost the answers plus update with the latest state of affairs. Where can I find the code? Here’s where you can find the git repo: But even better, we are actively working on pull requests so that the code will become part of existing projects LSP4J, LSP4E and Eclipse Che. You can checkout the first PR for LSP4J here: Does the debug protocol support drop to frame? What about evaluate expressions? Hovers? Step into? Definitely yes to evaluate expressions, hovers and step into. Don’t think it supports drop to frame, not obviously but may be there using different terminology. Is the protocol extensible? Yes, so you could add functionality like drop-to-frame. But the extensibility is not formalized so that is something we would like to help address. Is the protocol blocking? No it is asynchronous. Does it use JSON-RPC just like the Language Server Protocol? No it pre-dates JSON-RPC 2.0 and uses its own custom protocol. It is similar enough to JSON-RPC. While it would be nice to have the same protocol being used, it is probably not worth the effort to change this given the number of existing debug adapter implementations already out in the wild. Also thanks to all those who left written feedback on the talk, especially the person who had this to say: “A really good initiative. Don’t over do it though by pushing making the protocol complex just to support features of one language, seems like it is a case for C/C++, i.e. registers support. It could be a separate extension.” Great point, thanks for the input!   [...]

vert.x project: Eclipse Vert.x meets GraphQL

Tue, 14 Nov 2017 00:00:00 +0000

I recently added GraphQL support to Gentics Mesh and I thought it would be a good idea to boil down the essence of my implementation in example so that I could share it in a simpler form. The example I’m about to show will not cover all aspects that I have added to the Gentics Mesh API (e.g. paging, search and error handling) but it will give you a basic overview of the parts that I put together. GraphQL does not require a GraphDB even if the name might suggest it. Using a graphdb in combination with GraphQL does nevertheless provide you with some advantages which I will highlight later on. What is GraphQL? What is it good for? GraphQL as the name suggests is a new query language which can be used to load exactly the amount of data which you ask for. The query is defined in way that the query fields correlate to the JSON data that is being retrieved. In our StarWars Demo domain model this query will load the name of human 1001 which is Darth Vader. { vader: human(id: 1001) { name } } Would result in: { "data": { "vader": { "name": "Darth Vader" } } } The Demo App The demo application I build makes use of the graphql-java library. The data is being stored in a graph database. I use OrientDB in combination with the OGM Ferma to provide a data access layer. GraphQL does not necessarily require a graph database but in this example I will make use of one and highlight the benefits of using a GraphDB for my usecase. You can find the sources here: Data The StarWarsData class creates a Graph which contains the Star Wars Movies and Characters, Planets and their relations. The model is fairly simple. There is a single StarWarsRoot vertex which acts as a start element for various aggregation vertices: Movies are stored in MovieRoot, Planets in PlanetsRoot, Characters are stored in HumansRoot and DroidsRoot. The model classes are used for wrappers of the specific graph vertices. The Ferma OGM is used to provide these wrappers. Each class contains methods which can be used to traverse the graph to locate the needed vertices. The found vertices are in turn again wrapped and can be used to locate other graph elements. Schema The next thing we need is the GraphQL schema. The schema describes each element which can be retrieved. It also describes the properties and relationships for these elements. The graphql-java library provides an API to create the object types and schema information. private GraphQLObjectType createMovieType() { return newObject().name("Movie") .description("One of the films in the Star Wars universe.") // .title .field(newFieldDefinition().name("title") .description("Title of the episode.") .type(GraphQLString) .dataFetcher((env) -> { Movie movie = env.getSource(); return movie.getName(); })) // .description .field(newFieldDefinition().name("description") .description("Description of the episode.") .type(GraphQLString)) .build(); } A type can be referenced via a GraphQLTypeReference once it has been created and added to the schema. This is especially important if you need to add fields which reference other types. Data fetchers are used to access the context, traverse the graph and retrieve properties from graph elements. Another great source to learn more about the schema options is the GarfieldSchema example. Finally all the created types must be referenced by a central object type QueryType. The query type object is basically the root object for the query. It defines what query options are initially possible. In our case it is possible to load the hero of the sage, specific movies, humans or droids. Verticle The GraphQLVerticle is used to accept the GraphQL request and process it. The verticle also contains a StaticHandler to provide the Graphiql Browser web interface. T[...]

Holger Voormann: Eclipse Oxygen.1a IDE Improvements: Java 9, JUnit 5, General, Gradle and PHP

Sat, 11 Nov 2017 13:44:31 +0000

Oxygen.1a (4.7.1a) was released two weeks after Oxygen.1 (4.7.1) on October 11, 2017. Oxygen.1 includes bug fixes and minor improvements. Since Oxygen.1a, the Eclipse IDE runs out of the box with Java 9 and supports development for Java 9 as well as testing with JUnit 5. Many thanks to all of you who have contributed in any way. As usual I made a short video that shows some improvements in action: Java 9 (see also Eclipse Project 4.7.1a New and Noteworthy – Java 9 and Eclipse Wiki – Java 9 Examples) 0:37 Creation of a Java 9 application that consists of two modules 2:05 Exporting the application to JARs 2:21 Running the exported application from the command line JUnit 5 (see also Eclipse Project 4.7.1a New and Noteworthy – JUnit 5) 3:54 New Junit 5 alias Jupiter test case 4:08 assertThrows(...) 4:32 assertAll(...) 4:48 @DisplayName 4:55 @Disabled 5:00 @ParameterizedTest with @ValueSource 5:21 @ParameterizedTest with @CsvSource 5:34 @TestFactory 5:55 @Tag 6:07 @Nested General (see also in Eclipse 4.7.1/4.7.1a closed bugs) 6:28 Bug in three-way compare editor has been fixed 6:50 RSS Feed reader 7:40 Dark theme improvements Gradle (see also Eclipse Buildship 2.1.0 New and Noteworthy) 7:59 Settings on run configuration, project and project level 8:12 Build scans PHP (see also in PDT 5.1 closed bugs) 8:45 true, false and null as constants in lower-case only 9:03 PHPDoc is now correctly generated also for boolean parameters 9:07 Generate getters for a boolean field: prefix is instead of get More details about Java 9, JUnit 5 and other Eclipse topics can be seen in the recently uploaded 177 EclipseCon Europe 2017 videos with a total duration of more than 3 days and 19 hours. Next releases (calendar / ICAL): Oxygen.2 on December 20, 2017 Oxygen.3 on March 21, 2018 Photon.0 on June 27, 2018 Upgrade to Eclipse Oxygen.1a or download Eclipse Oxygen.1a and happy coding! [...]

EclipseCon Europe 2017: Replay EclipseCon Europe 2017

Fri, 10 Nov 2017 13:04:51 +0000

If you missed a talk at this year's conference, there's a good chance that you'll be able to replay it. You'll find most of the talks from this year are online.

Kichwa Coders: Debug Protocol vs Language Server Protocol

Wed, 08 Nov 2017 13:09:47 +0000

It is safe to say that the language server protocol (LSP) is the future of developer tools.  When it comes to the equivalent for debug, the debug protocol is ‘LSP for debuggers’. It is a useful tagline but here are three key differences to be aware of:

  1. State – the big mindshift with LSP is that servers are stateless. The clients store all the state e.g. the files themselves and settings (what language, classpath, etc). Any state kept on the serverside (e.g. the index) is usually purely for performance reasons. What this means is that, for instance, servers can be restarted and carry on seamlessly without having to know anything of what happened in the system beforehand. On the other hand, the debug protocol is not stateless, servers need to know all sorts of state and sequences of what has happened, so the design space is different for this protocol.
  2. JSON RPC 2.0 Spec (and cancellable requests) – The LSP defines JSON-RPC messages for requests, responses and notifications. The debug protocol was created before JSON RPC 2.0 spec was finalized, debug protocol uses a similar structure, but it is not cross compatible. For example, the JSON field name for the method to call is command in debug protocol and method in JSON RPC 2.0. The type of message (event, request, or response) is explicit in DSP in the type field, but is implicit in JSON RPC 2.0 (based on presence of the combination of method, id, result and error fields). However using a library like org.eclipse.lsp4j.jsonrpc can hide such differences and provide equivalent higher level abstractions (like Java interfaces) and leave the library to handle the differences. The LSP has a nice feature, cancellable requests, that is an extension to JSON RPC2.0 that is also not available in the debug protocol:
  3. Ubiquity – although the LSP was defined originally for use in VS Code do you know that the 2 flagship languages for VS Code are not based on LSP? Typescript and javascript language tooling is not done using LSP. On the other hand the debug protocol does underpin all the debugger implementations in VS Code, including the flagship node debuggers for V8 and Chrome.

All that being said, it’s worth repeating the common benefits of both protocols which are:

  • good separation of client/server
  • building the tooling once and reusing it across IDEs and editors i.e. vs code, eclipse, atom, etc
  • better unit/isolated testing
  • write in language most suited to the job
  • more effective way for tool developers to keep pace with underlying tools

(image) (image)

InfoQ Eclipse feed: Accelerating the Adoption of Java Microservices with Eclipse MicroProfile

Wed, 08 Nov 2017 06:30:00 +0000


InfoQ caught up with Emily Jiang from IBM to hear about the new Eclipse MicroProfile project and the new release, with extended fault tolerance and other new features.

By Monica Beckwith

Lorenzo Bettini: How to add Eclipse launcher in Gnome dock

Tue, 07 Nov 2017 13:00:55 +0000

In this post I’ll show how to add an Eclipse launcher as a favorite (pinned) application in the Gnome dock (I’m using Ubuntu Artful). This post is inspired by First of all, you need to create a .desktop file, where you need to specify the full path of your Eclipse installation:[Desktop Entry] Version=Oxygen Name=Eclipse Java Comment=Eclipse is an IDE Exec=/home/bettini/eclipse/java-latest-released/eclipse/eclipse Icon=/home/bettini/eclipse/java-latest-released/eclipse/icon.xpm Terminal=false Type=Application Categories=Utility;Application;Development;This is relative to my installation of Eclipse which is in the folder /home/bettini/eclipse/java-latest-released/eclipse, note the executable “eclipse” and the “icon.xpm”. The name “Eclipse Java” is what will appear as the launcher name both in Gnome applications and later in the dock. Make this file executable. Copy this file in your home folder in .local/share/applications. Now in Gnome Activities search for such a launcher and it should appear: Select it and make sure that Eclipse effectively runs. Unfortunately, in the dock, there’s no contextual menu for you to add it as a favorite and pin it to the dock: But you can still add it to the dock favorites (and thus pin it there) by using the corresponding contextual menu that is available when the launcher appears in the Activities: And there you go: the Eclipse launcher is now on your dock and it’s there to stay   Be Sociable, Share! Tweet[...]

Fabio Zadrozny: Macro keyboard recording on Eclipse / LiClipse 4.3.1

Tue, 07 Nov 2017 12:21:46 +0000

I'm currently working on a new engine for record and playback of keyboard macros in Eclipse. It's currently available as a project in the Eclipse incubation (see for more details and how to install it to Eclipse) and I hope it'll be a part of Eclipse 4.8 -- the current version should be stable already, but it needs some hardening, so, feedback is appreciated ;)

Also, I decided to integrate it into LiClipse too (so, the new 4.3.1 release of LiClipse adds support to record and playback of macros).

The idea is that this will fix a long standing (and popular) feature request in Eclipse -- -- and a pet peeve on mine too as it's not uncommon for me to copy a file to notepad++ to make a record/playback and then copy it back to Eclipse... this really should be builtin (as a note, the rectangular edition in Eclipse, multiple cursors in LiClipse  and regexps in the find dialog do solve a number of use-cases, but I find that record/playback on some cases is invaluable).

Now, why not just use Well, I've used it some times but unfortunately I didn't find it as stable as I wanted -- it's really hard to come up with a stable record of what's happening in Eclipse -- so, I think an effective solution must really be builtin to Eclipse in order to be effective.

Also, in order to be feasible, there are some limitations in the scope on what it should accomplish: it's not a general Eclipse IDE record/playback, but rather a record/playback in the scope of an editor, so, it should properly record/playback the keystrokes in the editor and the resulting actions from such commands (although the implementation is done in a way which could support more general recording in Eclipse, but this would require changing many other parts of the IDE to be aware of the macro record/playback, so, I'm not sure it'd be feasible).

This means that some particular implementations which don't work through commands will have to be adapted -- so, for instance, record in the find dialog currently doesn't work because it doesn't work through commands and there's no way to listen that a find action was actually triggered from there... right now, the workaround is using the Incremental Find (Ctrl+J) and Find Next (Ctrl+K) commands when on record mode (my idea is taking a look at it after the macro record/playback engine is integrated to core Eclipse as I don't think it's a blocker due to having a proper workaround through actual commands), the focus now is making it solid for record and playback of commands which are related to the text editor.

So, that's it, hope you enjoy macro recording on LiClipse 4.3.1 -- and hopefully on Eclipse itself later on ;)

JBoss Tools Team: JBoss Tools and Red Hat Developer Studio for Eclipse Oxygen.1a

Mon, 06 Nov 2017 11:31:13 +0000

JBoss Tools 4.5.1 and Red Hat JBoss Developer Studio 11.1 for Eclipse Oxygen.1a are here waiting for you. Check it out! Installation JBoss Developer Studio comes with everything pre-bundled in its installer. Simply download it from our JBoss Products page and run it like this: java -jar jboss-devstudio-.jar JBoss Tools or Bring-Your-Own-Eclipse (BYOE) JBoss Developer Studio require a bit more: This release requires at least Eclipse 4.7 (Oxygen) but we recommend using the latest Eclipse 4.7.1a Oxygen JEE Bundle since then you get most of the dependencies preinstalled. Once you have installed Eclipse, you can either find us on the Eclipse Marketplace under "JBoss Tools" or "Red Hat JBoss Developer Studio". For JBoss Tools, you can also use our update site directly. What is new? Our main focus for this release was on adoption of Java9, improvements for container based development and bug fixing. Eclipse Oxygen itself has a lot of new cool stuff but let me highlight just a few updates in both Eclipse Oxygen and JBoss Tools plugins that I think are worth mentioning. OpenShift 3 CDK 3.2 Server Adapter A new server adapter has been added to support the next generation of CDK 3.2. While the server adapter itself has limited functionality, it is able to start and stop the CDK virtual machine via its minishift binary. Simply hit Ctrl+3 (Cmd+3 on OSX) and type CDK, that will bring up a command to setup and/or launch the CDK server adapter. You should see the old CDK 2 server adapter along with the new CDK 3 one (labeled Red Hat Container Development Kit 3.2+ ). All you have to do is set the credentials for your Red Hat account, the location of the CDK’s minishift binary file, the type of virtualization hypervisor and an optional CDK profile name. Once you’re finished, a new CDK Server adapter will then be created and visible in the Servers view. Once the server is started, Docker and OpenShift connections should appear in their respective views, allowing the user to quickly create a new Openshift application and begin developing their AwesomeApp in a highly-replicatable environment. New command to tune resource limits A new command has been added to tune resource limits (CPU, memory) on an OpenShift deployment. It’s available for a Service, a DeploymentConfig, a ReplicationController or a Pod. To activate it, go the the OpenShift explorer, select the OpenShift resource, right click and select Edit resource limits. The following dialog will show up: After you changed the resource limits for this deployment, it will be updated and new pods will be spawned (not for ReplicationController) Discover Docker registry URL for OpenShift connections When an OpenShift connection is created, the Docker registry URL is empty. When the CDK is started through the CDK server adapter, an OpenShift [...]

Cedric Brun: ⦏Breaking News Eclipse Sirius⦎ SiriusCon 2017!

Mon, 06 Nov 2017 00:00:00 +0000

SiriusCon 2017 has never been so close! The third edition of this conference will take place this Thursday, the 9th of November in the beautiful Paris! A whole day of exclusive content: presentations with a specific focus on Eclipse Sirius itself, others about companion technologies and feedback from users who used these technologies to build their custom tools! This year these tools are covering activities ranging from the Risk Analysis in Industry Supply Chains to the design and management of REST API for an enterprise information system. One can learn a lot from the experiences of the others and I’m often amazed at the tools which are getting built.

We’ll start the day with a keynote by Mike Milinkovich, the executive director of the Eclipse Foundation. It’s an honor to host such an important actor in the Open-Source movement, he has a unique perspective regarding what happened in the Software Industry the last decade and how Open-Source enabled worldwide collaborations. This keynote is especially relevant for such a conference as Sirius is part of a rich ecosystem of technologies, products and companies and is an integral part of the Eclipse world.

The event also features talks with a particular focus: document generation from models, simulation and animation, diagram layouting, using Xtext and Sirius or learning how to smooth the user experience of your graphical modeler. Last but not least, tutorials during the afternoon to either discover or sharpen your skills! Find out the complete program.

Content is one thing, but we are also organizing the event so that you will enjoy a nice time in a friendly atmosphere. This is the occasion to get in touch with the team, chat with other users, directly provide your feedback or get some direct help with the clinic. We’ll also prepare a showcase area to demonstrate tools and technologies, both for beginners and advanced users. Do yourself a favor and do not hesitate to reach out to people here.

You get exclusive content at SiriusCon, insights you can’t find anywhere else, sharp details about the technology, its use and deployment and its direction, and you also get to enjoy lively chats in a delightful place, right next to the Montparnasse train station (at the Novotel Paris Vaugirard). The event is free but the room is limited, make sure to register soon!


⦏Breaking News Eclipse Sirius⦎ SiriusCon 2017! was originally published by Cédric Brun at CTO CEO @ Obeo on November 06, 2017.

Nikhil Nanivadekar: UnifiedMap: How it works?

Sun, 05 Nov 2017 15:14:11 +0000

UnifiedMap: How it works?Eclipse Collections comes with it’s own implementations of List, Set and Map. It also has additional data structures like Multimap, Bag and an entire Primitive Collections hierarchy. In this blog we will take a look under the hood of UnifiedMap.UnifiedMapUnifiedMap is the Map implementation of Eclipse Collections and is implemented very differently than a JDK is backed by a table of Entry objects. The Entry implementation in HashMap has hashcode, key, value, next as members, HashMap essentially caches the hashcode of keys.UnifiedMap schematicA UnifiedMap is backed by an array where keys and values occupy alternate slots in the array :protected transient Object[] table . The flattened array structure stores only the keys and values there by creating a leaner Map implementation with reduced memory footprint. Added benefit of having keys and values in consecutive slots is improved cache locality.Collisions in the main array are handled by putting a special object called CHAINED_KEY in key slot. The value slot of CHAINED_KEY (slot after CHAINED_KEY slot) contains another Object[] array similar to main array called CHAINED_OBJECT with keys and values in alternate slots.Look ups in UnifiedMap use a standard hashcode index algorithm to find the location of a key in the array. If a key is not a CHAINED_KEY then the next slot contains the value. If a key is a CHAINED_KEY then the CHAINED_OBJECT is evaluated linearly to find the required key and the next slot in CHAINED_OBJECT contains the value.Since UnifiedMap does not cache the hashcode, for each look up, hashcode needs to be computed. So, the performance of UnifiedMap is directly dependent on the hashcode implementation of the key.Below are a few memory and performance comparisons between JDK 1.8 HashMap and Eclipse Collections 9.0.0 UnifiedMap.Memory Footprint (lower number the better)Memory Comparison HashMap vs UnifiedMapMemory Comparison HashMap vs UnifiedMapPerformance Tests (higher number the better)Source code for memory tests and performance tests is available on GitHub.Summary: Eclipse Collections UnifiedMap has ~50% smaller memory footprint compared to JDK HashMap, but that comes with a minor performance implication.Eclipse Collections is open for contributions. If you like it star it.UnifiedMap: How it works? was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.[...]

Maximilian and Jonas: Eclipse DemoCamp Munich: Registration opens today

Fri, 03 Nov 2017 15:20:46 +0000

Eclipse Democamp Munich December 4th 2017 – Registration opens today!

We are pleased to invite you to participate in the Eclipse DemoCamp Munich 2017. The DemoCamp Munich is one the biggest DemoCamps worldwide and therefore an excellent opportunity to showcase all the cool, new and interesting technology being built by the Eclipse community. This event is open to Eclipse enthusiasts who want to show demos of what they are doing with Eclipse.

Registration will open today, November 6th at 2.30 pm

Please click here for detailed information and the registration.

Seating is limited, so please register soon if you plan to attend.

We look forward to welcoming you to the Eclipse DemoCamp 2017!


The last DemoCamps have always been sold out. Due to legal reasons, we have a fixed limit for the room and cannot overbook. However, every year some places unfortunately remain empty. Please unregister if you find you are unable to attend so we can invite participants from the waiting list. If you are not attending and have not unregistered, we kindly ask for a donation of 10 Euros to “Friends of Eclipse”. Thank you in advance for your understanding!

If the event is sold out, you will be placed on the waiting list. You will be informed if a place becomes available, and you will need to confirm your attendance after we contact you.

If you are interested in giving a talk, please send your presentation proposal to for consideration. There are always more proposals than slots in the agenda, so we will make a selection from the submissions.

The post Eclipse DemoCamp Munich: Registration opens today appeared first on EclipseSource.

Kichwa Coders: The language server protocol will revolutionize how you code

Fri, 03 Nov 2017 12:26:50 +0000

The next generation Spring Boot tooling has been completely refactored to be based on the language server protocol (LSP). The tooling covers things like code assist for the Spring Boot property file, support for Cloud Foundry manifest files as well as Spring Boot support for Java files with typical features such as validation, content-assist and quick-fixes. Beyond IDEs This new generation of Spring tools, Spring Tools 4, will be fully unveiled at the SpringOne Platform conference later this year. Traditionally Spring tooling was written in Java as Eclipse plugins and could not be reused in other developer environments. The language server protocol enables Spring tooling to go beyond Eclipse and provide similarly great user experiences for Atom and Visual Studio Code, and likely any platform which implement language server clients. The list of clients supporting LSP is growing fast, even with Vi and emacs featuring it on their road-maps. In fact, the notable exception is IntelliJ. The market leader already has a well established language extension framework and the resources to keep up with language changes. It will be intriguing to see when and if they jump on the bandwagon and acknowledge the users banging the door down. Every Programming Language that Matters On the server side the number of protocol implementations is growing fast. There were 27 implementations back in June, my current count stands at 46. LSP easily makes sense for newer modern languages such as Typescript and Go, not to mention any domain-specific language. When it comes to languages with great IDE support such as Java, LSP is a big step back in functionality. However this could change quickly as the pace of Java releases quickens. Even for C/C++, LSP presents a chance to start afresh with a new approach. LSP: The Good, Bad & Ugly At EclipseCon Europe, Martin Lippert spoke about Pivotal’s journey to get Spring tooling to this stage and the good, bad and ugly of language server protocols. Here are some of the highlights of his insights. Good: Write once, run everywhere It is a no-brainer for toolsmiths to switch to something which enables them to creating tooling just once and make it readily available across different tools. building lightweight tooling (separation of client/server) the freedom of starting fresh building the tooling once and reusing it across various environments isolated testing writing tools in the language most suited to the job Bad: More features, better integration? LSP covers many language features but is not feature-rich. Syntax highlighting is not included though readily handled by Textmate grammars. Other features such as advanced refactoring should fall within the remit of LSP so hopefully this will only  be a matter of time. Additionally there is no communication between language servers. If the Spring language tooling provides completions for Java in a property file, will it be able to reuse an existing Java LSP or does it have to launch its own and redo all the indexing and parsing work?  As things scale this will be interesting to see how interactions between language servers can best be handled.   Ugly: More protocol please The protocol itself isn’t quite enough of a protocol and still leaves room for interpretation. Which means the promise of client-agnostic language servers doesn’t fully exist yet. Currently each client behaves differently. For example each client has its own way to start a server and define an extension. Additionally every client is different, which for now means feature flags per client to work around issues, for example, fo[...]

Benjamin Cabe: Enter the Open IoT Challenge 4.0: some ideas for your submission

Fri, 03 Nov 2017 09:34:40 +0000

There are only a couple weeks left (deadline is Nov. 13) for entering the fourth edition of our Open IoT Challenge! The Open IoT Challenge encourages IoT enthusiasts and developers to build innovative solutions for the Internet of Things using open standards and open source technology. You probably remember last year’s edition and its winner, Sébastien Lambour, who built an amazing solution: InTheMoodForLife. The project aims at analyzing sleep patterns to anticipate mood disorder episodes for people suffering from bipolar disorder. Sébastien won $3,000, and we also provided him with an additional $1,000 to fund his participation in Eclipse IoT events where he presented his project. For example, Sébastien attended the Eclipse IoT Day in London, a couple months ago, and gave a brilliant talk where he shared his experience. As a reminder, there is already a nice incentive for you to enter the challenge, even if you feel like you can’t compete for the first place (and you shouldn’t feel like that, by the way!). In fact, if you are among the 10 best submissions, our jury will award you a $150 gift certificate that will help you buy the hardware you need to build your project! I thought it would be useful to share some of the ideas I would like to see come to life, and some of the technologies that I think would be interesting to use. Deep learning With Deeplearning4j moving to Eclipse, now is the perfect time to think of having deep learning play a role in your project. Whether you plan on doing image recognition, predictive maintenance, or natural language processing, I am curious to see if Deeplearning4j, or other open source projects in the machine learning / deep learning area, can help you implement your solution. There are some IoT gateways out there that are fairly capable, and even some that include a GPU, so please be crazy and push the boundaries of edge computing! Industrial IoT Many – too many, probably – IoT solutions are very consumer oriented (connected toothbrush anyone?), so I certainly hope to see lots of projects that are more industry-focused. Our production performance management testbed can probably give you some pointers regarding open source projects that are applicable, and even provide you some code to get started. Blockchain and distributed ledgers Beyond the buzzword and the hype, blockchain is still an interesting topic, which you may want to put to use in your Open IoT Challenge project. Security is one key aspect of IoT. Blockchain might be a way for you to secure communications or data exchanges, but it is also interesting to think about using distributed ledgers as a way to enable a sharing economy. What if you could “share” some of your IoT devices’ processing or networking power and get compensated, in a secure way, using a blockchain? And how about true “pay-per-use” scenarios, where e.g construction companies share a pool of high-value power tools for which actual usage is tracked, logged, and billed accordingly, through a blockchain? Of particular interest, in my opinion, is IOTA, an open source distributed ledger which, by design, has no transaction fees (it has no miners, as the 2,779,530,283,277,761 (!) tokens that form the ‘tangle’ were all generated in the so-called genesis transaction). This means that you can leverage the IOTA tangle to implement secured micro-transactions in your IoT solution, e.g to expose (and monetize) sensor data to the world. I would be particularly curious to see how IOTA performs on constrained devices, and how well it scales. Low-powe[...]

Maximilian and Jonas: Save the date: Eclipse DemoCamp Munich on 4th of December 2017

Thu, 02 Nov 2017 19:31:35 +0000

We are pleased to invite you to participate to the Eclipse DemoCamp Munich 2017. Like in the past years, we continue in our tradition of hosting a “Christmas DemoCamp”. Please save the following date and mark your calendars on December 4th 2017 for the next Eclipse DemoCamp in Munich!  

We offer 80 seats, but we usually receive around 200 registrations. To give everybody the same chance, registration for the event will start exactly on November 6th 2017 2pm.

More details on the event and the possibility to register you will find here.

If you are interested in giving a talk, please send your presentation proposal to for consideration. There are always more proposals than slots in the agenda, so we will make a selection from submitted proposals.

We are looking forward to your registration and seeing you in December!

The post Save the date: Eclipse DemoCamp Munich on 4th of December 2017 appeared first on EclipseSource.