Jacek on things

No error dialogs in eclipse headless test

2011-12-29T00:36:00.000-08:00

Here's a small funny thing I learned a while ago while running GUI tests of Eclipse application and now stumbled upon it again.
When running Eclipse tests headlessly, certain dialogs don't show up as they would normally (e.g. when writing/recording the test). This is because of flags:


org.eclipse.jface.dialogsErrorDialog.AUTOMATED_MODE = false;
org.eclipse.jface.util.SafeRunnable.setIgnoreErrors(true);

So if you for example have a test scenario that DOES expect an error dialog to show up, make sure you have above flags set correctly, or find out a different assertion than waiting for an error dialog.

Orion PHP Support demo

2011-07-25T14:34:00.000-07:00

If you're following Eclipse planet, you couldn't have missed Karol Gusak's weekly status reports about PHP support that's being built for Orion.

If you still haven't tried PHP in Orion yourself, here's a little demo now on YouTube that nicely shows syntax highlighting, content-assist as well as overall PHP experience in Orion. Click below to check it now.

Making extensible GUI with org.eclipse.ui.menus

2011-07-21T02:08:00.000-07:00

It's actually first time I had to make a custom part of GUI extensible. In an Eclipse forms editor like following, we wanted custom actions to come from various plugins:

Since eclipse APIs provides this sort of extensibility with their org.eclipse.ui.menus extension point, I looked at how to reuse that mechanism. It turns simple. All you need to do is, while creating the editable area, add:


final Composite parent = ... // that's the area we want to make extensible

ContributionManager contributionManager = new ContributionManager() {
  public void update(boolean force) {
    for (IContributionItem item : items) {
      item.fill(parent);
    }
  }
};

IMenuService service = (IMenuService) getSite().getService(IMenuService.class);
contributionManager.add(new GroupMarker("testing"));
service.populateContributionManager(contributionManager, "toolbar:org.zend.editor1?after=testing");
contributionManager.update(false);

Now to contribute something to that area, you need to extend org.eclipse.ui.menus extension point:


<extension point="org.eclipse.ui.menus">
      <menuContribution allPopups="false"
        locationURI="toolbar:org.zend.editor1?after=testing">
   … Your contributions here …
       </menuContribution>
</extension>

So now, if you for example prepared some commands in advance, you can easily link them without any extra coding. Since I wanted some nice looking link, I used control contribution. It let's you create entirely custom widget.

See the end result:

Lessons learned:
1. When specifying locationURI, it's worth choosing 'toolbar', over 'menu' or others because only 'toolbar' locations support custom control contributions.
2. Only supported URI parameters are 'after', 'before' and 'endof'. When using different parameters, I'm not sure how (if at all) it will be handled and where exactly your contribution will be landed.
3. Not quite sure why, but all the existing docs that I have come accross, only say how to use menus extension point in standard places like view menubar, window toolbar, etc. Nothing about re-using whole mechanism..

Starting and immediately using OSGi bundle: possible?

2011-07-14T03:29:00.001-07:00

Lately I had this little thing to do: an OSGi bundle (SuperTool) comes with some other OSGi bundle (GreatSdk) included.
SuperTool depends on logic in GreatSdk so the first thing it needs to do during activation is to install GreatSdk and immediately after that start loading classes from GreatSdk.

At first thought it seems logical to make SuperTool-GreatSdk dependency optional, to let SuperTool install and start safely without GreatSdk. Once installed, during startup SuperTool should install GreatSdk and start using it, for example:

BundleActivator.start(BundleContext context) {
greatSdk = context.installBundle("file:///path/to/great.sdk_1.0.0.jar");
greatSdk.start();

GreatSdkStarter gss = new GreatSdkStarter(); // separate class in SuperTool that references some classes from GreatSdk
gss.start(); // creates some GreatSdk classes
}

Unfortunately this fails in gss.start() with ClassNotFoundException:


java.lang.ClassNotFoundException: greatSdk.Sdk
at org.eclipse.osgi.internal.loader.BundleLoader.findClassInternal(BundleLoader.java:513)
at org.eclipse.osgi.internal.loader.BundleLoader.findClass(BundleLoader.java:429)
at org.eclipse.osgi.internal.loader.BundleLoader.findClass(BundleLoader.java:417)
at org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader.loadClass(DefaultClassLoader.java:107)
at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
at supertool.GreatSdkStarter.start(GreatSdkStarter.java:8)
at supertool.Activator.start(Activator.java:63)

What does work is reflectively creating GreatSdk class instance via obtained Bundle:


// again in superTool activator.start()
Class clazz = b.loadClass("greatSdk.Sdk");
Object ob = clazz.newInstance();

So problem seems to be in the SuperTool information about the world. It looks like SuperTool is not yet aware that greatSdk was installed in the meantime.

Another thing that works is refreshing SuperTool via OSGi console:


osgi> start superTool 
// loads greatSdk, but fails with ClassNotFoundException for classes referenced in GreatSdk
java.lang.ClassNotFoundException: greatSdk.Sdk....
osgi> ss
,,,
1 ACTIVE greatSdk
2. RESOLVED superTool

osgi> refresh superTool // magic
osgi > start superTool

After the refresh, starting superTool again makes it properly see greatSdk. Unfortunately doing refresh from within superTool activator.start() doesn't work so sweet. PackageAdmin.refreshBundles(superTool) terminates successfully, but CNFE is still thrown.

