You are currently browsing the tag archive for the ‘Linux’ tag.

K64 1

Just released:

  • Oracle Java ME Embedded 8.2: Now even smaller!
  • Oracle Java ME SDK 8.2: Now with Linux tooling support!

Check out the details in the blog entry of my college Alex Belokrylov.

Stay tuned for more Java ME Embedded-related announcements in the coming weeks.


— Terrence

Newsflash 757208

Here is the next Java ME 8 Developer Drop, b58. As before, this is provided “as is”, with no guarantees of stability or functionality. 

To access, go to the EA #2 downloads page and look for “latest developer build”:

 Questions/feedback? Java ME Embedded OTN forum or


— Terrence

Newsflash 757208

Update 3/20/2014: Added notes for b54 drop.

As announced 2 weeks ago, we have started semi-regular developer drops of Java ME 8.

Developer Drop b54 was just pushed out today. As before, this is provided “as is”, with no guarantees of stability or functionality. 

To access, go to the EA #2 downloads page and look for “latest developer build”:

Note: It is recommended to use the NetBeans 8 RC1 or NetBeans 8 GA “All” bundle together with the latest Java ME SDK 8 developer build.


Change of Device Access API in the b54:

  • The Device Access API name and namespace has been changed to Device I/O (DIO) in preparation for the Java ME 8 final release. This requires that you update the package imports in your application. The latest DIO documentation can be found here.

Notes on changes for the Qualcomm IoE platform in b54:

  • The previously separate Netsetup BrewMP application has been removed and the functionality has been integrated into the Java runtime. Network setup for WiFi/3G is now done as part of the Java runtime initialization.
  • A new BrewMP application called reboot_java has been added. It is optional and can be used to trigger a soft reboot (Java reboot without board reboot).
  • Network setup, AccessPoint API, and Cellular API functionality has been improved/made more complete. 

Questions/feedback? Java ME Embedded OTN forum or


— Terrence

Newsflash 757208

Announcing Java ME 8 Developer Drops

Recently, we released Early Access #2 versions of Java ME 8 and Java ME SDK 8. A lot of developers tried it out and feedback has been great. As expected (after all, this was an Early Access release) – there are still bugs and deficiencies and we have been busy fixing them … many are already taken care of.

In order to enable the developer community to follow along and benefit from the latest improvements and fixes we decided to provide semi-regular developer drops alongside the Early Access #2 release. These developer drops are planned roughly every 14 days, are based on the latest builds and have undergone basic testing. They are provided “as is”, with no guarantees of stability or functionality. This is bleeding edge 😉

 You can access these developer builds on the same pages as the other EA #2 downloads (look for “latest developer build”):

Note: It is recommended to use the NetBeans 8 RC1 “All” bundle together with the latest Java ME SDK 8 developer build.


Please go ahead and give the latest developer builds a spin. And be sure to ask questions and provide feedback: Java ME Embedded OTN forum or


— Terrence

Newsflash 757208

Announcing Java ME 8 Early Access #2

This blog has been quiet lately, but not for lack of activity … quite the opposite.

