Skip navigation
ANNOUNCEMENT: community.oracle.com is currently Read only due to planned upgrade until 29-Sep-2020 9:30 AM Pacific Time. Any changes made during Read only mode will be lost and will need to be re-entered when the application is back read/write.

In my previous blog post, I did some experimentation with simultaneous execution of multiple threads. Since the threads were all doing relatively large chunks of work, the overhead from thread creation and management was almost irrelevant. In this post, I take a look at the overhead that launching a series of threads can have on an application.

The starting point is a modified version of the application I developed for the last post. A thread is called to perform some number-crunching. After the number-crunching is complete, a method is called to return the last result. As I said in my last post, it's a pretty useless application. However, it does a good job of fully utilizing whatever number of processors I'd like to use. And, since there's no real I/O happening (no disk reads/writes, etc.), it works quite well as a means for analyzing what happens when you perform different experiments with threads.

For today's testing, I removed all print statements (once I'd verified that the application was doing what I wanted it to do), so that the processing consists exclusively (or, at least as close as I could get to that) of the computational processing performed by each thread instance, and thread "overhead" (creating, launching, joining).

Here's the main class:

class ThreadOverheadTest {
  public static void main(String args[]) {
    int nThrCalls;
    NewThread thr1;
    double result = 0.0;
    int nWork = 1000000;
    int jWork0;
    int jWork1;
    int jWorkIncr;
    int iThrCall;
        
    if (args.length < 1) {
       nThrCalls = 1;
    } else {
       nThrCalls = Integer.parseInt(args[0]);
       if (nThrCalls < 1) nThrCalls = 1;
       if (nThrCalls > nWork) nThrCalls = nWork;
    } 
    
    System.out.println("Performing " + nWork + " total units of work using " + 
                       nThrCalls + " thread calls.");

    jWorkIncr = nWork / nThrCalls;
    jWork0 = 1;
    jWork1 = jWorkIncr;
    System.out.println("Each consecutive thread will perform " + jWorkIncr + 
                       " units of work.");
    
    while (jWork0 <= nWork) {
       thr1 = new NewThread("thr1"); // start thread
       thr1.SetWorkRange(jWork0, jWork1);
       thr1.t.start();

       try {
         // wait for other threads to end
         thr1.t.join();
       } catch (InterruptedException e) {
         System.out.println("Main thread Interrupted");
       }

       result = thr1.GetLastValue();

       jWork0 += jWorkIncr;
       jWork1 += jWorkIncr;
       if (jWork1 > nWork) jWork1 = nWork;
    }

    System.out.println("Final Result: " + result);
  }
}

So, we're going to perform 1 Million units of work (nWork). The argument defines how many consecutive threads will be launched to perform all the units of work. The default value is to do all the work using a single thread.

Here are the results when I run this using a single thread on my CentOS 6.2 Linux machine:

$ time java ThreadOverheadTest 1
Performing 1000000 total units of work using 1 thread calls.
Each consecutive thread will perform 1000000 units of work.
Final Result: 14142.13562373095

real    0m14.130s
user    0m14.102s
sys     0m0.025s

Here the computation thread is called once, and told to do all 1,000,000 units of work. This, then, is the baseline timing, the amount of time required to complete the computations basically in the absence of any thread overhead.

In case you're curious, here's the computational thread that performs the work:

import static java.lang.Math.pow;

// Create multiple threads.
class NewThread implements Runnable {
  String name; // name of thread
  Thread t;
  int iVal0;
  int iVal1;
  double lastVal;

  void SetWorkRange(int i0, int i1) {
    iVal0 = i0;
    iVal1 = i1;
    //System.out.println(name + " work range: " + iVal0 + "-" + iVal1);
    return;
  }

  double GetLastValue() {
    return lastVal;
  }

  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    //System.out.println("New thread: " + t);
    //t.start(); // Start the thread
  }

  // This is the entry point for thread.
  public void run() {
    //System.out.println(name + " starting, working on " + iVal0 + "-" + iVal1);
    try {
      for(int j = iVal0; j <= iVal1; j++) {
        for(int i = 1; i <= 200; i++) {
          double val0 = i;
          double val1 = j;
          double val2 = val0 * val1;
          double val3 = pow(val2, 0.5);
          lastVal = val3;
        }
      }
    } catch (Exception e) {
      System.out.println(name + "error" + e);
    }
    //System.out.println(name + " exiting.");
  }
}