What's other way to activate and immediately use optional dependencies in an OSGi bundle?

(Except 'don't do it' :-) )

Installing V8Cgi on Mac

2011-07-13T05:03:00.000-07:00

V8CGI is a very thin Apache module encapsulating V8 - Google's JavaScript engine that's used e.g. in Google Chrome. Those concerned with NodeJS stability may consider V8CGI a better choice, thanks to stability provided by Apache base.

A short while ago, on DevMeetings.pl DevCamp we've been playing with V8CGI, RingoJS and Node. Thanks to good performance, intuitive and high quality APIs, V8CGI turned out to be the black horse of the whole event, although installing it on Macs was little tricky.

Readers with Windows and Linux should follow to V8CGI home page, where they can get precompiled Windows binary and learn how to install binary on Ubuntu.

Mac users, let's open terminal and try to build the V8 apache module ourselves.

Getting V8CGI to work is four steps:
1. Getting the source code
2. Building it
3. Configuration
4. Test drive

1. Getting the source code
When checking out sources from SVN, we actually need two packages V8 and V8CGI:
a) svn checkout http://v8cgi.googlecode.com/svn/trunk/ v8cgi
b) svn checkout http://v8.googlecode.com/svn/trunk/ v8

You should end up with two new directories: v8 and v8cgi. When downloading a ready package from V8CGI home page, V8 sources are already included.

2. Build V8 and V8CGI
We'll use scons - a software construction tool. A good way to get started with scons is:

scons -Q -h

It gets you a list of available build configuration options. Worth visiting when you hit a wall compilation errors.

Let's first build V8:


cd v8
scons library=shared arch=x64
sudo cp libv8.dylib /usr/lib/libv8.dylib

We need x64 arch, as that's default Mac's Apache architecture. As a result your newly built libv8.dylib should be now available in /usr/lib directory.

Now let's build V8CGI.


cd ../v8cgi
scons module=1 mysql=0 gd=0 apache_path=/usr/include/apache2/ apr_path=/usr/include/apr-1/

Note that I added some extra options (run scons -Q -h for list of all options):
mysql=0 - disabled mysql support, that is on by default. Not quite sure if all I need to enable this option is on my Mac, and I don't need mysql for now, so let's just disable it.
gd=0 - disabled image-processing library 'gd', that is on by default. Same as with mysql, let's try without gd for start.
apache_path and apr_path - that's the path to Apache header files. Necessary to build against our HTTP server.

For me this command ends up with following error:


Undefined symbols for architecture x86_64:
  "_iconv_open", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
  "_iconv", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
  "_iconv_close", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
ld: symbol(s) not found for architecture x86_64
collect2: ld returned 1 exit status
scons: *** [mod_v8cgi.dylib] Error 1
scons: building terminated because of errors.

Above error message says that 'iconv' library is missing for our architecture x86_64. Iconv is used for converting different character set encodings, like UTF to ISO, ISO to ASCII, etc. It's not critical part of V8CGI, specially if you only want to evaluate that technology.

For evaluation purposes, we could just rip out the iconv calls from v8cgi source code but let's build iconv ourselves. Create another directory "iconv" next to v8 and v8cgi and execute following steps there:


curl -O http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.11.tar.gz
tar -zxvf libiconv-1.11.tar.gz
cd libiconv-1.11
./configure
make
make install

Note that latest iconv library is 1.13.1. We're using 1.11, because that one is compatible with iconv version included by default on Mac. Building with 1.13 you will end up with following error when trying to start apache next time:


httpd: Syntax error on line 118 of /private/etc/apache2/httpd.conf: 
Cannot load /usr/local/apache2/modules/mod_v8cgi.dylib into server: 
dlopen(/usr/local/apache2/modules/mod_v8cgi.dylib, 10): 
Library not loaded: /usr/local/lib/libiconv.2.dylib\n  
Referenced from: /usr/local/apache2/modules/mod_v8cgi.dylib\n  
Reason: Incompatible library version: mod_v8cgi.dylib requires version 8.0.0 or later, but libiconv.2.dylib provides version 7.0.0

Let's go back to v8cgi directory and continue it's build. We need two extra params to link our new iconv module:


scons module=1 mysql=0 gd=0 \
   apache_path=/usr/include/apache2/ \
   apr_path=/usr/include/apr-1/ \
    libpath=/usr/local/lib cpppath=/usr/local/include

The build proceeds few steps forward and fails again with:


g++ -o mod_v8cgi.dylib -bundle -bundle_loader /usr/sbin/httpd src/common.os src/system.os src/cache.os src/gc.os src/app.os src/path.os src/lib/binary/bytestorage.os src/mod_v8cgi.os -L/Users/jacek/Downloads/aa/v8 -L/usr/local/lib -lv8 -lv8 -lapr-1 -laprutil-1
Undefined symbols for architecture x86_64:
  "_libiconv_open", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
  "_libiconv", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
  "_libiconv_close", referenced from:
      ByteStorage::transcode(char const*, char const*)in bytestorage.os
ld: symbol(s) not found for architecture x86_64
collect2: ld returned 1 exit status
scons: *** [mod_v8cgi.dylib] Error 1
scons: building terminated because of errors.

This time, compilation of v8cgi library is almost done, but breaks on gluing everything together. Let's invoke the same command adding -liconv:


g++ -o mod_v8cgi.dylib -bundle -bundle_loader /usr/sbin/httpd src/common.os src/system.os \
   src/cache.os src/gc.os src/app.os src/path.os src/lib/binary/bytestorage.os src/mod_v8cgi.os \
   -L/Users/jacek/Downloads/aa/v8 -L/usr/local/lib -lv8 -lv8 -lapr-1 -laprutil-1 -liconv

And success! No errors and your mod_v8cgi.dylib is out there, ready to try.

Configuration
Configuration is pretty well described in v8cgi/INSTALL text file so I'll just copy it here:

sudo cp v8cgi.conf.posix /etc/v8cgi.conf

- configure /etc/v8cgi.config
sudo vi /etc/v8cgi.conf
require.paths.push('~/src/v8cgi/lib');

- configure the apache module:
sudo vi /etc/apache2/mods-available/v8cgi.load
* The only line in the file should be:
LoadModule v8cgi_module ~/src/v8cgi/mod_v8cgi.so
--
sudo vi /etc/apache2/mods-available/v8cgi.conf
* The only line in the file should be:
AddHandler v8cgi-script .sjs .ssjs .jst

Restart Apache and you're ready to go!

Signing firefox extensions

2011-04-28T02:05:00.000-07:00

Signing FF extensions is pretty straightforward. Lately I've been going through some strains related to them, so I thought I'd share lesson learned.

You have two sides that need to match with each other: online update URL and extension itself. Online update URL is a single file - update.rdf. Extension is an XPI file, with install.rdf file inside.

Update.rdf contains a list of available extensions. Each extension should have checksum information, e.g. in sha1 algorithm.
Once update.rdf is complete with all information and checksums, it must be signed with signer key.
Note that, every time you change any of extension, it's checksum will likely change and so you need to update and re-sign update.rdf as well.

On the other side, the install.rdf included in our XPI file needs to have our public key. Once you create install.rdf and put public key there, you can forget about it. XPI file does not have any checksum or signing.

This all sounds nice and well but sometimes it doesn't go as well. Let's suppose public key included in XPI file was wrong and the file is already in the public. Every update attempt will fail with error about malformed signature or updateKey. That's because during update, Firefox tries to match public key in XPI to signature in update.rdf.
The only solution is to manually install extension again, with correct public key. It's necessary to clear browser cache before performing manual install, because FF uses cache first if the extension is already there.

Detailed information about RDF file formats is here.

Building Windows installer with WiX

2011-02-18T17:07:00.000-08:00

WiX is Windows Installer XML (WIX) Toolset. It's an open source project coming from Microsoft. Actually, it was the first project that Microsoft has officially published under Open Source license. Initially it appeared on SF.NET, but recently has moved to Microsoft's owned CodePlex.com. Half of the internet still points to SF though.

This tool let's you pack a bunch of files into a user-friendly MSI installer, including GUI, silent install, repair, windows registry editing and Start menu customizations.

WiX is a bunch of cool ideas. The first one goes with the each tools names. There's Heat, Candle and Light. They act as preprocessor, linker and compiler. So no matter whether you know everything about compilers, or you always left it to the IDE - tools seem friendly from the very first look.

As name says it, the spine of the toolset is XML. To turn on the heat, developer needs to specify files to install, user interface, user interactions, install steps, resources and custom actions. All this lands in one or more XML documents following provided XML Schemas.

Microsoft Visual Studio users are lucky, as there's GUI in VS that hides WiX to some extent. However I'm not sure how much flexible it is, i.e. how far can you go without having to manually edit XMLs. I was working on plain XML file in Eclipse IDE. Thanks to XSD Eclipse was able to provide content assist. This saved me from many typo-like bugs and helped find right tags faster, than by looking at the docs.

The installer to build had some requirements. It had to be good-looking, native user experience. Some 3rd-party artifacts needed to be installed in the system as well: a dll, another product msi, and an exe to invoke in install time.

User interface

Installers are typically wizards, built of couple of pages. WiX provides several default pages for standard operations. They're easily customizable with some space for branding. Unfortunately some predefined pages look bad. For example features selection dialog uses ugly drop-downs, rather than checkboxes. Maybe it's useful in some scenarios, but for 99% cases they're confusing.

Those not happy with default GUIs can implement their own by putting basic widgets (Button, Text, Label) together. All in XML. That's a bit of work for a beginner who previously built GUIs only in HTML or Java. There are also little caveats here and there, that can turn simple changes into a whole day of work. For example, there's no support for transparent background in checkboxes, or background color is different on various Windows versions. So good luck, if you're planning for many customizations.

Overall, user interface looks nice. It's simple, minimal, doesn't hurt an eye. But at the same time, it's not something impressive, not eye catching.

Installing 3rd party stuff

