I Use This!
Very High Activity

News

Analyzed 22 days ago. based on code collected 23 days ago.
Posted over 10 years ago by [email protected] (Denis Roy)
Diversity in tech is an issue that needs no introduction. Although, I just did that.I attended a large professional automotive drag racing event last weekend, and coming from a tech background, the diversity in that field was so obvious that it just ... [More] goes unnoticed to everyone else. The leaderboards are peppered with women and men. The biggest names in racing are women and men. The crowd cheers for women and men. The attendance itself is women and men.And children. Young children. Teens. Boys and Girls.In fact, children are often seen in the racing pits, watching helping Daddy and Mommy repair an engine, prepare the car for the next round and do whatever it takes to win.Where are the children in tech? Where are the children at EclipseCon? Where are the children in your office building?My daughter in 2010, at age 4, watching a race from afar while I change tires.We involve our children into our leisure activities at a young age -- be it art, sports, or automotive racing. But I don't see the same type of involvement in tech. My expertise on this matter is only as exhaustive as my observation skills, but here is what I am doing to encourage my daughter to go into tech:- I bring my daughter to the office for 1/2 days when I can. She spends most of her time doing activities she prefers, and I occasionally show her what I'm working on and why it's important.- I bring my daughter to the data center, where the Eclipse servers are running. She is not allowed to touch, and I only spend a few minutes there since it's quite cold.- I show my daughter pictures and content of the tech conferences I go to.- I relate my daughter's homework to what I do for a living.... and I will do all the same with my son, as soon as he reaches an appropriate age. If we want to improve diversity in tech, I think it has to happen at an early age. If Demo Camps, hackathons, conferences and even daily office activities were more children/family-friendly, perhaps diversity in tech would be like diversity in professional drag racing:A non-issue. [Less]
Posted over 10 years ago
Plan to attend Eclipse Day India, on August 29 in Bangalore.
Posted over 10 years ago
I once more could not resist but showed up at 3 Democamps (Vienna, Munich and Zürich) where I showed how you can reassemble the components from our compensator research to create a smart code editor for Google Dart with: * Syntax highlighting * Error ... [More] reporting * Auto completion The slides from my talk are available at Slideshare Java fx tools from Tom Schindl or if you prefer it as a PDF If you’ve some time to spare and want to see me coding a smart editor for Google Dart in 15 Minutes you can watch the recording of the session in Vienna (the interesting part starts at around minute 15 of the video) [Less]
Posted over 10 years ago
One of the great strengths of LightweightM2M (LwM2M) is to be… ahem… lightweight! The fact that it relies on CoAP for the communication, and that all the standard resources are meant to be very concise really helps making very small ... [More] implementations that can fit in constrained devices. In the video below, you can see how Eclipse Wakaama (a C implementation of LwM2M) has been ported to an mbed NXP LPC1768 – a device with just 32KB of RAM! – and is controlled from Eclipse Leshan, a LwM2M server in Java. What I really like in this video is that it shows how simple yet powerful LwM2M actually is, and how efficiently you can fit advanced features like firmware upgrade in very constrained devices. View the video on YouTube [Less]
Posted over 10 years ago
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. I also attended EnterJS, where we brought an iPhone attached to a punching bag to show ... [More] just how responsive Tabris.js is. While at EnterJS, I presented J2V8 and released J2V8 3.0. J2V8 brings Google’s V8 JavaScript engine to Java. Here is the official New and Noteworthy for J2V8 3.0. Multithread Support J2V8 now has multithread support. Multiple V8 Runtimes can now be created, each on their own thread. This means that worker threads can be started, each with their own isolated runtime. A locker was also introduced. This allows a thread can give-up control of a V8 Runtime and another thread can take over. You can read more about this feature here. V8 Executors To make multithreaded programming easier, a V8Executor class was added. This is a thread which contains its own V8Runtime. When started, it will execute the provided JavaScript on its isolated runtime and then wait for messages. The executor will continue running until it is explicitly terminated. This abstraction makes it very easy to include WebWorkers in your J2V8 application. You can read more about this feature here. V8Functions A V8Function is now a first class citizen in J2V8. If a script returns a function, you can cast it to a V8Function and invoke it at a later time. This should make storing and passing around JavaScript functions much easier. v8.executeVoidScript("function add(x, y) {return x+y;}"); V8Function function = (V8Function) v8.getObject("add"); V8Array parameters = new V8Array(v8).push(7).push(8); Object result = function.call(v8, parameters); Universal get / executeScript Methods J2V8 uses the principle primitive when possible. This means that when working with JavaScript, wrapper classes should not be created for primitives types. This helps with performance, but can cause massive code bloat as you need different cases for each possible return type. While we are sticking with this principle, we have added an additional API which uses Object and wrapper classes. If you don’t know the return type of a script, you can call executeScript and J2V8 will create wrappers as needed. Object result = v8.executeScript("...long complicated JavaScript..."); Linux Support Linux support has finally be added and pushed to Maven Central. You can use the following dependency in your pom.xml to add Linux support. <dependency> <groupId>com.eclipsesource.j2v8</groupId> <artifactId>j2v8_linux_x86_64</artifactId> <version>3.0.0</version> </dependency> API and Getting Started Guide JavaDocs have been written for all the public API. The JUnit tests are still your best source of examples, but you can now browse the source code for an overview of the functionality. In addition to this, a getting started guide was written to help you get started with J2V8. You can read the 2 part getting started guide here and here. Finally,  Angelo Zerr  managed to use J2V8 in Tern.js. You can now choose J2V8 as your engine for Tern. Thanks for the pull requests, and please let us know what you are building with J2V8. For more J2V8 Tips & Tricks, follow me on Twitter. Leave a Comment. Tagged with j2v8, j2v8 [Less]
Posted over 10 years ago
I’m a bit late to announce the release of e(fx)clipse 2.0 but I’ve been heads down in e4/JavaFX projects so I did not yet have time to blog about the release in detail. Where to get it from Naturally we provide p2 update sites: Tooling: ... [More] http://download.eclipse.org/efxclipse/updates-released/2.0.0/site as a zip Runtime/Target-Platform: http://download.eclipse.org/efxclipse/runtime-released/2.0.0/site as a zip We also updated our All-In-One builds where we also bundled: EGit 4.0.0 bndtools 2.4.1 AnyEditTools 2.4.15 Findbugs 3.0.1 Eclemma 2.3.2 New Features / APIs The main focus of the release clearly was on the runtime layer where we fixed 119 Bugzilla-Tickets (most of the enhancements). Below is a list of the more interesting ones. Updateing your application got a lot easier To put it in kind words the p2-API is a very low-level and noisy one allowing you to do crazy stuff but frankly all you really want is to request an update for your application. So this should be damn easy. With 2.0 we made it dead simple for you: Tooling: The new application wizard allows you to directly bootstrap an application who has all necessary bits to update through p2 Runtime: We have had a unfunctional implementation which we revised (big thank to Dirk Fauth) import org.eclipse.e4.core.di.annotations.Execute import org.eclipse.fx.core.update.UpdateService; import org.eclipse.fx.core.update.UpdateService.UpdatePlan; import org.eclipse.fx.core.update.UpdateService.UpdateResult; import java.util.Optional; import org.eclipse.fx.core.ProgressReporter; import org.eclipse.fx.core.StatusException; public class RequestUpdate { @Execute public void update(UpdateService service) { service .checkUpdate(ProgressReporter.NULLPROGRESS_REPORTER) .onComplete(this::onCheckComplete) .onException(this::onException); } private void onCheckComplete(Optional<UpdatePlan> updatePlan) { if (updatePlan.isPresent()) { updatePlan.get().runUpdate(ProgressReporter.NULLPROGRESS_REPORTER) .onComplete(this::onUpdateSuccess) .onException(this::onException); } else { // Show nothing to update } } private void onUpdateSuccess(UpdateResult result) { // Inform that the update has finished } private void onException(StatusException updatePlan) { // Show info that status update failed } } New styled text APIs In case you’ve seen me at demo camps, EclipseCon and XtextCon you noticed that we have put a lot of time into the StyledTextArea which we reworked internally a lot and so things like selection, … are working properly now! The nice side effect of the reworking of StyledTextArea internals is that we managed to factor out internal into reuseable small APIs. StyledString: A java.lang.CharSequence who is made up of StyledStringSegments who have style classes associated with them StyledLabel: Similar API to javafx.scene.control.Label allowing you to represent a StyledString in the scenegraph StyledTextNode: A scenegraph node who is able to show arbitary decorations on a text string StyledTextLayoutContainer: A scenegraph node who is able to display selections SimpleTreeCell & SimpleListCell: Got enhanced to supported StyledString if the CharSequence provided by the labelExtractorFunction is a StyledString The following screenshots shows some of them working together to present an Dart-Editor In the center is the StyledTextArea, the autocompletion dialog uses SimpleListCell and the outline view the SimpleTreeCell. FilterableTreeItem & SortableTreeItem Our UI-Library got 2 now TreeItem implementations who support filtering and sorting! The most remarkable thing is that they have not been developed by BestSolution.at but Christoph Keimel has contributed them! Get in control of the e4 window WITHOUT providing a custom renderer Previous version had very limited support for controling your window. Starting with 2.0 we provide a (provisional) API who allows you to control almost anything from your window! For that we developed an abstract window API (org.eclipse.fx.ui.controls.stage.Frame) and also ship some default implementations (eg org.eclipse.fx.ui.controls.stage.DefaultTrimmedWindowPane). In the screenshot below we’ve relocated the MenuBar into a HBox with a search field at the end to save vertical space Lightweight dialogs Based on the Frame/Window API who is used in the renderer code in a heavy weight fashion we also have a new lightweight dialog system who is built around this API beside a base org.eclipse.fx.ui.controls.dialog.Dialog class we ship 2 implementations people we most likely use very frequently: TitleAreaDialog MessageDialog e4 supports lightweight dialogs While the lightweight dialog API can be used by any application, e4 applications can make use of lightweight dialogs through a new service named org.eclipse.fx.ui.services.dialog.LightWeightDialogService so opening a dialog who takes the complete window can be done with: @Execute public void openDialog(LightWeightDialogService service) { MyDialog d = new MyDialog(); service.openDialog(d, ModalityScope.WINDOW); } While the dialog service allows to open a dialog and control it’s modality there’s a 2nd service who is able to control how a dialog is shown/hidden. By default the dialog is simply show and hidden but you can for example add some nice animations like shown in the video below. [Less]
Posted over 10 years ago
It’s easy to get caught thinking that Mylyn only provides access to traditional issue trackers like Bugzilla and Jira. It also features integration with Gerrit. This screenshot shows the Planning perspective being used to work directly with Gerrit ... [More] reviews. Working with Gerrit in the Planning Perspective You can manipulate the review directly from within Eclipse, browse changes, fetch a patch set (and clone the source repository if necessary), cherry pick, abandon, and more. Naturally, it also includes the standard sort of great Mylyn support like the ability to schedule when you’re going to do the work and the task focused UI. [Less]
Posted over 10 years ago
Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!
Posted over 10 years ago by [email protected] (Fabio Zadrozny)
LiClipse 2.2.0 (just released) introduces improved search capabilities for Eclipse.This is done by leveraging Lucene for indexing the files searched -- it's interesting to note that the index is built (and checked for consistency) on-the-fly when a ... [More] text search is requested, which means that the indexing won't add any overhead on the build process (although that means that the first time some scope is searched it may take a bit more time to build the indexes -- but still comparable to a regular text search on Eclipse -- and subsequent calls are nearly instant).The image below shows the search dialog (activated through Ctrl + H), where it's possible to select what/where to search. The path(s) and project(s) are updated when a search is requested based on the current selection.The search results page also offers additional flexibility, which allows grouping the matches in different ways -- they can be flattened, grouped by project, folder or files -- and filtering the results based on the paths (multiple terms may be comma-separated and "!" can be used in the beginning of the term to exclude matches).Also, this release adds support out of the box for Linux Shell files, Windows bat files, PERL and Swift (through TextMate bundles), so, 27 languages are available out of the box now (View supported languages). [Less]
Posted over 10 years ago
GWT and Vaadin come with a great feature to debug the client-side widget code in the Chrome browser. Using GWT’s code server, the Java code will be displayed in the Chrome browser, and you can set your breakpoints and do debugging stuff directly in ... [More] Chrome. To run the superDevMode some preparations are required: Enable SuperDevMode in widgetset Compile your widgetset by a Maven build Download all dependencies required to run the codeserver (another Maven build) Create a launch config to run the code server Enhance the classpath of the code server launch config Add all downloaded dependencies to the classpath of the code server launch config Add local client-side code bundles and their source folders to the classpath Add the widgetset bundle to the classpath Ensure that 5.2 and 5.3 are at the beginning of the classpath Start the code server Start your OSGi Vaadin Application Open http://localhost:9876/ Bookmark “Dev Mode on” and “Dev Mode off” in the browser Open your application in Chrome {URL}/?superdevmode To reload widgetset in 8) click the “Dev Mode on” bookmark Ensure that Chrome -> Developer tools -> Properties -> Sources -> xyz Sourcemaps are checked Open the source tab in Chrome and find your java sources there 1 Enable SuperDevMode To enable the super dev mode, add the following lines to your widgetset.gwt.xml <set-configuration-property name="devModeRedirectEnabled" value="true" />; <add-linker name="xsiframe" /> 2 Compile widgetset To compile the widgetset properly, we are using a Maven build. Create a file called pom-compileWidgetset.xml in your widgetset bundle and configure the pom. Therefore just follow Vaaclipse widgetset as a sample. Following entries in the pom are mandatory: Add all your maven dependencies required to compile the widgetset Configure the vaadin-maven-plugin to compile the widgetset. The compiled widgetset will be copied to ${basedir}/resources. Run the build with “mvn clean verify -f pom-compileWidgetset.xml” 3 Download all dependencies for the CodeServer To run the code server properly, a lot of jar files are required. The simplest method to collect all dependencies and their transitive dependencies is to use another Maven build. Create a file called pom-superdev.xml in your widgetset bundle and configure the pom. For this pom, just follow Vaaclipse widgetset as a sample. The pom contains all required dependencies and a configuration for the maven-dependency-plugin which copies all jar files to a folder under “${project.build.directory}/superDev-lib”. Attention: The superDev-lib folder will be removed, if you call “mvn clean …” on the widgetset bundle. So it might be a good idea to create a folder called superDev-lib directly in the widgetset bundles root and copy the jars from“${project.build.directory}/superDev-lib” to this folder manually. Run the build with “mvn clean verify -f pom-superdev.xml” 4 Create a superDev launch config The superDev launch config is a simple java launch config. Settings: Main class: com.google.gwt.dev.codeserver.CodeServer Program arguments: “-logLevel DEBUG org.semanticsoft.vaaclipse.widgetset.DefaultWidgetset” VM arguments: “-Xss8M -Xmx512M -XX:MaxPermSize=512M” 5 Enhance the classpath of the superDev launch config The jar files downloaded under 3) need to be added to the classpath of the launchconfig. Open the launch config, switch to tab “Classpath” Press “Add JARs” Then add all jar files located in /superDev-lib to the classpath. Then add any “local client-side bundles” contained in the workspace Add the source folder of the “local client-side bundles” too Add the “widgetset bundle” Add the source folder of the “widgetset bundle” Ensure that the “local client-side bundles”, the “widgetset bundle” and their source folders are at the beginning of the classpath. Follow the launch configs contained in Vaaclipse widgetset as a sample. 6 Run the superDev launch config Running the superDev launch config means that the widgetset is compiled. If the code server could start properly, you will find following lines in the console: The code server is ready. Next, visit: http://localhost:9876/ 7 Start the application launch config Now you need to start you application using a launch config. No special configs are required there. 8 Open http://localhost:9876/ Just follow the instructions on the website and bookmark the two links. 9 Open application in superDevMode To do this, open {URL}/?superdevmode in your Chrome browser. The browser will tell you that the widgetset is being recompiled. Afterwards, the application opens. 10 and 11 No steps to describe here … 12 Open source code in Chrome browser Open the developer tools in Chrome. Under the source tab you should find all your client-side Java code. You may set breakpoints to the code and do all the debugging stuff — right in your browser! [Less]