A "unit of work" is the inner i loop that does the numerical computation. 14.13 seconds were required to perform 1 Million units of work, so each unit of work takes about 0.014 milliseconds to complete on my CentOS system.

Now watch what happens as the number of threads is increased:

                                               
Consecutive
Threads
Units of Work
Per Thread
Time to Complete
(seconds)
1100000014.13
1010000013.84
1001000013.90
1000100014.62
1000010018.61
1000001030.20
10000001117.30

It took a lot of threads running before there's much of a noticeable performance hit. But ultimately, by consecutively creating and running 1 Million threads, each performing a single unit of work, I was able to bog down my application's performance pretty severely.

You can't really say that all of the extra time represents thread overhead. For example, something as simple as flipping the i and j loops in the computational thread produces a somewhat different set of results. But, I think we can fairly safely state that creating and invoking 1,000,000 threads consecutively puts a significant burden on my system.

So why, you may wonder, was I interested in taking the time to create and perform this experiment? Because it provides a baseline for similar experiments I plan to perform using the Java 7 Fork/Join Framework and other JVM concurrency options, eventually including Project Lambda.


Java.net Weblogs

Since my last blog post, Harold Carr has posted two new java.net blogs:


Poll

Our current Java.net poll asks Will you use JavaFX for development once it's fully ported to Mac and Linux platforms?. Voting will be open until this Friday, March 2.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:

Multithreaded programming has been possible in Java for a very long time. That's a good thing, since modern computers and even many mobile phones are multicore today. If an application is primarily interactive, its processing speed is fairly irrelevant today -- the limiting time factor is how fast the user can type or move and click the mouse or touch the screen, etc. But, to increase the speed of applications that do a lot of work between user interactions, utilizing those multiple cores is necessary.

Java 7 introduced the Fork/Join Framework, and Project Lambda will bring Lambda Expressions (closures) into Java 8. So, a question developers will soon be facing is: what's the best way for me to take advantage of multiple cores in my specific application? Should I use traditional Java threads? The Fork/Join Framework? Lambda Expressions (once Java 8 is released)?

I've worked on multithreaded development since late 1993 -- though most of that work has been in C, running on SunOS, and later on Solaris, multiprocessor machines. An eight-processor SunOS machine in 1993 was fairly radically powered at the time. The code was mathematical models and analyses applied to various types of satellite data. The researchers developed their functions as single-thread code (often in Fortran); my job was to convert it such that it could efficiently utilize all eight Sun processors.

It was an adventure, to say the least!

Today I did some experimentation on my quad-core CentOS 6.2 system (and, just for fun, on my dual-core HP Mini, which runs some kind of minimal Ubuntu, as well) with a basic multithreaded Java application. Essentially, the code creates some threads, passes them a data range, has each thread do some work on all values that are in the passed-in range, then requests back a final result. Here's the actual thread class:

import static java.lang.Math.pow;

class NewThread implements Runnable {
  String name; // name of thread
  Thread t;
  int iVal0;
  int iVal1;
  double lastVal;

  void SetWorkRange(int i0, int i1) {
    iVal0 = i0;
    iVal1 = i1;
    //System.out.println(name + " work range: " + iVal0 + "-" + iVal1);
    return;
  }

  double GetLastValue() {
    return lastVal;
  }

  NewThread(String threadname) {
    name = threadname;
    t = new Thread(this, name);
    System.out.println("New thread: " + t);
    //t.start(); // Start the thread
  }

  // This is the entry point for thread.
  public void run() {
    System.out.println(name + " starting, working on " + iVal0 + "-" + iVal1);
    try {
      for(int i = 1; i <= 100000; i++) {
        for(int j = iVal0; j <= iVal1; j++) {
          double val0 = i;
          double val1 = j;
          double val2 = val0 * val1;
          double val3 = pow(val2, 0.5);
          lastVal = val3;
        }
      }
    } catch (Exception e) {
      System.out.println(name + "error" + e);
    }
    System.out.println(name + " exiting.");
  }
}

The starting point for this was an example in Herbert Schildt's excellent "Java The Complete Reference" which I reviewed a while back.

The class in my sample application is used as follows. For each thread:

  1. A new NewThread is created;
  2. SetWorkRange is called to specify a data range for the thread's execution;
  3. The thread is run;
  4. The main app waits for the thread's processing to complete;
  5. GetLastValue is called to return the last result for the thread's execution.