It's very simple to invoke any system command from WIX. If system command is not enough, then a DLL or VB script can be called as well. Unfortunately it get's more complicated starting with Windows Vista and Windows 7. They have UAC (User Account Control) which denies pretty much all activity that was not explicitly accepted by user - e.g. blocks write access in some areas, disallows some programs. This is not really WIX issue, but being closely coupled to underlying MSI technology, WIX exposes some difficulties that we usually don't want to see or understand. So, any custom action (e.g. custom command invocation), that requires UAC signoff (or "privileges elevation") must be ran deferred. So in fact, it will be ran separately after the installer. Unfortunately deferred command does not see any properties or variables set during install process. So for example, if you want to remove extra files on uninstall, you need to think about communication mechanism, that will tell remove command the location to be removed and then run remove command deferred. That's much more than "rm -rf $DIR". The advantage is that you decide what privileges are used for which step (it's not so obvious with other 'advanced' tools).

Installing files

When installing the files, MSI maintains extra bookkeeping for rollback support. Unfortunately this is quite time consuming. In our case, whole application was 500M which meant extra precious minutes of installation time (and first impression) only for ability to click "Cancel"/"Repair". Disabling this bookkeeping is supported only in more recent MSI versions. This makes MSI technology look very bad when compared to any Archive/ZIP-based installers. The good side is, that latest MSI (e.g. included in Win7) is pretty fast, and it's only Windows XP where things are slow. During uninstall, naturally, only the installed files are removed. This is usually advantage, but if application generates any files, like cache, or stores files in many locations, then we want that removed as well. There's no out-of-the-box "remove dir" functionality.

Updates

MSI supports updates. Update can replace particular files in install. This time, our tool was managing updates by itself and there was no easy way to automatically map those updates to certain files. So we didn't use this functionality.

That's pretty much my first top five thoughts about WIX. At the end, it's also worth mentioning the community. WIX has extremely lively forum. Only rare questions pass without an answer. Unfortunately not many people make an effort to dig a bit into archives, so many basic questions get asked all the time.

I've got some other installer tooling to blog about as well. So for next entry, I need to decide whether to get deeper into WIX or give an overview of it's alternative. Don't hesitate to comment, if you'd like to hear anything in particular about WIX.

Two Eclipse p2 repository operations to make you happy

2011-01-14T01:11:00.000-08:00

On the integrations side of the Eclipse business I often happen to need two things:
1. add a random OSGi jar to repository
2. copy from one repository to another

Looking thru p2 manual it's not always entirely obvious how to do it, so here goes my take on the subject.
All my automation uses Ant, so I'll speak a bit of Ant now:

1. Add a random OSGi jar to repository


<p2.publish.featuresAndBundles
  repository="file:/path/to/destination/repository"      e.g. ${buildDirectory}/repo
  publishArtifacts="true"
  compress="true"
  append="true"
  source="/absolute/path/to/folder/with/jar" />

Few notes:
1. source attribute must be an absolute path.
2. source path must contain "features" and "plugins" directories. So if you have only one bundle, make sure to put it under plugins dir first.
3. make sure repository attribute is a URL, not plain path

2. Copy from one repository to another


<p2.mirror verbose="true">
  <repository location="file:/path/to/destination/repository" />
  <source>
    <repository location="file:/path/to/source/repository" />
  </source>
  <iu id="pluginName" version="" />
</p2.mirror>

Notes:
1. Why not use p2.director? It copies only bundles for current architecture
2. Mirror task is still not perfect, but enough for most copying operations, it has some extra options, worth looking into.

Extending Eclipse Orion

2011-01-12T01:06:00.001-08:00

Yesterday Eclipse E4 team announced Orion - an experimental Eclipse Web IDE. There's plenty of information about the project on Orion wiki.

Orion is a set of JavaScript and HTTP APIs that simplify common development part of rich applications, like file storage, preferences, authentication, dialogs, selection. Since it's coming from Eclipse, Orion is skewed towards IDE development, so from start it also includes text editor with some decent features, like JavaScript syntax highlighting and JSLint integration.

The project may go towards strengthening it's JS IDE feature set, as well as enhancing it's core side - extensibility, client APIs ...or do it all at once. In any case it's going to be fascinating journey!

So how to extend Orion? One can re-implement existing HTTP API in language other than Java; add more HTTP APIs, e.g. for task management, calendar, etc. Same with JavaScript API - it seems fairly easy to add more. Looking at this from classic Eclipse adopter point of view, I tried to add some GUI contribution that brings new functionality to existing Orion - let's say a PHP editor to complement the JS one. Naturally all without leaving Orion. I took following steps:

1. create new Orion bundle with new editor

2. install on Orion server

3. test and improve the contribution

Creating new bundle for Orion

Orion is technically a simple Equinox http server, so it's pretty straightforward. We need MANIFEST.MF with bundle description, plugin.xml that describes what web content should be published and the content itself.

New bundle structure, looking at it from Orion:

META-INF/MANIFEST.MF

Pretty much ,standard Eclipse plugin manifest.

plugin.xml

This one specifies that our bundle contains some static web content under /web directory and that it should be accessible in the container under /simple alias. Straightforward, thanks to Equinox.

Interestingly, at the moment Orion team decided to put all configuration in one bundle, so e.g. webeditor or webide JS code currently doesn't decide on it's own where will it appear, but instead a separate configuration bundle defines that.

Installing bundle into Orion

To install just created bundle, we need to figure out where is it stored and install it. By default Orion stores files in serverworkspace directory in it's home dir. On Mac this happens to be \Eclipse.app\Contents\MacOS\serverworkspace

In order to install bundle, it's best to use equinox osgi console - available in Orion thanks to the fact that it's equinox application. Orion docs mention something about server console, but I'm not entirely sure if this is the same, or some other console.

So first start Orion with osgi console:

./eclipse -console

and then, install the bundle:

osgi> install file:/Users/jacek/Downloads/eclipse-orion/eclipse.app/Contents/MacOS/serverworkspace/A

Bundle id is 75

osgi> start 75

I used absolute path from Orion workspace, to easily make updates later. Surprisingly my project dir is named "A" instead of it's real name. Another interesting thing is that there's no all the well known .project and .settings files. Web developers are going to like it, and I'm wondering where is this information stored currently.

Test and improve the contribution

So now that our bits are installed, let's see them:

http://localhost:8080/sample/index.html and yes! It works!

Curious mind would be interested what was the source of the index.html, that generated such nice "Hello [object Object]" message. I included some Orion Client API to check if it's available and yes, it is! From now on, further documentation can be found at Orion Client API wiki.

The source is following:

After updating the bundle contents - e.g. to turn this sample to real new PHP editor - there's another command required to make Orion see our changes. From osgi console type:

osgi> update org.eclipse.sample

The only thing that I was not able to figure out is how to actually add a link or other UI contribution to code editor, files navigator, or other existing UIs. At the moment user has to manually enter the URL to see my contribution. I'd be happy to hear how to do this, if you happen to know.

Google App Inventor Eclipse Plugin

2010-07-14T00:55:00.000-07:00

Hey, in case you missed it, here it is - the App Inventor plugin for easily making Android apps straight from your favourite IDE.

Together with git, task management and debugger now you can make not only silly kitty apps, but something bigger too :-)

