Gorkem Ercan

Secrets and Types

noreply@blogger.com (Unknown) — Fri, 28 Aug 2020 20:10:00 -0400

If you are deploying your applications to kubernetes it’ s likely that you are using Secrets to manage your sensitive data. More and more tools aim to make working with them easier. Secret is a simple resource. In addition to usual kubernetes resource fields, it has a type and data. The expected data keys change depending on the value of the data. This is where the tooling can help. The available documentation that covers types and data keys to guide the developers is scarce. So here is my attempt for one.

Opaque

This is the default secret type that can be used for defining arbitrary user-defined data.

Service Account Token (kubernetes.io/service-account-token)

Contains a token that identifies a service account to the API

Data Key	Definition	Required
token	A token that identifies the service account to the API	Yes
kubernetes.kubeconfig	kubeconfig data for service account token	No
ca.crt	Root certificate authority	No
namespace	Namespace to use as the default for namespaced API calls	No

It also requires annotations on the secret

Annotation	Definition	Required
kubernetes.io/service-account.name	The name of the ServiceAccount the token identifies	Yes
kubernetes.io/service-account.uid	the UID of the ServiceAccount the token identifies	Yes

Dockercfg (kubernetes.io/dockercfg)

Contains a dockercfg file that follows the same format rules as ~/.dockercfg

Data Key	Definition	Required
.dockercfg	a serialized ~/.dockercfg file	Yes

Docker Config JSON (kubernetes.io/dockerconfigjson)

Contains a dockercfg file that follows the same format rules as ~/.docker/config.json

Data Key	Definition	Required
.dockerconfigjson	a serialized ~/.docker/config.json file	Yes

Basic Authentication (kubernetes.io/basic-auth)

Contains data needed for basic authentication.

Data Key	Definition	Required
username	username used for authentication	Yes
password	password or token needed for authentication	Yes

SSH Authentication (kubernetes.io/ssh-auth)

Contains data needed for SSH authentication.

Data Key	Definition	Required
ssh-privatekey	private SSH key needed for authentication	Yes

TLS (kubernetes.io/tls)

Contains information about a TLS client or server secret. It’ s primarily used with TLS termination of the Ingress resource, but may be used in other types.

Data Key	Definition	Required
tls.key	TLS private key	Yes
tls.crt	TLS certificate	Yes

Bootstrap Token (bootstrap.kubernetes.io/token)

Used during the automated bootstrap process (first implemented by kubeadm). It stores tokens that are used to sign well known ConfigMaps. They’ re used for authentication.

A conference for Eclipse heads

noreply@blogger.com (Unknown) — Tue, 6 Dec 2016 15:51:00 -0500

Since, the first EclipseCon in 2004, that was held in Disneyland, Eclipse had a conference in US. I missed all the Disney music of 2004 and my first EclipseCon was in 2005 but I have presented on various EclipseCons since then. Throughout these years, I was able to observe the variances on interests for EclipseCon audiences. However it is a challenge to form an EclipseCon program that is equally interesting to developers of Eclipse technology and Eclipse users. This year the job had become a bit easier, to serve varying interests EclipseCon is teaming up with Devoxx US and becoming Eclipse Converge.

As part of the program committee for Eclipse Converge, my goal is to shape a program in the spirit of the early EclipseCons where the talks would be concentrated around building and innovating on Eclipse projects. If you have talks that are deep in Eclipse technology, please submit them. At least I will be voting for them.

And who knows we can bring the Disney music back to EclipseCon next year!

Benchmarking JavaScript parsers for Eclipse JSDT

noreply@blogger.com (Unknown) — Tue, 17 Nov 2015 13:36:00 -0500

The JavaScript parser for the Eclipse JSDTproject is outdated. It lacks support for the latest EcmaScript 2015 (ES6)standard and has quality issues. Moreover, the parser on JSDT is derived from the JDT’s Java parser, hence it is not adopted by the JavaScript community at large, leaving the JSDT committers as the sole maintainer. Luckily, there are good quality JavaScript parsers that already support a large number of tools built around it. However, these parsers, like most of the JavaScript tools, are developed using JavaScript and requires additional effort to integrate with Eclipse JSDT which runs on a Java VM. In the last few weeks, I have been experimenting with alternatives that enables such integration.

Parsers

Before I go into the details of integration let me quickly introduce the parsers that I have tried.

Acorn	Acorn is a tiny parser written in JavaScript that supports the latest ES6 standard. It is one of the most adopted parsers and used by several popular JavaScript tools. It parses JavaScript to ESTree (SpiderMonkey) AST format and is extensible to support additional languages such as JSX, QML etc.
Esprima	Esprima is also a fast, tiny parser that is written in JavaScript, which also supports the latest ES6. Its development has been recently moved to JQuery foundation and has been in use on Eclipse Orion for a while. Just like Acorn it also uses the ESTree AST format.
Shift(java)	Shift(java)is the only Java based parser on my list. It is a relatively new parser. It uses Shift AST as its model which is different from the widely adopted ESTree.