A pretty useless multithreaded application, no doubt! But, it did let me gather some numbers on the relative performance of running computation-centric code with different numbers of threads on my computers.

I analyzed the data range from 1 to 8000, running with 1, 2, 4, and 8 threads, dividing the work equally between each thread. So, in the single-thread case, I called SetWorkRange with 1 and 8000; in the two-thread case, I calledSetWorkRange with 1 and 4000 for the first thread, and 4001 and 8000 for the second thread; etc.

Here are the timing results on my CentOS 6.2 quad-core system:

                             
ThreadsClock Time
(seconds)
CPU Time
(seconds)
153.253.2
226.753.2
413.753.2
813.553.4

These results imply basically perfect scaling out to the number of processor cores in my system; and they imply no real loss (even a tiny clock-time improvement) from running eight threads on my quad-core processor.

Here's what happened on my HP Mini (which wasn't exactly designed with high-volume computation-intensive processing in mind):

                             
ThreadsClock Time
(seconds)
CPU Time
(seconds)
11741.81682.0
21433.11802.4
41235.01860.8
81097.11868.2

The itty-bitty Mini found the task daunting, to say the least. The results don't make a lot of sense, if I'm right that my HP Mini is a dual-core machine. The fact that the application completed in less time as the number of threads were increased to 4 and 8 is interesting, but my guess is that it reflects upon the uniqueness of the HP Mini's hardware and OS more than anything related to Java or my test app.

What I like about today's experimentation is that it demonstrates some of the complexity that's involved in efficiently utilizing the available processing power in any device. Same app, two different devices, with widely differing processing capability. The result? A quite different performance per number of threads graph for each device... So, how's a Java developer to write an efficient multi-platform "write once, run anywhere" application in this modern multicore world???

I'll be investigating this via a new Java.net project (not yet public) and blogs starting with this one. It's a topic I know lots about from my early work with multithreaded development on C on Sun multiprocessor computers, and also from my work on Intel's open source ThreadingBuildingBlocksproject (see my Intel Software Network blogs).

In the end, successful multithreaded programming is all about applying language capabilities to efficiently utilize the available multicore/multiprocessor hardware resources. Java currently offers multiple methodologies for addressing this problem, and new methods will arrive with Java 8. It's going to be exciting to investigate and test what works best in what situations!


Java.net Weblogs

Since my last blog post, several people have posted new java.net blogs:


Poll

Our current Java.net poll asks Will you use JavaFX for development once it's fully ported to Mac and Linux platforms?. Voting will be open until Friday, March 2.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:

About a month ago, I tried to get started with the JavaFX 2.1 Developer Preview on my CentOS 5.5 Linux system. I didn't get very far, due to dependency problems (a great many of the CentOS 5.5 packages were too old). After deciding I didn't want to risk making my system unstable, I took a look at the package list for the latest CentOS (6.2) and found that the great majority its package versions are sufficiently recent to enable running the JavaFX 2.1 Developer Preview. So, over this past weekend, I made the switch from CentOS 5.5 to CentOS 6.2.

During the CentOS 6.2 installation, I was surprised to be presented with a set of baseline configuration choices (Desktop, Minimal Desktop, Minimal, Basic Server, Database Server, Web Server, Virtual Host, and Software Development Workstation). "Software Development Workstation" sounded pretty good to me, so I selected that option. As the install proceeded, I was pleased to see all kinds of useful packages being loaded onto my system: OpenJDK 1.6, OpenJDK development packages, Python 2.6.6, Boost, MySQL, OpenLDAP, Postgres, NumPy, NetCDF, git, Apache Server, Ant, Eclipse, MatPlotLib, Subversion, LaTeX, Qt, Swig... Those are just a few of the packages I noted as their names flashed rapidly by on the screen. Quite a nicely configured "out-of-the-box" Linux system for a software engineer!

With respect to Java development, the Eclipse version is 3.6.1. Also on the Applications/Programming menu I found the OpenJDK Monitoring and Management Console (JConsole, Version 1.6.0_22-b22), and the OpenJDK Policy Tool.

Running JavaFX 2.1 Developer Preview Build 13 Samples on CentOS 6.2