See it in action: (embedded Youtube video below)

..hm so wouldn't that be easy with web plugins?

Extend Eclipse in JavaScript... or PHP :-)

2010-07-04T06:05:00.000-07:00

The JavaScript unit tests view for Eclipse I blogged last time, wouldn't be anything special, unless you're JavaScript guy. Except the fact that it's implemented in plain HTML+JavaScript for GUI part and business logic.
Ah.. and it uses jQuery too, so I think I can label the view as an example of jQuery plugins for Eclipse :-)

This has several advantages:
- I don't need to know Java to extend Eclipse. This is great for such Eclipse IDE users as JavaScript, or PHP developers.
- many things are easier to calculate in web languages, than Java. E.g. (running JS tests, running a web poll, etc.)
- writing simple UI in HTML is dead easy. and you can use CSS :-)

The main disadvantage is difficult communication with workbench. Java APIs are complicated and hard to map 1:1 in JavaScript, however for start I'm looking at exposing only few most useful features, like selection service.

The inner workings are pretty simple. Some HTML is rendered by browser widget embedded in traditonal Java Eclipse view. Additionally, JSON and Ajax are used to keep HTML view informed what's going on in the Eclipse workbench.

I know that e4 open social is working on something similar, however how do the gadgets communicate with Workbench?

Wish me luck with final efforts on releasing Zend Studio, and you'll see more of this HTML/JS/PHP plugins :-)

JavaScript unit tests in Eclipse

2010-06-26T02:32:00.001-07:00

Anybody knows what's currently the most popular tool for javascript unit testing?

While figuring this out, I made up a simple javascript unit tests integration with Eclipse to easily run precious tests from my favourite environment :-)

Unit tests are simple objects with functions to test and there's a couple of JUnit-style assertions. I wonder if the above view could be integrated with some real JS unit test tool.

Understanding JavaScript libraries

2010-05-28T03:53:00.000-07:00

I'd like to share with you some thoughts on supporting javascript libraries in an IDE. I found it quite interesting so far and I hope you'll enjoy the read :-)

Let's assume we have to add content-assist for popular javascript libraries, like jQuery or Prototype, etc, there's dozens of those.

First of all, if those libraries are written entierly in JavaScript, why do we have to add anything special? Can't some JS parser (e.g. JSDT) just take care of understanding those libraries, like it's done for Java or other languages?

Unfortunately no. Most popular convention in JavaScript world is to write libraries that self-expand themselves in runtime. For example:


/** this function adds all fields and functions to given object
 */
jQuery.extend = function(object, fields) {
   for (var field in fields) {
      object.prototype[field] = fields[field];
   }
};

jQuery.extend(Array, {

    /** Removes an object from array
     */
    remove : function(obj) {
    }

    /** Prints JSON string of an object
     */
    toJSON : function() {
    }
});

So statically analyzing above code, compiler could guess only that extend(objects, fields) function is defined and added to jQuery object. For the other functions - remove(obj) and toJSON(), we can only assume, based on some comments (and code), that they'll be added to Array object after invoking the extend() method. This extending pattern is the fundament behind jQuery plugins, Prototype and ExtJS.

Before going further into details with possible solutions, let's see what does typical static analyzer (e.g JSDT) understand. It understands basic JavaScript structures, like:


/** jQuery.function1 jsdoc
 */
jQuery.prototype.extend = function(object, object) {}

/** jQuery function jsdoc
 */
Array.remove = function(object) {}
Array.toJSON = function() {}
}

Based on above code, JSDT can provide content assist for functions and fields and properly match jsdoc to them. So maybe all that is needed is some convertion between original library source code and understandable code?

Ok so what are possible solutions to build proper JSDT data?
There's several options:

improve static analysis to understand popular JavaScript patterns, such as extend patten.
forget about source code and use libraries provided API documentation to derive JSDT documentation
run the source code in real environment and capture it's behavior

AD1. Improve static analysis with knowledge of popular JavaScript patterns, such as extend patten.