Note

Why does AST model matter?

AST model is what actually what tools operate on. For instance a JavaScript linter first uses a parser to generate an AST model and operates on the model to find possible problems. As one can imagine, an IDE that uses a widely adopted AST model can utilize the ecosystem of JavaScript tools more efficiently.

Eclipse JSDT already comes with a JSDT AST model that is used internally that is very hard to replace. Therefore, regardless of the AST model generated by the parser it will be converted to JSDT’s own model before used. Which renders discussionsaround the AST models moot in JSDT’s context.

Integration

The parsers other than Shift, which already runs on the Java VM, need a mechanism to play nice with the Java VM. I have experimented with 3 mechanisms for running Acorn and Esprima for JSDT so far.

Node.js	Utilizes node.js to run the parser code. node.js runs as an external process, receives the content to be parsed and return the results. I have chosen to use console I/O to communicate between node.js and Java VM. There are also other techniques such as running an http or a socket based server for communication. In order to avoid the start up time for node.js, which does affect the performance significantly, node.js process is actually kept running.
J2V8	A JNI based wrapper that bundles V8 JavaScript VM. It provides a low level Java API to execute JavaScript on bare V8 engine. Although it uses V8, it does not provide the full functionality of node.js and can only be used to execute selected scripts, fortunately Acorn and Esprima parsers can be run with J2V8.
Nashorn	The JavaScript engine that is nowadays built into Java 8. Provides a simple high level API to run JavaScript.

Performance Benchmarks

The criteria for choosing a parser may vary from the feature set, to AST model used, to even community size. However performance is the one criteria that would make all others relevant. So in order to compare the performance of different alternatives I have developed a number of benchmark tests to compare parsers and the mechanisms.

All benchmark tests produce a result with an AST model, either in JSON form or as a Java object model. Tests avoid the startup time for their environments, for instance the startup time for the node.js process affects the results significantly but are discarded by the tests. The current test sets use AngularJs 1.2.5 and JQuery Mobile 1.4.2 (JQM) as the JavaScript code to be parsed.

Table 1. Average time for each benchmark
Parser(Script)	Runtime	Score	Error
Acorn (AngularJS)	J2V8	118.229 ms	± 1.453
Acorn (JQM)	J2V8	150.250 ms	± 4.579
Acorn (AngularJS)	Nashorn	181.617 ms	± 6.421
Acorn (JQM)	Nashorn	177.265 ms	± 9.074
Acorn (AngularJS)	NodeJS	59.115 ms	± 0.698
Acorn (JQM)	NodeJS	34.670 ms	± 0.250
Esprima (AngularJS)	J2V8	98.399 ms	± 0.77
Esprima (JQM)	J2V8	114.753 ms	± 1.007
Esprima (AngularJS)	Nashorn	73.542 ms	± 0.450
Esprima (JQM)	Nashorn	73.848 ms	± 0.885
Shift (Angular)	JavaVM	16.369 ms	± 1.019
Shift (JQM)	JavaVM	15.900 ms	± 0.325

As expected Shift parser which runs directly on top of JavaVM is the quickest solution. To be fair, Shift parser is missing several features such as source location, tolerant parsing and comments that may affect the parsing performance. However even after these features added it may remain the quickest. I feel that the performance for J2V8 can also improve with more creative use of the low level APIs however there is so much memory copying between Java heap to JNI to V8 heap and back I am not sure if it would be significant.

The surprise for me is the Esprima’s performance with Nashorn. It is unexpected in two ways. It is actually the third quickest option however Acorn does not give the same level of performance.

5 Cordova project configurations for iOS and Android

noreply@blogger.com (Unknown) — Thu, 1 Oct 2015 18:09:00 -0400

Apache Cordova command line tool(CLI) provides a unified way to manage and build mobile applications across platforms. Unfortunately, it is not always possible to provide configuration options generic enough that span all supported platforms. For those cases, Cordova takes a platform specific approach.

Here is a small guide for 5 of these less known configuration options. All of these options are managed on the config.xml file on your project. As attributes of the root widget node.

android-packageName

Normally, the the package name for an Android application is generated from the id of the Cordova application. Presence of android-packageName on the config.xml causes the package name on AndroidManifest.xml and java package name for the activity class to be generated from its value.
android-activityName

The android-activityName attribute allows the main activity name to be specified. Activity name is one of those things that cannot change in Android. Therefore this feature becomes useful when renewing an older implementation with a Cordova based one or upgrading between Cordova versions that have different default activity name values.
android-versionCode

Sets the versionCode value on the application’s manifest file. If android-versionCode is not specified versionCode is generated to have the default value of 1. If you are wondering why the default value is 1 instead of the value of the version attribute, this is because versionCode is restricted to be an integer.
ios-CFBundleIdentifier