The JavaFX 2.1 Developer Preview Release Notes for the Linux distribution define Ubuntu Linux 10.4 or higher as the required Linux operating system. The notes also say that JDK 6 update 26 or higher is required. The default JDK version for CentOS 6.2 is 1.6.0_22. I'll address that soon (I'm actually planning to start running JDK 7). But even with the not quite recent enough JDK version, most of the JavaFX 2.1 Developer Preview samples run under the out-of-the-box CentOS 6.2 "Software Development Workstation" configuration. For example, here's a screen shot of the Brick Breaker sample app in action:

So, the initial evidence is that CentOS 6.2 can be added to list of Linux operating systems on which you can develop JavaFX applications using the JavaFX 2.1 Developer Preview. That's excellent!


Poll

Our new Java.net poll asks Will you use JavaFX for development once it's fully ported to Mac and Linux platforms?. Voting will be open until Friday, March 2.


Java.net Weblogs

Since my last blog post, several people have posted new java.net blogs:


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:


Spotlights

Our latest Java.net Spotlight is Richard Bair's A Short Tour Through JavaFX-UI-Common:

We've just recently announced the release of the “javafx-ui-common” project into OpenJFX. The name may be a little underwhelming, but the content is absolutely core to JavaFX. For most developers interested in contributing to JavaFX and in understanding how the system works, javafx-ui-common and javafx-ui-controls will be the two most important projects...

Our previous Spotlight was Janice J. Heiss' Agile ALM: A Conversation with Java Champion and ALM Expert Michael Hüttermann:

This series of interviews spotlights Java Champions, individuals who have received special recognition from Java developers across industry, academia, Java User Groups (JUGs), and the larger community. Michael Hüttermann is a developer and coach on Java/JEE, SCM/ALM, SDLC-Tooling and agile software development. A Java Champion, he is certified as SCJA, SCJP, SCJD, and SCWCD, and he is a member of the JCP...

Before that, we highlighted Julien Ponge's Adding Some Agility to Java EE Application Deployment with GlassFish:

Four noteworthy features in GlassFish add agility to Java EE application deployment. Deploying and managing Java Platform, Enterprise Edition (Java EE) applications seems like a fairly established activity. Applications can be deployed, undeployed, and upgraded through a combination of deployment and undeployment. Applications use various types of resources, such as...

Subscriptions and Archives: You can subscribe to this blog using the java.net Editor's Blog Feed. You can also subscribe to the Java Today RSS feedand the java.net blogs feed. You can find historical archives of what has appeared the front page of Java.net in the java.net home page archive.

-- Kevin Farnham
Twitter: @kevin_farnham

 

Today I attended the Oracle Technology Network's Java Virtual Developer Day, a four-hour online event that takes a pretty deep dive into Java 7 and JavaFX 2.0. The agenda started with a keynote presentation, "The Java Platform: Now and the Future," followed by a general session, "What is Java SE 7 and JDK 7." These were presented by Simon Ritter, Technology Evangelist, Oracle.

Following the keynote and general session, attendees could choose a Technical Sessions track ("Diving into JavaFX 2.0" and "Java SE 7: New and improved APIs") or a Hands-On Lab Track ("Java SE 7 Hands-On Lab" and "JavaFX 2.0 Hands-On Lab"). I chose the Technical Sessions track, in part because I wanted attend via a large screen, which I have available only on my CentOS Linux machine. Attending on Linux meant that I couldn't participate in the JavaFX 2.0 lab (which required Windows). While the Virtual Developer Day Java Pre-Event Checklist does not claim support for Linux, I had no problems attending the mini-conference using CentOS 5.5 and Firefox 3.6.24.

I saw as many as 750 people connected simultaneously, as I occasionally looked at the "Users" meter at the bottom of the virtual room. One time my login timed out between sessions, but I was quickly able to log back in and attend the next session. Aside from that, the system's performance was fine for me.


OTN Virtual Developer Day - Java "room": Presentation and Q&A components

The virtual "room" in which the developer day takes place includes a screen where presentation slides are displayed, with a live text messaging box where attendees can ask questions as the presentation proceeds. There's also an option to view the slides in full-screen mode (in which case the text messaging panel is not shown). The general "feel" is pretty close to what it's like to attend a live conference session. No, you can't ask the actual speaker questions, but the live Q&A team answered plenty of interesting questions as the sessions proceeded.