It's possible to extend JSDT with extra logic that understands what extend() function does. Then, whenever static analyzer finds call to extend(), it can easily apply the pattern. The drawback is that there's more patterns, for example extendIf(boolean, object, fields) (in ExtJS),
or code is more complicated, for example the features to be added to object are computed in a non-trivial way. For example:


features = { // an object with various features that should be added to
various objects
  objectAdditions : { object : Object, extend : function(), id :
function() },
  domAdditions : { object : Element, toHTML : function() },
  docuAdditions : ( object : Document, connect : function() }
}

for (var featureSet in features) {
  Lib.extend(features[featureSet].object, features[featureSet]);
}

Libraries authors have a lot of invention: they either optimize their libraries for JS file size, or try to make it as human-readable as possible by adding more JS structures. In both cases we can find either more functions, similar to extend() or more JavaScript code used
to build new API.

AD2. Forget about source code and use libraries provided API documentation to derive JSDT documentation

The most successful libraries have excellent documentation. JQuery has it's own in XML, which is then converted to HTML. ExtJS and Prototype have greatly commented source code. It's worth mentioning that JS libraries source code can be found in several formats. First as a
development source code - single library is split into many separate files of logically-related stuff. Second format is the debugging source code - library in it's final single file shape, but with formatting and comments included. Finally, there's minified source code - typically a
single line, with all whitespaces and comments ripped off.

The main advantage is that everything that is officially documented/supported in the docs, will be correctly reflected in JSDT. The main drawback is that for each library a separate converter is needed. Additionally, XML and HTML structure are subject to change, so there's a risk that each new version of library will also need a new converter. Documents may also show API in ways that are not possible to encode in JavaScript stubs. For example use overloading to describe
different kinds of the same function, whereas in fact in JavaScript this is just a single function with variable number of arguments:


/** jsdoc1 */
jQuery(selector) {}
/** jsdoc2 */
jQuery(element, expr)

Finally, while parsing XML is relatively painless, the HTML is often a subject to many XML parser errors, so regular expressions may be better tool than XML parser.

AD3. Run the source code in real environment and capture it's behavior

This sounds like WIN, because after all, all javascript libraries are written to be run, so it's only matter of capturing the result.

There's two ways to capture the JavaScript structures. One way is by using Mozilla Rhino. It's a JavaScript engine written completely in Java. Rhino also has excellent debugging facility that let's easily inspect the memory state. Being Java-based has another advantage, that it's relatively easy to integrate.

Another solution is one of standard JavaScript engines, e.g IE or Mozilla - those are supported by all libraries. Natively in JavaScript, it's fairly easy to capture the result of above examples, because all objects in JavaScript are hashmaps, so reading an object API is as easy as iterating over it's members with a for loop. The drawback is that it's impossible to read API of objects that have not been created yet. For example:


AnEvent = function(name, time, source) {
  this.eventName = name;
  this.time = time;
  this.source = source;
  this.send = function(object) {...};
}

So until someone calls new AnEvent(name, time, source), it's impossible to figure out the structure of the AnEvent type. The other problem with this solution is that only trusted code can be run. Any infinite loop would break it.

Looking thru the mirror

2010-02-02T01:42:00.000-08:00

After a loaf of Java, bite of JavaScript and little bit of PHP in my most recent career, last week I headed to Poznan .Net Group meeting to see what are this guys doing up there.

Assuming you're a Java guy, you know who is who in Java world, you know what's JEE, you wait for Java7, can tell why NetBeans sucks. You meet a Java friend and together whine about Maven, Eclipse, EJB, then have a beer and next day all again.

And now there are those .Net folks. What are they up to? One guy there was from company of approx. 200 Java engineers. Only his (10 person?) team does .Net there. Oh my, are this two groups talking with each other during a lunch? That's what I was wondering on my way there.

And the meeting was fun. At first look, just as I had passed a magic mirror with applied "s/Java/.Net/". About 10 people in the room (quite like on our Java group), tense air, two topics: S#arp Architecture and PowerPivot review. I especially liked S#arp because it's kind of framework. PowerPivot on the other hand is actually a tool, powerful and good to know about, but I'm not going to use it or work on anything similar in near future.

The first speaker, started with a little history background of web applications, then did quick breakdown of all S#arp parts and finally small demo of what it does.

S#arp, as it was said, is a bunch of nice tools glued together, adhering to common conventions. There's NHibernate, TweetSharp, NUnit, N4, jQuery and couple more Nthings that I don't remember. It's a generative approach, where you customize prefabricated templates to produce some C# code. Generated stuff uses bunch of custom code based on various popular small tools.

So while you could basically do all of this by yourself, learn NUnit, N4, etc. etc., you can just focus on describing your model, and then get very basic unit tests, web application, data layer abtraction and something more with just one click.

So I'd be interested to learn about Java solution, where you edit a model, and get ready web application. I know I can use EMF, to easily get running Eclipse application, it generates tests skeleton, can customize templates. But fundamental difference between EMF and S#arp is that in EMF you have to buy everything (validation, data persistence, etc.) from one source, whereas S#arp adapts to already existing technologies and is mere MVC integration layer. Second, standard EMF doesn't generate web apps. Third, some JEE folks just don't buy code generation and EMF so maybe there are more arguments which such non-JEE guy as me doesn't understand.

