The blog title says it all: A casual online search for "Swing OSGi" leads a long-time Eclipse user to the NetBeans Platform and inspires a "love post" about his new framework.

Chart FX for Java Community Edition is a free, full development version of Chart FX for Java, a 100% Java component that uses your J2EE application server and JSP and JSF technology to produce charts in a variety of formats: PNG, JPEG, SVG and FLASH. Integrated into Netbean, you can configure the look at feel of your charts in a familiar design-time environment, where changes are automatically applied to the chart so you can see exactly what the chart is going to look like.

Here at Google, we have engineers using Eclipse every day to build our external and internal products, as well as engineers building and releasing Eclipse tools. Earlier this year, we announced Eclipse Labs, which is “a single place where anyone can start and maintain their open source projects based on the Eclipse platform with just a few clicks.” Since we use Eclipse so much here at Google, hosting Eclipse Day at the Googleplex is one way of giving back to the community and providing an environment for Eclipse contributors and users to network and share ideas. We hosted Eclipse Day before in 2009 and 2008, and last week we hosted our third year where we tried out some new ideas: a brief lunchtime unconference and post-conference Ignite talks.

Ian Skerrett of the Eclipse Foundation wrote on his blog,

Wrap-up of Eclipse Day at the Googleplex
...Over 150 people attended the day long event that included 12 sessions related to Eclipse and Google technology. The presentations are now available online. There was lots of great information presented, like upcoming improvements to the Android SDK (based on Eclipse), Git support in Eclipse, a review of the Instantiations tools that Google just purchased and an introduction to the new Tools for Mobile Web project.Most important, all of us at Google would like to thank Ian Skerrett and everyone at the Eclipse Foundation for assembling three of these great events. We were happy to welcome the Eclipse community to our campus, and we are happy to continue to support Eclipse. Don’t forget that we’re always looking to make this conference better, so give us your ideas! Tell us what you would like to see at future events in the comments, or if you were able to attend, tell us what you thought about this year’s program.

By Robert Konigsberg, Software Build Tools Team

As part of the GWT team's ongoing effort to address the needs of the Maven community, the Google Plugin for Eclipse (GPE) team is working to improve interoperability with Maven in future releases. Plugin version 1.3.3 makes it possible to use Maven in a GPE project with a little tweaking, and future versions aim to improve this experience. There is already good support from the open source community for using Maven with GWT and/or App Engine projects; however, it has been difficult to enable both Maven and GPE for the same project. This article explains how to do that. It assumes you already have some Maven knowledge.

Working with GWT and GAE in Maven

First, here are a few tips on using Maven with GWT and GAE.

The open source community has written Maven plugins for both GWT and App Engine which wrap the native development tools for these platforms.

• maven-gae-plugin provides Maven goals to run, debug, deploy, and rollback a GAE application as well as a handful of utility goals. In addition, the plugin automatically retrieves all GAE runtime dependencies from the plugin's SVN repo (Google is working on publishing these dependencies to the central Maven repo, as well).
• gwt-maven-plugin from codehaus.org provides Maven goals to compile GWT applications, and run or debug in hosted mode using the dev mode console.

Both projects provide Maven archetypes to generate a pom.xml and project skeleton. In addition, you can find a GWT+GAE+Roo sample POM within the Expenses sample project in GWT trunk. It contains everything you need to build a GWT 2.1 app (as of 2.1.0 M3) with Spring Roo and deploy to App Engine. If you're not using Spring, you can remove the Spring dependencies.

The documentation for each plugin lists all of the Maven goals available, but we'll briefly look at the most common:

• mvn gae:run starts the App Engine development server.
• mvn gae:deploy deploys your application to App Engine.
• mvn gwt:run runs your GWT app in hosted mode using the standalone dev mode console. If you're using maven-gae-plugin, it will also invoke gae:run.
• mvn gwt:debug runs your GWT app in hosted mode and additionally enables the debugger port hook so you can debug in Eclipse as a Remote Java Application on the standard debugger port (8000). It is generally easier, however, to launch the debugger within Eclipse using GPE. We'll look at how to enable that shortly.
• mvn gwt:compile compiles your GWT app for production.
• mvn eclipse:eclipse creates an Eclipse project that you can import into Eclipse. The sample POM referenced above contains configuration for the maven-eclipse-plugin which adds the gwt and gae project natures used by Google Plugin for Eclipse. After you run Maven eclipse:eclipse, you can import your project into Eclipse using File | Import | Project | Existing Project.

Using the goals provided by the GWT and GAE Maven plugins, it is not necessary to use the Google Plugin for Eclipse at all, as you can use Maven instead to run / debug / deploy. However, GPE provides tighter integration with Eclipse Run / Debug launch, code completion, warnings and errors, etc., so it's useful to enable it also.

Enabling Google Plugin for Eclipse to work with an existing Maven project

If you have an existing Maven project in Eclipse and want to enable GPE functionality, follow these steps:

1. In Eclipse, open your project's properties (Alt+Enter or right-click, Properties)
2. Under Google | App Engine, select the version of the App Engine SDK you're using. GPE is not yet able to use the version defined in your Maven POM, so you may need to download your SDK version using the Eclipse software updater (see http://code.google.com/eclipse/docs/download.html)
3. Under Google | Web Toolkit, likewise select the version of the GWT SDK you're using. As with the App Engine SDK, install it via the Eclipse plugin update site if needed.
4. Under Google | Web Application, check the "This project has a WAR directory" box and point it to your project's src/main/webapp directory. This is the standard WAR source folder for Maven Web projects. Be sure that the "Launch and deploy from this directory" box is NOT checked.
5. Under Java Build Path, select the Order and Export tab and move all Maven dependencies to the BOTTOM. Otherwise, GPE will see the App Engine and GWT SDKs from the Maven repo on the build path and complain that they are not valid. This is because GPE expects a specific SDK structure used to enable other tooling.
6. Also under Java Build Path, select the Source tab and ensure that the Build output directory is enabled and pointing to target/your-project-name/WEB-INF/classes. If you created the project with mvn eclipse:eclipse, this should be done for you automatically.
7. Finally, and this is very important, the first time you launch your project using Run As | Web Application (or Debug), you will be prompted to select the war directly. This is NOT src/main/webapp, but rather the WAR output folder, which is target/your-project-name. If you make a mistake, simply go to Run | Run Configurations... and remove any old configurations for the project. GPE will then ask you again next time you try to Run As | Web Application.

Mavenizing an existing GPE project

To use Maven with an existing GPE project, follow these steps:

1. Create a pom.xml using one of the project archetypes or sample POM discussed above. Make sure it contains configuration for gwt-maven-plugin, maven-eclipse-plugin, and maven-gae-plugin (if you're using App Engine).
2. Maven projects use a different layout than the default GPE project, so create folders for your Java code (src/main/java) and static resources (src/main/webapp).
3. Move all source files under the GPE-created war directory into src/main/webapp. These include any config files (web.xml, etc.) under war/WEB-INF and static resources such as images and CSS. After you've moved the source files, you can delete the war directory, as Maven will create output folders for your GWT modules under the target directory, not the war directory.
4. Add Maven dependencies in your pom.xml for each jar that had been in WEB-INF/lib.
5. Run mvn clean gae:unpack war:war in the pom.xml directory. This will unzip the App Engine SDK in your local maven repo and copy static resources from src/main/webapp into target/project-name, where GPE expects to find them when configured as above.
6. Run mvn eclipse:clean eclipse:eclipse in the project directory to recreate your Eclipse project file, then Refresh it in Eclipse (select project and press F5 or right-click, Refresh).
7. Follow the steps in the previous section to enable GPE support with Maven.

Let me conclude with a hearty thank you to everyone who has contributed to the development of maven-gae-plugin and gwt-maven-plugin. Your contributions are an indispensable part of Google's ability to better meet the needs of the Maven community.

I remember when I first used PDFCreator, I was doing some freelance web development work. As it happens sometimes, I had a client that was not very tech savvy. I was fortunate that this client could even check email (and even that was stretching it a bit). The PDF format was the one thing he could read and understand, and figure out how to open. In many cases, PDF seems to be the lowest common denominator; it’s easy, cross-platform, and it ensures that anyone viewing the document is looking at the same thing. PDFCreator allowed me to put *anything* into a nice PDF: screenshots, documents, spreadsheets, reports, whatever. It was a life saver then, and it is now.

While some programs offer the ability to convert into a PDF format, or export into PDF, there are many that do not have this capability. With this software, anything that can be printed can be turned into a PDF. In essence, you install the software, and it installs as a PDF printer, so to create a PDF from anything, you just need to print. Its only limitation is that it is specific to Windows OS.

PDFCreator does more than just create PDFs, in fact. The software now includes many other features such as the ability to:

• Encrypt and digitally sign PDFs and protect them from being opened or modified
• Send generated files via email
• Create more than just PDFs: PNG, JPG, TIFF, BMP, PCX, PS, EPS
• AutoSave files to folders and filenames based on tags like Username, Computername, Date, Time etc.
• Merge multiple files into one PDF

The project began in 2002 when Philip Chinery, one of the core devs, needed a useful tool to make PDFs and nothing out there suited his needs. He wrote the software, and in 2003, Frank Heindörfer joined the team. “Since that time,” Philip tells me, “we have been the first free PDF software with a full installer, the first one with PDF security, PDF/A and PDF/X support, digital signatures and a COM automation interface to control the software.”

Over the years, the team has had to work through many technical obstacles, “like finding all relevant parts to do a proper printer driver installation or getting the permissions right with the new Windows Vista permission structure,” says Philip. “The latter has caused us to take nearly one year to fully support Vista after it has been released. We finally had to tweak the permissions of the SYSTEM account which other printer drivers as the Xerox drivers do as well, but we are not fully happy with that so far.”

Philip and Frank have learned a lot through their work with PDFCreator. They have a great time working on something they believe in, and they enjoy working on the team together, which is very important for any project, but especially crucial in open source.

Wise words of advice for others working in or just starting out in open source: “Take a point where you want to be better than everyone else and try to achieve that. It is better to have a good program with few features than a bad program with many features. And, use a programming language that will be available for some time.”

The team has big plans for PDFCreator, including rewriting the entire app in C# (it is currently written in VB6.) “We are currently having a kind of prototype application and are working on side aspects as a good translation system and Setting Storage. It is quite likely that they will become available separately to help other developers.”

They have also decided to start their own company, pdfforge GbR, to continue to improve PDFCreator, while offering custom development.

PDFCreator is one of the top 10 projects on SourceForge.net of all time, and there is a reason for that. It’s a great tool, it’s super simple to use and install, and the team works very well together. If you are using Windows, this should definitely be in your toolbox.

For more information on PDFCreator: http://pdfforge.org
To download PDFCreator: https://sourceforge.net/projects/pdfcreator
If you would like to donate to this project: http://www.pdfforge.org/donations

The Google Plugin for Eclipse is the fastest way to start developing Google Web Toolkit and App Engine applications.

MyEclipse for Spring 8.6: Generate Google Web Toolkit, Adobe Flex, iPhone Apps in Minutes

Developing Spring applications? Do it right and do it fast.

Java native implementation of the ACT-R (Anderson, 2007) cognitive architecture and support code. The IDE integration is available as a separate "product"

Eclipse IDE integration for jACT-R, Java implementation of ACT-R (Anderson, 2007) cognitive architecture.

<strong >MDA compliant and
built on
Eclipse, BLU AGE</strong><span >
®</span><strong >
generates UML models
from legacy applications'
source
code and instantly transforms them into Java EE and .Net applications.</strong>
<strong><br>
<br>
BLU
AGE</strong>
®<strong>
2009 Edition Reverse / Modernization </strong>module
allows automatic UML models (PIM) extraction from Legacy applications
source
code and data, in order to afford their re-engineering through BLU AGE
‘Build’ and

<strong >MDA compliant and
built on
Eclipse, BLU AGE</strong><span >
®</span><strong >
generates UML models
from legacy applications'
source
code and instantly transforms them into Java EE and .Net applications.</strong>
<p><span >BLU AGE®
2009 Edition Deliver</span> module
is the first Integrated Generation Environment to fully generate your
applications into the majority of existing (and forthcoming) frameworks
and
web-application servers thanks to a large range of customizable
transformation

<p><span ><font color="#5263a3"><strong>MDA compliant and built on Eclipse, BLU AGE is groundbreaking software workbench that instantly and automatically transforms your Models into Agile Java EE and .NET business applications.</strong></font></span> </p>
</p>
<p>
<strong>BLU AGE 2009 Edition Build </strong>module is the first Integrated Modeling Environment to build and debug your models and generate -in real time- a fully bug-free Java EE application (for PIM/BPEL validation).
</p>
<p>

The end of the year is right around the corner (already!) but we’re not quite done showcasing projects that have been with us for 10 years or more. September’s Project of the Month is GPL Ghostscript, a complete set of page description language interpreters including PDF, PostScript, PCL5, PCLXL, and XPS.

Even if you’ve never used GPL Ghostscript, you’ve probably heard its name since it’s been around since 1989. Project developers say, “anyone who needs to view, print, archive, or convert PDF, PostScript, PCL, or XPS on any platform is a potential GPL Ghostscript user.” If that describes you, then be sure to check out the app. If you already know it and love it, why not contribute? “We are willing to pay for bug fixes through our bug bounty system,” says GPL Ghostscript’s Project Lead.

Have a look at what the development team has learned over the years, then take a trip down memory lane and see what other projects we’ve covered this year.

New release of Continuent Tungsten provides an ideal open source database platform for cloud-based applications

The new Uize.Array.Order module provides functionality for changing the order of elements in an array, with support for reversing, jumbling, inside to out, etc. Unlike sorting an array based upon the values of its elements, the methods of the Uize.Array.Order module allow you to reorder the elements according to different patterns - without respect to the element values. For example, the Uize.Array.Order.reverse method reverses the order of the elements in an array. The Uize.Array.Order.jumble method jumbles (randomly shuffles) the elements in an array. The Uize.Array.Order.insideOut method reorders the elements from inside to out by starting with the inner elements and moving outwards in both directions to reach the start and the end of the array, while the Uize.Array.Order.outsideIn method reorders the elements from outside to in by starting with the outer elements and moving inwards in both directions to reach the inner elements.

The new Uize.Array module defines a namespace for various modules that provide array specific functionality or utilities. To kick things off, the new Uize.Array.Order module under the Uize.Array namespace provides functionality for changing the order of elements in an array, with support for reversing, jumbling, specialized sorting, and more.

The Uize.Widget.Collection.Dynamic module has been improved with the addition of support for the touch interface of Apple's iPad. With the updated version of this module, it is now possible to reorganize the items in a collection using the Apple iPad's touch interface. This is demonstrated in the Dynamic Collection example, which has been updated with selection checkboxes for the collection item widgets to allow non-contiguous selection of multiple items.