ios-CFBundleIdentifier determines the value of CFBundleIdentifier key in the Info.plist file of your application. This key is the unique identifier for your application on the system. If ios-CFBundleIdentifier is not specified the value of the id field will be used when generating Info.plist.
ios-CFBundleVersion

This is the iOS cousin of the android-versionCode explained earlier. They pretty much serve similar purpose on their respective platforms. You should be aware of the quirks when defining the value. If ios-CFBundleVersion is not specified the value of the version attribute is used for generating the iOS application.

Here is a complete example that specifies all the values:


  <widget id="application.id" version="0.0.1"
    xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0"
    android-packageName="the.android.packname"
    android-activityName="MyCoolActivity"
    android-versionCode="4"
    ios-CFBundleIdentifier="my.legacy.ios.id"
    ios-CFBundleVersion="0.0.3">
  </widget>



Try Red Hat's Mobile Application Platform on Openshift
noreply@blogger.com (Unknown) — Wed, 29 Jul 2015 15:28:00 -0400
You can now try the Red Hat Mobile Application Platform (RHMAP) yourself. This is the platform that Red Hat acquired last year and now there is a version of it running on Openshift online. If you have an Openshift online account, browse to openshift.feedhenry.com and request your invite. Both Openshift online and RHMAP invite are free.

As a bonus, here is a video that shows how to use JBoss Developer Studio 9 and RHMAP together to build Apache Cordova based applications.





What is new on Eclipse Thym 0.2.0
noreply@blogger.com (Unknown) — Fri, 20 Mar 2015 11:25:00 -0400
We have just released a new version of Eclipse Thym. 

Compared to 0.1.0 release the highlights for the 0.2.0 release are.
Working sets are supported on New Hybrid Mobile Project wizard: You can add your Hybrid Mobile projects to JavaScript working sets during project creation.
Convert existing Eclipse projects to a Hybrid Mobile project: Any existing Eclipse project, that has a proper config.xml and www directory, can be converted using the Configure > Convert to Hybrid Mobile Project menu item. This feature also introduces a new API to enable adopters to programmatically convert existing projects to Hybrid Mobile projects.
Icon and Splash Screen support for iOS and Android builds:  If your config.xml has icon and/or splash screen references. Native project or executable exports created from Thym will honour them. Refer to Apache Cordova documentation for details of icon and splash screen support. 
As usual Thym 0.2.0 is available from these update sites and Eclipse marketplace.
Update existing installs:
http://download.eclipse.org/thym/releases/latest/
Release repository good for building against:
http://download.eclipse.org/thym/releases/0.2.0/


GPIO with Node.js in Pidora
noreply@blogger.com (Unknown) — Fri, 2 Jan 2015 11:21:00 -0500
So you have node.js running on a raspberry pi (if not see earlier post), I guess next you want to do some physical computing, and get some LEDs blinking.

In order to do physical computing, you need a library to access GPIO. Luckily, there is no shortage of   libraries for GPIO on npm. Without spending too much time, I have tried a few of them and for no particular reason, I have chosen to use wiring-pi.  wiring-pi is actually bindings to the WiringPi , a well known C library for GPIO.

Pidora actually includes WiringPi so you can actually start using it right away. It does come with a command line utility called gpio. However, the wiring-pi npm package does check out and compile its own copy of the library so if you do not already have it installed on your raspberry pi, do not worry.

Because wiring-pi needs git to retrieve WiringPi,  you need git to be available on your raspberry pi. First install it using

yum install git

Now you are ready to install wiring-pi

npm install wiring-pi

If you have followed my earlier post for installing node.js, you probably have a second node installation that came with pidora. In some cases, gyp conflicts with this obsolete one and installation of the wiring-pi may fail. To fix remove gyp and try to install wiring-pi again.

yum remove gyp
npm install wiring-pi

Since blinking LEDs were mentioned, here is a sample code that I have used, which is the example code from wiring-pi Github repository with a small change.




Pidora Node.js quickstart
noreply@blogger.com (Unknown) — Sun, 14 Dec 2014 22:07:00 -0500
I have been using pidora (a fedora remix) for my raspberry pi experiments. So far, pidora has been treating me fine. However, you can quickly notice that pidora lacks documentation compared to debian based raspbian, so here is my instructions for getting node.js to work on pidora.

Actually, if you try to install node.js from yum repository, you will notice that node.js is available and can be installed. In fact, it was version 0.10.25, which was OK, when I was writing this.  However, when I tried to run an application with it, it failed with the message "Binary compiled with -mfloat-abi=hard but without -DUSE_EABI_HARDFLOAT". As one can imagine, I have not pursued further this road and looked other options.