The other intersting observation was IDE. There's no problem, like we once had on Java meeting where speaker nearly refused to show example, because we had only Eclipse and he works on NetBeans. Everyone uses VisualStudio. And actually some of the mentioned small tools integrates with VS if you copy one or two dlls here and there.

It's pretty much like joining JEE knowledge, JEE tools, EMF Runtime and EMF tools to work together. You get EMF tooling to create a model and then generate a standard JEE application, adhering to conventions, best practices, etc. This is what tons of JEE developers could like. With little knowledge of patterns, conventions, practices they'd be quickly making standard JEE apps adhering to best practices, conventions and patterns.

That's just a highlight of the meeting compared vs. my little Java knowledge. But there were also many little differences in group governance, people motivation, focus on trends and so on. I encourage anyone to try this excercise and look thru the mirror too.

Wspólna lista poznańskich forów IT już jest

2010-01-30T07:42:00.000-08:00

Już jest jedna wspólna lista poznańskich grup informatyków! Wszystkie wpisy są ładnie posegregowane by łatwo się zorientować, który pochodzi z JUGu, .Netu, itp. Na pierwszy rzut oka wygląda że największy ruch jest na grupie Javowej, ale może to tylko zbieg okoliczności.

Oczywiście nie wszystko jeszcze się udało. Np. poznańskim Linuksowcom szwankuje strona, adobowcy nie mają forum a jedynie bloga, grupy uczelniane (Politechniczne Booboo i Uniwersysteckie KINO) korzystają z uczelnianych list dyskusyjnych, gdzie jedynym sposobem nadążania za dyskusją jest zapisanie swojego e-maila - o RSS jeszcze nikt tam nie słyszał.

Link RSS: Poznan IT Groups.

Dla ciekawskich jest też jak to tam sobie działa.

Co tam ciekawego w Poznaniu!?

2010-01-24T06:17:00.000-08:00

Odkąd bardziej interesuję się javascriptem, odkrywam nową cechę społeczności javowej. Jest ona najbardziej zorganizowaną grupą programistów regularnie spotykających się w wielu miastach tylko po to by zdradzać kilka technicznych sekretów swoich warsztatów. Są ludzie z korporacji, studenci, konsultanci, startupowcy, naukowcy - niemal wszyscy. Większości nikt za przychodzenie nie płaci, czasem można zgarnąć książkę ale najczęściej jedynym plusem ze spotkania jest kilka nowych ciekawostek i znajomości.

A co wśród wyznawców innych języków? .Net-owcy, php-owcy, erlang-owcy (mieliby co gadać o nktalku:-), dynamiczni, itp, itp. a potem bazodanowcy, flaszowcy, linuksowcy (tu wiem: PLUG)? Powiedzmy, że wchodzę w nowy język/temat i mam setkę pytań - jak tu zacząć? Najprościej oczywiście na starych dobrych grupach dyskusyjnych, ale jak tu znaleźć kogoś w okolicy?

Stąd wpadł mi pomysł by zebrać do kupy wszystkich programistów i grupy z Poznania i okolicy. Docelowo chciałbym widzieć kalendarz ze wszystkimi techniczno/technologicznymi wydarzeniami w Poznaniu, listę wszystkich tweetererów z Poznania, zagregowany blog okolicznych bloggerów i na koniec, choć wg. mnie najważniejsze, łatwą nawigację do wszystkich lokalnych forów (przynajmniej w trybie read-only).

Na początek wstawiam listę wszystkich znanych mi grup dyskusyjnych z Poznania:

Poznan-JUG: www.jug.poznan.pl
Poznan .Net Users Group: http://ms-groups.pl/pg.net/default.aspx
Poznan Linux User Group: http://www.poznan.linux.org.pl/ (Nie działa)
Poznan Adobe User Group: http://augpoznan.eu/ (btw. kilka dni temu mieli spotkanie!)
KINO: http://kino.wmi.amu.edu.pl/
BOOBOO: http://booboo.cs.put.poznan.pl/
GIK: (tu niestety nie ma żadnej listy dyskusyjnej)

Następne w kolejności będzie zagregowanie forów, by łatwo śledzić co się na nich dzieje. (Może wystarczy odszukać adresy RSS?)

Pozostaje tylko pytanie do Was, drodzy czytelnicy. Znacie jeszcze jakieś fora w Poznaniu/okolicach? Czekam na linki w komentarzach!

GeeCON 2010 - Call for papers

2010-01-17T00:54:00.000-08:00

May will be great month to be in Poznan. We'll be having a biggest Java conference in Poland and eastern Europe. The list of speakers is already getting very interesting. If you will be around, consider visiting us. Below I'll paste the call for papers, specially that there's not much OSGi or Eclipse speakers yet.

There are also cool vids from last year, you might like to see.

GeeCON 2010 - Call for papers
We want you to share your knowledge with others during GeeCON!

We are interested in hosting lectures on subjects associated with Java
and software engineering, such as:

Java EE, OSGi, enterprise architecture patterns and best practices
rich internet applications (Flex, JavaFX) and Java Desktop applications
modern web frameworks (Wicket, Grails, JSF etc.)
domain specific languages
languages on the JVM (Groovy, JRuby, Scala, Clojure ...)
mobile computing (Android, Java ME)
JVM performance tuning
distributed computing
software quality assurance in the Java world (refactoring, automated tests, mutational test verification, static code analysis)
software configuration management (including tools like Maven, Gradle, Ant, Ivy)
agile methodologies
cloud computing