What impressed me most is how much important information was packed into the technical sessions. There were plenty of code snippets and examples of new Java SE 7 features, and JavaFX 2.0 demos with backing code. Simon Ritter presented the Technical Sessions track, so my entire participation was four hours of viewing his slides and listening to his commentary on the slides. Really, the slides by themselves are a very small representation of the actual content Simon presented. For each slide, the verbal discussion was expansive.

Another thing that impressed me was the historical background that Simon brings into his discussions of new features in Java 7, and to JavaFX 2.0. He doesn't just state what's new, he goes back to how things were in the past, describes the problems that existed, then shows how the new language features solve the problem. The listener is left with a sense of the justification behind the latest Java 7 enhancements, the justifications for what's coming up in Java 8, the reasoning behind the abandonment of the JavaFX 1.3 scripting model and the redesign that led to JavaFX 2.0, etc.

Not only that, Simon frequently goes down into the JVM itself, describing its inner workings and how this relates to the Java language. For example, his discussion of the JVM-related problems entailed by InvokeDynamic (JSR 292) covers the history of invoke methods in the JVM, the problem presented by languages with dynamic typing, and the solution that was implemented in Java 7 (see above and below).

The presentations that make up the Java Virtual Developer Dayreally are superb! If you know Java well, but you don't know that much about the JVM, you'll receive a nice introductory education in how the JVM works from Simon's Java 7 discussions. Or, if in your job you haven't had the opportunity to catch up with the latest developments in Java, the Java Virtual Developer Day is a great opportunity to do some of that catching up.

And if Java is relatively new to you, in addition to learning about the new features of Java 7 and JavaFX 2.0, you'll see in this mini-conference how Java today is advancing based on a vision that is solving problems that existed in previous versions of the platform, and addressing today's emerging needs (for example, the Java 7 Fork/Join Framework, which is highly relevant for developing applications for modern multicore devices, even down to multicore hand-held devices).

I found the OTN's Java Virtual Developer Day to be very well done. I'm glad I chose to attend. The presentations are now available on demand.

The next live session is on February 28, timed for audiences in Europe, Africa, etc.


Java.net Weblogs

Since my last blog post, two new java.net blogs were posted by others:


Poll

Our current Java.net poll asks Under JCP 2.8, EC members lose their voting rights if they miss two consecutive meetings. Your view on this?. Voting will be open until Friday, February 17.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:

kfarnham

This Week: Jfokus 2012 Blog

Posted by kfarnham Feb 12, 2012

Among the conferences I hope to attend some day is Jfokus, held annually in Stockholm, Sweden. In my view, Jfokus exemplifies an emerging trend where Java-centric conferences that originally started out as smaller, regional events ultimately attain international stature. It seems to me that conferences like Jfokus are increasingly taking on a greater role in helping developers network, exchange ideas, and learn more about the latest advances in Java technologies -- unlike in the past when JavaOne was the most important Java event by far.

Jfokus 2012 happens this week, Monday through Wednesday.

This is the sixth Jfokus. The first Jfokus in 2007 attracted more than 450 developers, virtually all from Sweden. The following year, the conference expanded to two days, and became more of an international affair, with 650 developers from Sweden, several other European countries, and even India, being in attendance. The conference continued to grow, moving to a larger venue starting in 2009.

http://www.jfokus.se/images/waterfront340x202.jpg

This year's speakers roster includes many prominent Swedish developers, along with quite a few people from other countries. For example, Google's David Chandler will be presenting on the new Dart language; Markus Eisele, from Germany, will be presenting "Java 7 - State of the Enterprise"; Oracle's Arun Gupta will have several Java EE related presentations; Oracle's Michael Heinrichs will present "JavaFX 2.0 from a developer's perspective"; Fabiane Bizinella Nardon, of RBS in Brazil (and the Java.net Java Tools Community), will talk about "Zero Downtime Continuous Deployment of Java Web Applications"; Oracle's Dalibor Topic will talk about the OpenJDK... That just scratches the surface, really.

Mondayis devoted to tutorials, with a 3.5 hour morning session and a 3.5 hour afternoon session (five different tutorials happening simultaneously). Tuesdayopens with a keynote address, "Enterprise Java in 2012 and Beyond," presented by Juergen Hoeller of SpringSource. The remainder of the day consists of 50-minute sessions, followed by BOFs in the evening. Wednesday's schedule includes additional 50-minute sessions, followed by a closing keynote, "Cool Code," presented by Curbranlan's Kevlin Henney.