So next option is to get node.js directly from the node.js distribution. First download the latest arm build for node.js. Although the latest release for node.js is 0.10.33, the latest ARM build I could find was 0.10.28.

wget http://nodejs.org/dist/v0.10.28/node-v0.10.28-linux-arm-pi.tar.gz

Next extract the contents, move contents to /opt/node and link the bin folder to /opt/bin. I guess you can use different directories but can't imagine why.

tar xvzf node-v*
mv node-v* /opt/node
mkdir /opt/bin
ln -s /opt/node/bin/* /opt/bin/

Check that PATH includes /opt/bin. If it does not, edit /etc/profile to include it on PATH.  Now you should be all set. Of course, you need a library for accessing GPIO, and have your LEDs blinking but that is subject for another post.


Adoption... Sort of
noreply@blogger.com (Unknown) — Mon, 14 Jul 2014 21:57:00 -0400
Apparently, myeclipse has started to use bits and pieces from Thym. It was brought to my attention that the plugin wizard image on the myeclipse feature page is from Thym. You can compare it with an image of the same wizard on JBoss tools features page for yourself. I have not tried the product myself hopefully it is working well.
Normally, I would be very excited about a product adoption happening this quickly. However, the folks behind this product have a different way of adopting open source software, which usually means project Thym will get zero benefits from this adoption. Of course, one can only hope for a positive surprise.


Sharing Cordova projects becomes easier
noreply@blogger.com (Unknown) — Tue, 10 Jun 2014 11:59:00 -0400
Whether a project is created using Cordova's CLI or the Eclipse Thym (or JBoss Tools) sharing Cordova projects within a team is unpleasant. Cordova projects include generated artifacts and binary files in their source tree which violates source code management (SCM) best practices.

The first set of generated files are on the {$PROJECT_ROOT}/platforms directory. When using Cordova CLI when a cordova platform add {$PLATFORM} command is issued on a project, a {PROJECT_ROOT}/platforms/{$PLATFORM} directory is generated. This directory contains all your artifacts from {$PROJECT_ROOT}/www, {$PROJECT_ROOT}/merges/{$PLATFORM} directories and all the files necessary to create a native application with the platform build tools. Fortunately, Eclipse Thym generates platform folders on a temporary location and only when needed, hence does not share this problem. When using SCM tools, {$PROJECT_ROOT}/platforms should not be added to source management. For long term sanity, developers should do the extra step when they get the code from SCM and issue  "platform add" commands for the platforms that they will work on.

The {$PLATFORM_ROOT}/plugins folder includes the files for Cordova plugins installed to the project. These files are not usually modified by the developers but installed with the cordova plugin add {$PLUGIN_ID} command. This command creates a {$PLATFORM_ROOT}/plugins/{$PLUGIN_ID} directory and copies the plugin's files in. Eclipse Thym also does a similar thing but it uses a filter on the project explorer so that the files do not confuse developers. Since these files can be regenerated and are not modified during daily development, it is a bad practice to add them to the SCM tools. Because both Cordova CLI and Eclipse Thym did not have a record of installed plugins other than the directories under {$PLATFORM_ROOT}/plugins/ directory, it was not possible to avoid adding them to SCM.

Recently, I have added a couple of new commands to Cordova CLI. cordova save plugins saves the list of currently installed plugins to config.xml. cordova restore plugins reads these entries from config.xml and restores them to the project. The save command also comes with a --shrinkwrap flag to freeze to the installed versions of the plugins. Of course, Eclipse Thym also implements this feature. Here is a demo that shows the feature at work.



With the new save and restore commands and its implementation on Eclipse Thym, it is considerably easier to share Cordova projects but we are not done yet. At this time, restore and save commands support restoring plugins only from Cordova plugin registry but support for more sources should be expected in the future. It is also planned to extend these commands to platforms.

UPDATE: The commands and the functionality has evolved since the original post. Please refer to Cordova platform and plugin version management guide for the latest.


Eclipse is changing and that is a good thing
noreply@blogger.com (Unknown) — Mon, 31 Mar 2014 22:19:00 -0400
After missing a few years, I have attended the EclipseCon NA 2014 this year.  I am not sure if it is because I missed a few of these but I felt a deep change in Eclipse. I think the change roots from the fact that Eclipse foundation nowadays, has almost no restrictions on the type of projects that it hosts. I am not sure when this was actually relaxed. Back in the day, it was required that all Eclipse projects to use OSGi as runtime, hence be developed with Java. Nowadays, any project regardless of the runtime, development language is welcomed as long as it agrees to adhere to eclipse way. I believe this has triggered a slow shift on Eclipse from being a tooling community to a larger scoped open source community. I expect to see this change to accelerate in coming years as Eclipse's perception as a tooling only community slowly fades.

Looking at the interest and attendance from project committers, I am sad to report that Eclipse WTP project is terminal. There are a couple of reasons why an important project such as WTP is not dead yet. First, it has a large user community as indicated by download numbers. Also, it has a lot of commercial, and open source products that depend on WTP or parts of WTP. One would imagine that this dependency would create a lot of contributions to upstream. However, most of these products, for one reason or another, prefer to build around WTP and not contribute. I do not think we will be seeing new features on WTP anytime soon if ever.

I did receive a good amount of attention to my Hybrid Mobile development talk and the new Thym project proposal. I have started listing some of the interested parties to the proposal. And also was able to recruit Doug Schaefer and Chris Aniszczyk as mentors to the project. If you would like to be listed as an interested party and show your support, it is not late, please do let me know.

I am continuing my great open source community conferences tour with ApacheCon. It will be my first one, so I am not sure about what to expect. I will be speaking about building Cordova applications with Eclipse IDE on Tuesday. April 8, which should be fun.





Talking About Cordova Tooling and Thym Project Proposal
noreply@blogger.com (Unknown) — Wed, 12 Mar 2014 00:55:00 -0400
This spring turning out to be the season for conference sessions for me. I will be speaking about the new Hybrid (ehh... well Cordova) development tools on three different conferences. 
The series starts with EclipseCon next week. My "Hybrid Mobile Development Tools for Eclipse" session will be on Tuesday, March 18, 2014 between 13:30-14:05. 

Also, we had a recent proposal to move the development of most of the JBoss Hybrid Mobile tools to Eclipse. This will give me a chance to discuss anyone who is interested on Hybrid Mobile tooling for Eclipse and get the project going possibly faster. If you are attending and would like to discuss please let me know or just find me at the conference. 


Multiple Cordova Engines on JBoss Hybrid Mobile Tools
noreply@blogger.com (Unknown) — Thu, 9 Jan 2014 13:16:00 -0500
Until this week,  JBoss Hybrid Mobile Tools were able to work with a single Cordova version. To add insult to injury that single version (which is Cordova 3.1.0) was embedded in and was not changeable. However, Santa was busy and just dropped an initial implementation of multiple Cordova engine support to nightly builds. Below is a video of it in action. If you are cool enough to get the nightlies, instructions are on the project's site .


A word of caution is needed though. This feature is still under development. If you really really need to use a different cordova version it will do the trick but for anything else I would wait for the release before moving my production code. Please do try the feature and provide feedback either on the related issue  or create new ones. 


Not even a year
noreply@blogger.com (Unknown) — Thu, 12 Dec 2013 22:42:00 -0500
Within the past 12 months, I had a baby boy, moved to a new country, changed my job and developed a set of Eclipse plug-ins for developing Cordova applications.

The Hybrid Mobile development tools, as I called it, is about to be released as part of the JBoss Tools 4.1.1 release. Below is a video overview of the main feature set that is available in this release. 



We have a good set of features implemented but we are not done yet. Please do use the tools and provide your feedback on the current feature set and future ones. If you feel like making some changes you can fork the project on github.

In the mean time, we have started to explore if Eclipse Foundation would be a good place to further expand the development of the project. I am also interested to hear thoughts on that as well.


Exporting on JBoss Hybrid Mobile Tools
noreply@blogger.com (Unknown) — Mon, 29 Jul 2013 14:00:00 -0400
Work that I have been doing on tools around Apache Cordova is continuing its progress. I have been aware that we were not doing such a great job with exporting stuff out of our new project type, Native Hybrid projects. So I have been working to build a couple of new export wizards to fix this problem. Overall the development of the wizards have taken a longer time then usual because I decided to introduce extension points to accommodate easier integration of platforms in addition to currently supported iOS and Android. More on the extension points later as it deserves a post of its own.

The first of the wizards allows developers to export Native Platform Projects. Basically it generates a native project with all the bits from Apache Cordova for that platform that you can open/build/run via the platform's tools. For example, on iOS the exported project is an XCode project that can be build/run using XCode. Here is a screencast that shows export Native Platform Project wizard in action.



The second wizard is Mobile Application Export wizard. It helps you to export a native platform binary that is build for release. Depending on the platform, you can run this binary on a real device directly or after signing. At this time, we do not sign the binaries, but I do wish to support it in the future. I think this will be a critical feature if/when we support remote compilers.

We are moving as (reasonably) fast as possible to add new features to the project so project is actually on that exciting stage to contribute. If you are interested, it is hosted on github and your pull requests are always welcome. If you feel the need to contact me, you can use the JBoss tools mailing list or the #aerogear or #jbosstools irc channels on freenode.


Hybrid Mobile Application Development with JBoss Tools
noreply@blogger.com (Unknown) — Wed, 1 May 2013 19:19:00 -0400
I have been working to create an Eclipse based tool for developing hybrid mobile applications since I have joined Red Hat a few months ago. The tool is a set of plugins that make it easier to develop Apache Cordova based applications by hiding the details of the target platforms and allowing the developer to concentrate on building the application using the web development techniques.

We are still on the early stages of the development and not complete yet (but we are getting there fast).  Here is a list of features you can try and give feedback today. The instructions on how to get the latest builds is available on the GitHub project.

New Hybrid Mobile Project wizard. Creates a project structure that is compatible with the cordova-cli projects
Run on iOS emulator. Creates and compiles a XCode project and runs it on the emulator
Run on Android emulator. Compiles an Android project and runs it on the emulator
Run on Android device. Runs the project on an Android device if there is one attached. I should also note that Android functionality does not require the ADT plugins to be present. 
Config.xml editor.  Provides editing support Cordova's flavour of w3c widget specification XML configuration 
For those who needs more visual encouragement to try the tools, here is a video that shows creation and running of a Cordova project on iOS emulator with the JBoss Tools. 


We have more features coming in which includes a simulator environment for Cordova apps based on Ripple together with live reload support. If you have ideas for more features open them on JBoss jira, better yet implement them and create pull request to the project.




Using Nokia Maps on LWUIT applications
noreply@blogger.com (Unknown) — Mon, 8 Oct 2012 12:31:00 -0400
Nokia has a cool Maps platform with APIs that cover several platforms. Maps API for JavaME is one of those APIs. It is a quite well documented API especially for using with vanilla JavaME UI components (namely LCDUI Canvas). However, when it comes to JavaME applications, using a third party UI library instead of the vanilla JavaME UI components is a more common approach.

Since Nokia has chosen to port LWUIT to Series 40, I have naturally decided to create a small API to make it easier to use the Maps API with LWUIT.


The API is available on github. Repository also includes an example application that lists earthquakes on a list and map (see screenshots ). You can also find instructions that can get you started with the API quickly on the project's wiki. Furthermore, if you find bugs please do report them on github. If you want to improve the API or the example feel free to do that as well (that is why it is open source and hosted on github). And if you find the API useful drop a comment here.




A new IDE based on Eclipse MTJ
noreply@blogger.com (Unknown) — Tue, 26 Jun 2012 09:30:00 -0400

Nokia released a new version of the Nokia SDK for Java. In additon to supporting AshaTouch devices (devices with touch only input for you and me ), it includes a new IDE.  This new IDE is based on Eclipse MTJ. For those who remember, it also integrates to SDK discovery features of the now discontinued Pulsar distribution of Eclipse.

The main focus on this version of the IDE was to make it easier for newbies to Nokia platforms to discover and install the necessary tools and get started. On the discovery part IDE does a good job. As you can see from the screenshot it provides an extensive array of filters to find the right SDK for your project.

You should expect to see more features coming to the IDE and some of them will also appear on MTJ.


Besides the fact that I am the project lead for the Eclipse MTJ, this IDE makes me happy for an additional reason. I believe this is a product of my internal evangelism that has taken years to build up. For those of you who have not worked for the large companies (lucky you) this may sound strange.  But large corporations are like a community of their own and you basically spend more time advocating to your company than outside your company.

In this case, I had a positive result but in evangelism you encounter more frustrations than victories.


Slideset for New Features of Series 40 JavaME Platform
noreply@blogger.com (Unknown) — Tue, 6 Dec 2011 08:05:00 -0500
This is the slideset that I have used for JavaOne and the İstanbul developer day event. It highlights some of the major features introduced with Java Runtime 1.0 for Series 40 and Java Runtime 1.1 for Series 40.

More information including the tools and documentation for Java is available on the Nokia Java site.
The More Capable Series 40 Java Platform            
View more presentations from Gorkem Ercan.


What Angry Birds Is Using on Series 40 Phones
noreply@blogger.com (Unknown) — Thu, 27 Oct 2011 09:05:00 -0400
Rovio's Angry Birds made their entrance to the Series 40 with the Asha lineup of devices announced on Nokia World. If you have missed it Engadget has a post and video that features the mighty eagle showing off Angry Birds on Asha 303.

Angry Birds performs so well on these so called feature phones that it got people puzzled. I guess many people do not expect much from JavaME, therefore there had been questions whether this is actually a JavaME application or did Nokia open up its C libraries, or some other secret API to Angry Birds.

It is a well developed JavaME application! It does not even need access to APIs that are available to manufacturer/operator signed MIDlets. Below is a list of usual suspect APIs that Angry Birds uses as you can see it is a list of APIs that are available to any JavaME developer that targets Series 40.

CLDC(JSR-139)
MIDP (JSR-118)
MMAPI (JSR-135)
M3G (JSR-184)
Nokia UI API

So people, there is no mystery to Angry Bird's performance on Series 40, It is just an amazingly well developed JavaME application.


Nokia SDK 1.1 for Java available now.
noreply@blogger.com (Unknown) — Thu, 27 Oct 2011 07:56:00 -0400
At the NokiaWorld, Nokia announced Asha lineup of devices. There are extremely well built Series 40 devices that are likely to form a big market for developers quickly. Today, we are releasing the Nokia SDK Beta for Java 1.1 so that Java developers can start working on their applications right away.
Nokia SDK for Java 1.1
SDK is based on my favorite of the announced phones, Asha 303. Since the SDK is available today, you can develop and test your applications and be ready when devices are available on your target market.

Testing Support for In-App Purchase in Different Stages
As we are starting to accept applications that use the new in-app purchase functionality on Series 40 Java, we have enhanced the in-app purchase tools on the SDK. The IAP simulator, that was introduced on the earlier 1.0 release, now supports both offline and online testing for in-app purchase applications.

In the offline simulation mode, in-app purchase APIs will simply return the values that you have entered on the simulator to your application. This is particularly useful on the early stages of your development since it will allow you to start testing before even submitting the application to Nokia Store.

The online simulation and the test mode on the device is very similar. In this mode, SDK or the real device will communicate with the back-end servers. No monetary transactions will occur in this mode. It is possible to try out different scenarios such as failure of a purchase with the online simulation as well. The Nokia SDK manual that is installed together with the SDK provides more information on how to enable these modes.

This new emulator also significantly improves the system properties that you can access and simulate during development. All the Nokia system properties that were opened are now available on the SDK. In addition, you can simulate different values for the com.nokia.mid.batterylevel sysyem property and the com.nokia.mid.mnc and com.nokia.mid.countrycode values from the preferences.

The improvements and features are not limited to these, you can find the gory details on the Nokia SDK project. I have been using the SDK for my daily development for a while and it is already good for daily use. and available for download .




Speaking at JavaOne 2011
noreply@blogger.com (Unknown) — Sun, 25 Sep 2011 06:15:00 -0400
This year, I will be hosting a session in JavaOne titled "Getting the Most Out of the Series 40 Java Platform". As the title suggests, The talk is about the Java platfrom on Series 40 devices. I will be focusing around three topics that I believe will be interesting to JavaME developers. (1) Series 40 APIs for creating superior apps. for Touch & Type style devices. (2) Location features on Series 40 devices. (3) Monetization opportunities with the Nokia Store.

My talk takes place on Wednesday (Oct. 5) at 11:30 AM. It is at the Powell I/II room on Parc 55.


If JavaME solutions, such as the Series 40 platform enables, is in your interest, I recommend the following sessions.
Small Screens Playing a Big Boys' Game: A Playbook for Java ME in Emerging Markets (24101) 
Time and Venue: Tuesday 06:30 PM, Parc 55 - Cyril Magnin I/II/III
Java Moving Out of the Box in Emerging Markets (22700) 
Time and Venue: Tuesday, 07:30 PM, Parc 55 - Mission-	
Open Discussion on Emerging Markets (22721)
Time and Venue: Tuesday, 03:00 PM, Parc 55 - Mission-

For those interested on the quality of the JavaME applications, my colleague Risto Helin is hosting a session together with a bunch of quality enthusiasts called Unified Testing Initiative (JavaVerified for you and me).
Why Operators and Manufacturers Are Passionate About Application Quality (25021) 
Time and Venue: Thursday, 11:00 AM, Parc 55 - Mission-

Have a nice JavaOne and see you there.



Time To Renew Your Midlet's Icon
noreply@blogger.com (Unknown) — Mon, 5 Sep 2011 04:32:00 -0400

All Nokia platforms have received updates to its launcher icons recently. The common element introduced with the new iconography is the surround background shape. That means that the new icons for Nokia provided applications do not have pointy corners anymore. I guess the sharp pointy corners do reach out to human psyche and remind us of sharp dangerous objects, thus they feel unfriendly to many. If you have applications that are published on Ovi Store, I think this may just be a good time to renew them. Otherwise, the pointy corners of your icon may just stand out. 

To make it as easy as possible for you, the good folks in Nokia design have prepared detailed guidelines for creating icons that matches the new surround iconography. I strongly recommend reading through the material. It covers Series 40, Symbianand MeeGodevices and also provides Adobe Illustrator (AI) and Adobe Photoshop (PSD) templates to get you started.

You will quickly notice that the guidelines recommend using 43x43 PNG images on Series 40 and 96x96 SVGT images for Symbian phones. One may think that two different icons would require two versions of the Java application. Thanks to some magic with JAD attributes, you can bundle multiple icons into a single application JAR file. 

Java applications on Symbian have supported SVGT icons for a long time, you can read from the Scalable icon support document the details of how this works.  In short, in your JAD file you specify the Symbian SVGT icon name in Nokia-Scalable-Icon-MIDlet-1 attribute whereas the Series 40 PNG icon is defined in MIDlet-1 attribute. On Symbian devices where Nokia-Scalable-Icon-Midlet- attribute is supported, the SVGT icon will be used. Since Series 40 does not support the Nokia-Scalable-Icon-Midlet-  attribute, it will be ignored and the PNG icon specified on the standard Midlet- attribute will be used 

The resulting JAD file should have entries similiar to these.

MIDlet-1: HelloWorldMIDlet, /series40_icon_43_43.png, example.hello.HelloWorldMIDlet Nokia-Scalable-Icon-MIDlet-1: /symbian_icon_96_96.svg 

If you lack the Adobe photoshop/illustrator skills, there is also an online tool that you can use to convert your existing icon. Tool generates a SVG file which you can use directly on Symbian devices . Using a tool like the inkscape, you can convert the same SVG file to PNG for Series 40 devices. Although the resulting icon is OK for Series 40 use, the result may not be as favorable for Symbian devices. This is because the tool embeds our original icon into the SVG file, which may be somewhat unscallable.  For best results using a pure SVG icon is recommended.


New SDK for Series 40 Java
noreply@blogger.com (Unknown) — Wed, 8 Jun 2011 09:49:00 -0400
Beta version of the Nokia SDK for Java 1.0 is now publicly available. This new SDK is the replacement for the older Series 40 SDKs. It supports the development of the Series 40 touch and type applications. This new SDK is an initial step on the right direction for creating a better development environment for Series 40 developers.

The first thing to note about the SDK is the new installer and the SDK manager. This new infrastructure will allow developers to receive updates to the SDK.  My favorite feature is the diagnostics window. Most of my development uses cloud services. The new diagnostics window allows you to monitor the network traffic. This new feature already saved me a lot of time while using some REST services.
Diagnostics window

If you have a webcam on your developer desktop, you can now use it together with the SDK to test camera applications. Keep an eye on the diagnostics window while testing your camera application, you will notice instructions to press CTRL+W when your application needs to use the camera. You need to do this only once.

In addition to these new SDK features, there are the added tools for the new Series 40 features. SDK not only introduces the route editor for simulating location data but also provides additional support for cell-id based location inaccuracies.

Also introduced the in-App purchase simulator.  Yes, Series 40 is about to get new APIs for supporting in-app purchase, but more about that later. The simulation tool is not yet complete on the beta release and is provided as an alpha level tool to get early adopters to get familiar with the tools and API.

I think even in its beta release SDK provides a good alternative Java ME emulator with some bells and whistles. So give it a try, provide some feedback to the team.


Cultural implications on localization
noreply@blogger.com (Unknown) — Tue, 3 May 2011 03:32:00 -0400
An emerging pattern on mobile application stores is developers which target a limited local market initially, seek to expand their market after reaching a good amount of penetration on their initial market.

Reaching a new local market requires localizing your application however localization is not just about providing the strings translated to the local language. It gets much detailed quickly and touches cultural issues. These issues should be taken into consideration on all stages of the localization work. Here are a few tips, I have picked up regarding cultural issues on different stages of a localization project.

1. Define what should be localized
User visible text is the most obvious to localize but you should also look beyond text. Images and sounds should be considered as localization candidates as well. Unfortunately, the reasons for localizing images and sounds are usually cultural and harder to detect. For example, your great sports game may use the charge fanfare to indicate an offensive move, however on many parts of the world charge fanfare is not played on the sporting events and on those markets users do not associate it with an offensive move.

Here is a few cultural implications to consider when looking at what to localize.
Do not assume certain experiences such as the meaning of charge fanfare I have mentioned above.
Do not assume a certain history knowledge. Believe it or not but Boston tea party is for many represents a party in Boston that tea lovers attend.
Do not assume certain opinions, prejudices. Patagonia may represent a distant place for someone in Eurasia but someone in South America will have a completely different opinion about it.
Be respectful to religious and political beliefs.

2. Localize
It is essential that your localization specialist knows the target language well. I also recommend working with a specialist who is multicultural as well. Someone who does not only have a good understanding of the source and target languages only but also knows both cultures. I know on many occasions it will be hard (and expensive) to find multicultural talent but it is worth it. After all, it is the localization process that will ensure that the users on your new market will get your product and accept it.

In some cases, you should be ready to have localized versions of your sounds, images, icons in addition to text. You should leave room in your planning for the creation of these resources. It is also a good idea to implement a localization framework on your application that will allow you to easily use different versions of resources on different locales.

In my experience, for developers who use Latin characters daily, even when they pay extra attention to mirrored and double character languages, there are usually some details that were not right initially. If you are targeting one of those languages be prepared to handle them. I think the best help for mirrored and double character languages is to choose a UI technology that provides mechanics to handle them.

3. TestIt is best if the testing is done by people who are native to the target language and culture. This way you may also test if your localization was culturally successful besides being technically correct.