If you:

have experience in an interesting subject or a cutting-edge
technology,
want to share knowledge,
have good presentation skills,

don't hesitate! Prepare a short abstract about the topic you would
like to present during GeeCON and send it to us!

There are only a few rules:

call for papers starts on 2010-01-06 and ends 2010-02-28,
abstract should be about 250 words long and describe what you are
willing to present,
abstract must be accompanied by a short technical and presentational
resume,
lecture will be 50 minutes long and will be given in English
presentation will be prepared using a provided GeeCON template,
use this form to send your submission (don't send it via email)

in case you have any questions, contact us at call-for-
papers@geecon.org.

Feel free to send as many proposals as you see fit. Please, contact us
if you have any questions or doubts regarding your submission.

See you at GeeCON!

Web Yacht Sails Simulator

2009-11-07T02:20:00.000-08:00

Recently I'm fascinated with sailing. Some time ago I've finished a sailing course that will enable me to sail on some most popular tourist sail boats. The more I'm learning the more things are getting interesting. For example, it sounds obvious that moving a boat involves many forces that all interfere with each other, however the way in which this all works makes you can move not only with the wind but also by the wind. Of course sailor has to do a plenty of math (aka experiance) to get some decent speed.

Sailing makes for a wonderful subject in programming scenarios that I have in Eclipse Ajax Tooling (ATF) project, so I've started building a web yacht sails simulation. It will present a virtual boat that user can steer and put under various weather conditions.

First thing I had to do was refreshing my knowledge about vectors. There will be vector for wind, water stream, vectors for sails, rudder and various resistances. The other story is making it all visible. I chose to make an Ajax application running in the browser. HTML5 canvas is used to do all the drawing, this excellent tutorial makes it really easy to learn.

You can see first results here. A couple of vectors on HTML5 canvas. Drag and drop vector arrows to move them around. Some vectors are 'read-only' because they're dynamically calculated from others.

There's also short screencast embeded below, which might be not visible in RSS reader:

Vector Math from Jacek Pospychala on Vimeo.

Next to do: draw boat and model some physics.

Eclipse Ajax tools help is on wiki!

2009-11-04T04:09:00.000-08:00

When Eclipse Ajax Tools Framework (ATF) re-started delivering builds some time ago, we scored some negative feedback that it's hard to find what actually ATF does, and how it should be used.

This information, initially located in ATF help plug-in, was simply too hard to find. Now it's available at wiki and hopefull we'll be able to keep maintaining it both in wiki and eclipse help format.

Check out sexy ATF help :-)

btw. missed the Movember story? Ian explains.

ATF needs a logo!

2009-08-27T03:44:00.000-07:00

If you feel you can fit javascript, XML, asynchroniousness, XMLHttpRequests, dynamics and web 2.0 into small colourful picture, namely an icon or logo - read on!

ATF is looking for really cool logo to show up in such places as Open Web Tools Directory (Thanks to Mike for sharing this link).

How about these proposals?

PDE Plug-in registry to query your Equinox install

2009-08-19T07:33:00.000-07:00

This year's Google Summer of Code is nearing the end so it's high time to see some results. Under PDE umbrella Wojciech Galanciak is working on making PDE Plug-in registry view able to show you contents of your Equinox/Eclipse/any OSGi application (project details here).

It's like OSGi console, except that you can easily browse all extension point details, services details, bundles details, use filtering, easily scroll and so on.

.

Today he posted some demos:
First demo shows how to connect with remote applicaiton (or local in other JVM).
The second one how to use self-hosting mode in plugin registry view.

Check them out and share your thoughts either on pde-dev or directly in bugzilla.

Enjoy!

Ajax-heavy development, Javascript debugging for anyone?

2009-07-24T11:10:00.000-07:00

After busy week at my new job, today I was really happy to post an announcement that Ajax Tools Framework is getting new life. In last days it was updated and reorganized a bit to work with Eclipse Galileo and now is available for install from nightly builds update site.

ATF, was home for JavaScript Developer Tools (JSDT) and couple other features that later found their place in WebTools project. Unfortunately not all cool stuff had this luck.

Probably the best features still there in incubation are Mozilla IDE and Javascript debugging. Mozilla IDE brings lots of tools to x-ray your webpage. Among others, you can live edit page DOM model and see how the page look changes, play with CSS details or monitor HTTP requests. Javascript debugger is, as you guess, the reincarnation of everyone's favourite Debug perspective but for JS language.

Some of those features work well, while other still need some love, so our plan for next weeks is to make Mozilla IDE and Javascript debugging really strong and robust.

Let's try ATF and share your thoughts on mailing list or newsgroup! ... or tweeeter :-D

Stretching target platform

2009-07-22T23:45:00.000-07:00

I'd like to share with you the target platform for my new project:

You see it's not something typical one would have installed in Eclipse - there's a bunch of plug-ins from Mozilla or WTP repositories. Wouldn't it be troublesome for a newcomer willing to contribute? Install this and that from here and there... Oh and yes, then install their dependencies... Nooo!

But now, since Target Platforms can contain any repositories, I just configured all the dependencies there and posted the atf.target file next to the PSF file.
Now setting up the whole environment is as simple as importing two tiny files :-)
Horey! Thank you PDE (btw. what a new tasty home page :-))