You can follow Jfokus 2012 on Twitter (@Jfokus), on Facebook (Jfokus), or at the Jfokus conference site.

Update: Mattias Karlsson (@matkar) contacted me on Twitter with additional information about Jfokus: "Jfokus is a major international conference! 1450 visitors 2012." That, indeed, is a lot of growth in just five years since the first Jfokus in 2007. Mattias also points us to the video below, which gives us a bit of the feeling of what Jfokus 2011 was like:

Now I really wish I could be at Jfokus 2012!


Java.net Weblogs

Since my last blog post, several people have posted new java.net blogs:


Poll

Our current Java.net poll asks Under JCP 2.8, EC members lose their voting rights if they miss two consecutive meetings. Your view on this?. Voting will be open until Friday, February 17.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:


Spotlights

Our latest Java.net Spotlight is Tori Wieldt's Wanted: Java Code Brainteasers:

Each issue of Java Magazine includes a "Fix Me" page that presents a problem that challenges a Java developer's coding skills. The Java Magazine team is seeking Java Code Brainteasers for future issues. Here's a chance for you to contribute to Java Magazine!

Previously, we featured Javalobby's new poll, Have You Adopted Java 7 Yet?:

Java 7 has been available for a while now, and according statistics that Jelastic ran, it's market share is growing, albeit slowly. The article states that Java 7 accounts for 17% of the market while Java 6 still holds 83%. With Java still holding it's own on the latest TIOBEindex, there's no doubt that it's not losing it's appeal to developers and corporations...

Prior to that, we spotlighted Johan Vos' DaliCore on java.net:

After years of development, refactoring, brainstorms, projects, fun, more refactoring,... we open-sourced the DaliCore code. DaliCore creates the core for the social networking applications that we developed with LodgON over the past years. Some code and documentation is now available...

Subscriptions and Archives: You can subscribe to this blog using the java.net Editor's Blog Feed. You can also subscribe to the Java Today RSS feedand the java.net blogs feed. You can find historical archives of what has appeared the front page of Java.net in the java.net home page archive.

-- Kevin Farnham
Twitter: @kevin_farnham

 

In the most recently completed Java.net poll, the Java/JVM developers who chose to participate generally anticipate stable or increased job opportunities in 2012. A total of 373 votes were cast, with the following results:

In 2012, job opportunities for Java/JVM developers will...

  • 19% (72 votes) - Expand rapidly
  • 25% (92 votes) - Increase moderately
  • 23% (86 votes) - Remain stable
  • 9% (33 votes) - Decline
  • 17% (65 votes) - I don't know
  • 7% (25 votes) - Other

So, 2/3 of the voters believe job opportunities will remain stable or increase, while only 9% expect opportunities to decline. That's a level of optimism that I don't think we've seen in a while.

For example, looking back to our March 2010 poll that asked "Is the software engineering job market improving?", less than half of the voters selected one of the positive responses. Of course, the polls asked different questions, so it's a little complex trying to draw conclusions. Still, that poll was posted at a time when almost everyone had witnessed declining opportunities in the recent past. More than a quarter of the voters were still awaiting 'the promised "recovery"' or saw the situation continuing to worsen.

I have seen various articles that suggest a boom (or at least a fairly strong upward tide) is underway for software engineers. For example, there was the Dice.com (US) survey that I blogged about a month ago where United States recruiters indicated that finding "Java/J2EE Developers" is their top priority for 2012.

What's happening in the mobile apps arena is also pretty amazing. On April 15, 2011, the Wall Street Journal had an article titled "App Talent Pool Is Shallow: Companies Scramble for Engineers Who Can Write Software for Smartphones." (I have the clipping, but can't find an online link.)

Then there are these recent interesting articles at Forbes.com:

  • Venkatesh Rao, 5 December 2011 - The Rise of Developeronomics (the author cites software developers as being the one "safe haven" that exists today for investors); and
  • Tomio Geron, 21 December 2011 - Just How Much Are Engineers In Demand? Very Much So (which starts with: "As any technology executive in Silicon Valley could tell you, hiring engineers is one of their toughest tasks these days.")

Here's a demonstrative figure from Tomio's article:
http://blogs-images.forbes.com/tomiogeron/files/2011/12/demandscore_2-01.jpg

