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!
|
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]
|