We’ve been extremely busy with Java ME 8 – getting the specs (JSR 360: CLDC 8 & JSR 361: MEEP 8) ready for final ballot and working hard on updating the first Java ME 8 Early Access at JavaOne 2013 (learn moreby adding the latest features as well as new platforms.

So today, we’re announcing new update releases:

  • Oracle Java ME Embedded 8 Early Access #2
  • Oracle Java ME SDK 8 Early Access #2

These releases are designed to continue to drive Java ME 8 momentum in the industry by giving the community access to the latest Java ME 8 functionality and to demonstrate Oracle’s commitment to delivering Java ME 8 as a modern and purpose-built embedded software platform that addresses the rising demands of the embedded software industry and the Internet of Things.


Key features of the Java ME 8 and Java ME SDK 8 Early Access #2 releases: 

  • Improved support for the JSR 360 (CLDC 8 and GCF 8) draft
  • Improved support for the JSR 361 (MEEP 8) draft
  • Improved tooling support (Developer Agent, On-device Debugging, Memory Monitor, Network Monitor, CPU Profiler, Logging)
  • Improved networking and connectivity, including wireless support (3GPP, CDMA, WiFi)
  • Improved access to peripheral devices through Device Access API
  • New APIs for RESTful programming (JSON, OAuth2, HTTP client) 
  • Updated Java ME SDK 8 EA #2, improving support for new ME 8 functionality, platforms, peripheral devices, tooling, and integration with NetBeans 8 Beta
  • Ongoing support for APIs such as
    • File Connection
    • Wireless Messaging
    • Web Services
    • Security and Trust Services
    • Location
    • XML
  • Bug fixes, usability, performance, and footprint improvements

Supported Platforms: 

  • New support for Qualcomm IoE platform on Brew MP
  • Improved support for Raspberry Pi Model B on Debian Linux
  • Improved support for Windows 7 

Call To Action/Where to find more:

Go ahead and try Java ME 8. Give us feedback on the Java ME Embedded OTN forum or via


— Terrence

This is bigA few weeks ago, Oracle made available an updated release of Java ME Embedded, version 3.3, as an Early Access (EA) for Linux on Raspberry Pi (see blog entry).

Today, we are following up with the release on ARM Cortex-M3 for the ARM RTX RTOS on the KEIL MCBSTM32F200 developer board (*see note on Cortex-M4 below).

Why is this important?

With this release, Oracle now provides a Cortex-M3/M4 reference binary of the feature-rich, standards-based Java ME Embedded runtime, scaling from mid-range embedded systems such as Linux-based platforms all the way down to micro controller-type devices with limited memory and small RTOS or minimal kernels. System requirements:

  • Minimal Java ME Embedded configuration: 32-bit MCU, 130 KB RAM, 350 KB Flash/ROM
  • Full Java ME Embedded configuration: 700 KB RAM, 2000 KB Flash/ROM

Yes, that is Kilobytes, not Megabytes (!)

So take your existing Java skills, use familiar tools like NetBeans and Eclipse, and develop highly-functional, robust embedded applications for a wide range of embedded use cases and devices in a snap.

For example, you can begin developing your code on a powerful and flexible desktop-class system like Raspberry Pi. Later, you take the unmodified application binary and simply deploy it directly to the resource-constrained target devices running Java ME Embedded.

Sounds easy? It is: No cross-compilation, no complexities due to platform dependencies, no dealing different sets of architectures, tools, compilers, libraries, and versions, and significantly reduced integration and testing effort … in fact, many typical embedded software development pain points just evaporate (embedded developers: if you are crying tears of joy now, I understand – I’ve been there myself 😉

And on top of the rich set of functionality already provided by Java ME Embedded 3.2, version 3.3 adds a number of new features, such as an expanded and more flexible access to peripherals (such as ADC, DAC, Pulse Counter, and watchdog)improved logging functionality, tooling enhancements, additional new sample code, and more. Still in the same, low footprint.

Ok, great! What next?

  • Watch the brand-new webcast “Getting started with Java ME Embedded on KEIL” (part 1, part 2)
  • Order a KEIL MCBSTM32F200 from your favorite distributor (such as Mouser, Element14, or a number of others)
  • Review the Java ME Embedded 3.3 documentation, included “Getting Started Guides” and “Release Notes”
  • Download the Java ME Embedded 3.3 binary for KEIL MCBSTM32F200 from Oracle Technology Network (OTN)
  • Download and install the Java ME SDK 3.3 EA and/or the NetBeans and Eclipse plug-ins
  • Check out Angela Caicedo’s blog post “Getting started with Java ME Embedded on KEIL”

To learn more:

Getting in touch:

Stay tuned for more to come.


— Terrence

* Note: While the MCBSTM32F200 is the officially supported board, the release also works on the MCBSTM32F400 (which is the Cortex-M4 version)


Just back from Brazil and no time to catch my breath … so much happening:

  • JavaOne Latin America was a blast – so much enthusiasm in the developer community! Check out some of the videos and podcasts, including the JavaOne Community Keynote, OTN interviews with a variety of Java luminaries, as well as the Java Spotlight Podcast #60: JavaOne Latin America: Videos and Podcasts
  • Java 7u2 has been released, featuring an updated VM, support for Oracle Solaris 11, support for Firefox 5 and later, and security fixes. Also, JavaFX 2.0.2 is now included with Java SE to make developing and running JavaFX applications even easier: Java SE 7u2 Release Notes, JavaFX 2.0.2 Release Notes
  • Aligning with mainline JDK development, Java SE Embedded 7u2 has been released as well. This release includes new ports to Linux on PPC and performance improvements on ARM systems by 20-40%. Also, Oracle intends to port JavaFX to Linux on ARM in order to support a broad range of platforms from mid-range embedded all the way to desktops: Henrik’s blog on the Java SE Embedded 7u2 release.
  • Lots of activity around JavaFX as well – interest is really taking off. Point in case: A new project, eFX, has been started on aiming to create a generic application framework for JavaFX 2.0 based on the NetBeans platform: Geertjan’s blog on eFX
  • Finally, OTN put together a list of their “Most Popular Tech Articles of 2011”. Java topics, from Java SE 7 and 8 features, Java EE 6, JSF, and JavaFX dominate the list. Have a look: Our Most Popular Tech Articles of 2011


— Terrence

GuruPlug.pngEmbedded systems are becoming ever more powerful and affordable. Check out the GuruPlug, which is scheduled for release in a couple of weeks and has amazing specs:

  • Linux 2.6
  • 1.2 GHz ARM processor with 512 MB DRAM
  • 512 MB Flash, Ethernet, WiFi, 2 x USB, Bluetooth, GPIO
  • Low power consumption and small footprint
  • Java and OSGi available from distributor
  • Retail price: US $99 (standard version)

I haven’t played with one of these yet but at this price this is an awesome embedded platform for all sorts of interesting uses. I know I will get myself one!

The GuruPlug is but one in an amazing range of interesting devices: Be it the BUG, the ACME Systems FOX G20 board, the PC Engines ALIX 3D2 (a very compact and cheap PC-class SBC), the Nokia N900, the Marvell plug computer (as exemplified by the GuruPlug/SheevaPlug above), the Sun SPOT, and many more.

But it’s clear that with embedded devices being increasingly powerful and complex the old-school embedded development paradigm is becoming more and more outdated … a simple executable, a C compiler, and some cobbled-together libraries just don’t cut it anymore to build feature-rich embedded solutions on time.

Embedded Java is a perfect match:

  • Platform independence
  • A productive language
  • Multithreading and memory management built-in
  • Full-featured networking support
  • Comprehensive libraries for access to many platform features
  • Rich development tools

It’s all there to make embedded development so much more productive.

So, how do you get embedded Java onto your embedded devices? Pretty much all of these run Linux, so putting Java on them is actually pretty straightforward (sans the Sun SPOT, which runs Java out of the box already).

First, the question is about the processor architecture.

If you have an X86-based platform, such as the ALIX or a similar PC-class single board computer (SBC) it’s very easy since PC-compatibility is usually a given. So you can either run the standard Sun/Oracle Java SE for Linux distribution, or OpenJDK, or if you are developing an embedded solution, you should look at Java SE for Embedded (more on Java SE for Embedded below).

ARM-based platforms, however, often offer significant cost, size, and power consumption benefits over traditional X86-based solutions. The really cost efficient, low-power platforms such as most mobile devices, handheld systems such as the N900, or embedded systems such as the plug computer, all utilize ARM SOC (system-on-a-chip) designs.

Java on ARM requires a little more planning than Java on X86. The reason is that you typically need to factor in your design priorities: Is cost and footprint of overriding concern and therefore you forgo a JIT (just-in-time) compiler to save memory? Or does your embedded solution require highest Java performance and thus require the additional 8 to 64 MB memory budget needed (depending on the system) for a JIT compiler? And finally, is a JIT compiler supported for your architecture?

Depending on that decision, you have a number of options: Cacao, JamVM, phoneME, OpenJDK, Java SE for Embedded, and others. Let’s have a look at some of these:

  • Cacao, JavaVM, and phoneME have a long history in the embedded space. phoneME is a proven, robust solution with very effective optimization technologies, including a mature JIT compiler. But the other stacks offer benefits as well. See here for a series of blog entries comparing the different Java runtimes.
  • OpenJDK hasn’t been designed for embedded use per se, but there are various efforts under way to add JIT compilation for non-X86 platforms such as ARM, PPC, MIPS, and others: See the Zero/Shark project.
  • Java SE for Embedded is now available with full ARM support, including a JIT compiler – in fact, it supports 28 different ISA/OS combinations. Java SE for Embedded is fully Java SE-compliant, purpose built (for example, available in headless configurations) and is free for development purposes. Once you go to deployment Sun/Oracle offers affordable licensing. Check out the FAQ for details.
  • Jalimo is not a Java stack in itself, but a project which aims to bring Java to Linux-based devices, and which offers a robust build environment and packages leveraging different existing Java runtimes.

So, as you can see, there are plenty of options.

And once you have Java running on your target device you then have all the joys of development with Java: Advanced tools (NetBeans and many others), developing and testing on the host (no more complicated cross-compilation), and easy of deployment to the target (just run the class files on the target via memory card, Bluetooh, ftp/ssh, NFS, SMB, or other methods that works best for your situation).

I’m sure I have missed interesting projects and details – the area of embedded Java is wide and active, but I thought it would be useful to write-up some of the info that I’ve been collecting. Please feel free to post comments, corrections, or additional info!


— Terrence

Enter your email address to subscribe to this blog

Join 180 other followers

Twitter Updates

August 2020

Blog Stats

  • 280,276 hits