This all says to me that if you're good at what you do, today can indeed be a very good time for advancing your career in software engineering. It also suggests that adding new skills that are highly in demand can significantly increase your value in the marketplace.

So, please, keep working, learning, practicing, and advancing, people!

New poll: Lost JCP EC voting rights

Our new Java.net poll asks Under JCP 2.8, EC members lose their voting rights if they miss two consecutive meetings. Your view on this?. Voting will be open until Friday, February 17.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:


Spotlights

Our latest java.net Spotlight is the upcoming Java Virtual Developer Day:

Coming soon (Feb 14 in the Americas, Feb 28 in Europe/Russia/Africa): Java Virtual Developer Day, a half-day virtual mini-conference of technical sessions and hands-on labs, covering Java SE 7, JDK 7, JavaFX 2.0. Register now!

Subscriptions and Archives: You can subscribe to this blog using the java.net Editor's Blog Feed. You can also subscribe to the Java Today RSS feedand the java.net blogs feed. You can find historical archives of what has appeared the front page of java.net in the java.net home page archive.

-- Kevin Farnham
Twitter: @kevin_farnham

Last night I dreamed seemingly all night about NetBeans 7.1, theJavaFX 2.1 Developer Preview, the JDK 6 and JDK 7 installations on my CentOS Linux system, Java threads, the JDK 7 Fork/Join framework, closures... and probably a few more things were in there too. That kind of thing happens to me sometimes after a late night of programming or development-related brainstorming.

Now, if these dreams happen when I have looming deadline, I usually consider it a nightmare -- because I'll often "work" all night "solving" some problem that doesn't exist in my day world. But I'm hoping last night's dreams will ultimately prove to have been at least a little bit productive. There were plenty of curious ideas mixed in there. I'll find out if any of it's useful over the next several days...

Day work: JavaFX 2.1 Developer Preview on Linux

It's daytime now, so I'll get down to some practical work. First, there's some good news for developers who want to try out JavaFX 2.1 Developer Preview on Linux: Linux Release Notes and installation instructions are now available (that wasn't the case when I wrote my Getting Started (Very Preliminarily)... blog post a couple weeks ago). Also, the 2.1 Developer Preview is has advanced to build b11 (I originally downloaded build b9).

The instructions for JavaFX 2.1 on Linux identify the following system requirements:

  • Ubuntu Linux 10.4 or higher (32 or 64 bit)
  • JDK 6 update 26 or higher
  • gtk2 2.18+
  • libavcodec (for media)

I'm running CentOS 5.5, not Ubuntu; my current JDK 6 is prior to update 26; and rpm -q gtk2 tells me that I have gtk2 Version 2.10.4-20.el5. Not the perfect starting point... But, my guess is that likely I'll be able to get a proper configuration in place.

The latest GTK2 that's available via yum for CentOS 5.5 is still in the Version 2.10 sequence. So, I downloaded the last stable GTK2 (Version 2.24.9), and tried installing it. The result of./configure was a bunch of missing dependencies (too old a version of GLib, and missing atk, pango, cairo, and gdk-pixbuf-2.0). Using yum to see what prepackaged versions of these are available for my CentOS system, I found that in all cases the available packages predate the required versions.

Stepping back to GTK+ 2.18 would help some, but still the dependencies could not be met by simply using the yumpackage manager.

So, it's a dilemma. I'd like to try out the JavaFX 2.1 Developer Preview on my CentOS system, but there's a pretty big gulf between the CentOS 5.5 packages and what's required for JavaFX 2.1. Attempting big jumps in package versions can break a stable Linux system, in my experience. And the idea of upgrading to a newer operating system isn't all that appealing (that means downtime, and I do have development deadlines to meet). In addition, there are other things I'd like to be working on as well (such as experimenting with the performance differences between various strategies for efficiently utilizing multicore computers -- all that non-JavaFX stuff I was dreaming about last night).

I'll have to think about this for a while... Or, perhaps another night of Java-centric dreaming will provide a solution!


Java.net Weblogs

Since my last blog post, several people have posted new java.net blogs:


Poll

Our current java.net poll asks Under JCP 2.8, EC members lose their voting rights if they miss two consecutive meetings. Your view on this?. Voting will be open until Friday, February 17.


Articles

Our latest Java.net article is Michael Bar-Sinai's PanelMatic 101.


Java News

Here are the stories we've recently featured in our Java news section:

Filter Blog

By date: