Felipe Gaucho's Blog

Felipe Vieira Silva, a brazilian known as Felipe Gaucho, started his computing career in the 90's (C/C++, VB) and first tried Java in 1998 during the development of a robot arm simulator as a student of scientific initiation program at UNISINOS. One year later he concluded his course and becomes an enthusiastic about Java, seeking the tricks about the new technology and joining himself to projects that involved the concept of portable software - the fever of that time. On December 2002 he concluded his Masters Degree in the Federal University of Cear?, publishing his dissertation about "Planning & Scheduling" and started teaching in faculties of computing. The challenges of the new career revealed an exciting area: Learning & Education. Observing the behaviour of students and teachers, he started dreaming with several computational solutions for questions like "how to enhance the teaching?", "how to facilitate learning by the students?" and other common issues shared by the academic community. Nowadays, Felipe Ga?cho is seeking a PhD opportunity in order to improve his knowledge and enhance his capacity of contribution for the society. The establishment of the Schoolbus Project in the JELC community was an important step in that direction, and he believes he can become a good researcher in the next few years.

A Generic CRUD Facade for your @Entity Beans

CRUD (create-read-update-delete) is a repetitive code in Java EE projects but it can be isolated in a unique class through the usage of JPA annotations and Generics - a class I call CRUDEntityFacade. This is not a new pattern and the goal of this blog entry is just to prepare you to read my next entries about JAXB and JPA together. I am doing really nice things with Jersey and Glassfish, and before to expose complicated inventions I decided to register the basics of the persistence layer (also very nice for my own future reference).

Complete sample projects

The code I am publishing here is just to avoid you to checkout a full project and to dig to inspect my CRUD strategy. But if you want to see this technique in action, please be my guest to checkout one of my open-source projects. The projects are built by Maven and were created in Eclipse - but you should be able to run it on your preferred IDE without any problems. Both projects requires minimum Java 6.

• Example #1: the Footprint project, what includes a RESTful service coded with the Jersey framework. Subversion checkout:

  svn checkout https://footprint.dev.java.net/svn/footprint/trunk footprint --username username

• Example #2: the Cejug-Classifieds project, a WSDL first web-service coded with the JAX-WS framework. Subversion checkout:

  svn checkout https://cejug-classifieds.dev.java.net/svn/cejug-classifieds/trunk cejug-classifieds --username username

username is your java.net login, or you can use guest without password to get a read only copy.

The generic CRUD implemented with generics and JPA annotations

1. Defining the persistence interface containing the persistence operations we want to share between all entities. Note that I replicated the runtime exceptions because it is an interface and we expect interfaces to be the most document and self-understandable artifacts in our project.

   public interface FootprintEntityFacade {
   	T create(T entity) throws EntityExistsException, IllegalStateException,
   			IllegalArgumentException, TransactionRequiredException;
   	T read(Serializable primaryKey) throws IllegalStateException,
   			IllegalArgumentException;
   	T update(T entity) throws IllegalStateException,
   			IllegalArgumentException, TransactionRequiredException;
   	void deleteO(T entity) throws IllegalStateException,
   			IllegalArgumentException, TransactionRequiredException,
   			PersistenceException;
   }

2. To define a superclass of all entities. This is an important step, since we want to use generics we must have a unique type to pass in our interface implementation. The mapped superclass is also useful to share the ID attribute.

   @MappedSuperclass
   public abstract class AbstractFootprintEntity implements Serializable {
   	@Transient public static final long serialVersionUID = 196919661993L;
   	@Id
   	@GeneratedValue(strategy = GenerationType.AUTO)
   	private long id;
   	// getters & setters
   }
   

3. Then we need some entities. I will use an example of the Footprint entity that represents Events (JUG meetings, courses or conferences).

   @Entity
   public class FpEvent extends AbstractFootprintEntity {
   	@Transient private static final long serialVersionUID = 196919661993L;
   	@Column(nullable = false)
   	private String name;
   	@Column(nullable = true)
   	private String website;
   	@Version
   	private long updatedTime;
   	
   	// getters & setters
   }
   	

4. Now an important step, the realization of our generic CRUD interface to our Event Entity. In theory this empty interface is not necessary, but my experiments proved that this is the best way to go. It opens a chance for the customization of the persistence interface and - the main reason - it avoids conflicts between different entity instances using a same interface. You will have 1 empty interface for each Entity in your project, an oddity I couldn't rid off - if you know how to avoid it, please tell me.

   @Local
   public interface EventFacadeLocal extends FootprintEntityFacade<FpEvent> {
   }
   	

5. Now we just need to implement the CRUD. A special note about the empty constructor, that uses reflection to get the class of the generic type - this is the hidden trick that makes the magic possible.

   @Stateless
   public class CRUDEntityFacade<T extends AbstractFootprintEntity> implements FootprintEntityFacade<T> {
   	private transient final Class entityClass;
   	@SuppressWarnings("unchecked")
   	public CRUDEntityFacade() {
   		entityClass = (Class) ((java.lang.reflect.ParameterizedType) this
   				.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
   	}
   	@PersistenceContext(name = "footprint")
   	protected transient EntityManager manager;
   	public T create(final T entity) throws EntityExistsException,
   			IllegalStateException, IllegalArgumentException,
   			TransactionRequiredException {
   		manager.persist(entity);
   		manager.flush();
   		return entity;
   	}
   	public T read(final Serializable primaryKey) throws IllegalStateException,
   			IllegalArgumentException {
   		return manager.find(entityClass, primaryKey);
   	}
   	public T update(final T entity) throws IllegalStateException,
   			IllegalArgumentException, TransactionRequiredException {
   		manager.merge(entity);
   		manager.flush();
   		return entity;
   	}
   	public void delete(final T entity) throws IllegalStateException,
   			IllegalArgumentException, TransactionRequiredException,
   			PersistenceException {
   		manager.remove(entity);
   		manager.flush();
   	}
   }
   	

6. It is done, now we can persist any entity of the type AbstractFootprintEntity (remember to create the empty sub-interface for each new entity you want to persist). Below you find an example of the CRUD usage in a Jersey resource:

   @Path("/event")
   public class EventResource {
   	@EJB
   	private EventFacadeLocal eventFacade;
   	@Produces( { MediaType.APPLICATION_XML })
   	@Consumes(MediaType.APPLICATION_XML)
   	@POST
   	@Path("/test2")
   	public FpEvent postJAXBElement(FpEvent e) {
   		return eventFacade.create(e);
   	}
   }

In my next entries I will show you how to use dual annotation (JAXB + JPA) in order to minimize the impedance mismatch between the persistence layer and the serialization of element used in the services endpoints - REST or SOAP.

JavaONE 2009: here we go...

Hard financial times are also times for investments in our personal education in order to mitigate whatever situation the future bring to us. In this FUD scenario, nothing better than joinning the most influent Java conference in the world: Java ONE 2009.

No much to explain about the well known Java One, except this year I expect a lot from the java EE 6, fancy JavaFX demos and a lot of OSGi and RESTful (Jersey) services. From the pavilion I expect 101% of networking, amazing new gadgets and a few nice gifts as hunt trophy :)

I will take with me the Footprint, the Cejug-Classifieds and some other ideas to share over there... and, as usual, an open mind to listen your ideas and to discuss Java.

See you at California.

Google App Engine to support Java applications

The world of computing is recognizing once more the power of the Java platform as the de facto standard in producing quality software for diverse devices - including web browsers accessing services available in the cloud computing. After a growing number of articles discussing the problems of the so called lightweight technologies, it is time for Google to endorse the strengths of Java - specially the number and the quality of the java engineers. The new offer of Google is a clear statement that something was missing in the app engine and - mainly - that's great news for the Java community.

I just registered my account here, and I can't tell much about the new possibilities of Java App Engine, but I am quite optimistic about it and I recommend you to give it a try - let's see.

Kudos to Chris Adamson

Few years ago, I was teaching Java in universities in Brazil, spending all my days and nights studying and thinking on how to become a better teacher and how to become a better Java professional. I was not much than an enthusiast Java developer full of dreams on how to transform the world through the Java technology.... a lot to say, a lot to discuss and to learn and to teach..

QTI 2.1 draft specification has been removed from the IMS website

In the last few days the QTI 2.1 draft specification has been removed from the IMS website, citing a lack of participation:

The IMS QTIv2.1 draft specification has been removed from the IMS website. Adequate feedback on the specification has not been received, and therefore, the specification has been put back into the IMS project group process for further work.

The education community pushed a strong reaction in the IMS-QTI mailing list and I really hope the spec leaders will rethink their decision. Otherwise, excellent education resources - like OLAT for example - will miss a standard and eventually we will observe the chaos of ten years ago (when every company invented their own specification). IMO: not nice :(

Update: a forum was created to discuss this issue.

Footprint Project adopts Maven 2

What is Fotprint Project?

Footprint is a publisher and distributor of certificates of participation in conferences - signed PDF documents that prove you attended a conference or a course. Usually the companies have some formal process to manage education budget and universities also require some formal documentation in order to accept a participation in an event as part of their students' curriculum. The Footprint Project was created to respond the common question: How can I distribute reliable participation certificates to my conference attendees?

From the technical point of view Footprint is a wrapper for iText, facilitating the configuration of the basic features demanded by conference managers: to fill out PDF diplomas, to sign them with a digital certificate and to send them by email. You can perform those steps using the standard distributions of iText, JavaMail api and some encryption library, but in order to do that you will need to hack a bit around the Java code - and conference organizers are not expected to be Java developers.

Despite the simplicity of the Footprint features, the library contains all you need to fill PDF forms, sign and distribute them by an SMTP server. It also supports JDBC connection, what give you a chance to connect the certificates generator to any Java compatible database - and it comes with a pre-bundled CSV driver, what allows you to use CSV files instead of database. So, if your project uses Maven and requires PDF manipulation, there is a chance that Footprint library reduces a lot your efforts. * If you are not interested in Java code, and you only want to generate certificates for your JUG meeting or conference, you can visit the Footprint home-page and download the latest stable release - it is ready to go.

Footprint Project available in the java.net Maven 2 repository

Footprint is available in the java.net Maven 2 repository. In order to use footprint in your project, you have two chances: to use the full bundled Footprint code with its dependencies or to use te Footprint core and declare the dependencies separately. The former option gives you simplicity and the later offers you a chance to use different versions of the footprint dependencies, like Bouncy Castle encryption library or JavaMail API. So, let's configure the pom.xml

Using the full-bundled Footprint library

Just include in your pom.xml the following elements:

	<repositories>
		<repository>
			<id>maven2-repository.dev.java.net</id>
			<name>Java.net Repository for Maven</name>
			<url>https://download.java.net/maven/2/
			</url>
		</repository>
	</repositories>
	<dependencies>
		<dependency>
			<groupId>net.java.dev.footprint</groupId>
			<artifactId>footprint-core</artifactId>
			<version>1.0-SNAPSHOT</version>
			<classifier>jar-with-dependencies</classifier>
		</dependency>
	</dependencies>

Using only the footprint-core code

The core code of Footprint requires some dependencies declaration:

	<repositories>
		<repository>
			<id>maven2-repository.dev.java.net</id>
			<name>Java.net Repository for Maven</name>
			<url>https://download.java.net/maven/2/
			</url>
		</repository>
		<repository>
			<id>maven-repository.dev.java.net</id>
			<name>Java.net Maven 1 Repository (legacy)</name>
			<url>https://download.java.net/maven/1
			</url>
			<layout>legacy</layout>
		</repository>
	</repositories>
	<dependencies>
		<dependency>
			<groupId>net.java.dev.footprint</groupId>
			<artifactId>footprint-core</artifactId>
			<version>1.0-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>javax.mail</groupId>
			<artifactId>mail</artifactId>
			<version>1.4</version>
		</dependency>
		<dependency>
			<groupId>com.lowagie</groupId>
			<artifactId>itext</artifactId>
			<version>2.0.7</version>
		</dependency>
		<dependency>
			<groupId>csvjdbc</groupId>
			<artifactId>csvjdbc.jar</artifactId>
			<version>LATEST</version>
			<scope>system</scope>
			<systemPath>${project.build.directory}/../lib/csvjdbc.jar
			</systemPath>
		</dependency>
	</dependencies>

Special attention to the csvjdbc.jar dependency - the CSVJDBC Project does not uses Maven, so you need to download the library manually and copy somewhere in your file system. This is the kind of boring step Footprint tries to hide from its users.

Footprint code requires Java 6

An important detail is about the Java version required by Footprint library: at least Java 1.6. In order to guarantee that, please include in your pom (or preferably in the parent pom) the following fragment:

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
			...
		</plugins>
		...
	</build>

Checkout the Footprint code

Footprint is distributed under LGPL license, and if you are interested in checkout the project code, just follow these steps:

1. svn checkout https://footprint.dev.java.net/svn/footprint/trunk footprint --username your.java.net.login
   * you can also use the guest as username - to checkout a read-only copy of the code.
2. cd footprint
3. mvn clean install eclipse:eclipse

That's it, just open the project in your preferred IDE and have fun. If you find any problem or have a feature suggestion, be our guest to submit an issue in the Footprint Issue Tracker page. And if you want to follow the project continuous integration, please visit our Hudson.

Eclipse Community Awards Winners Announced: NeTS is finalist

I usually don't publish any company related news here but this one is special: the NeTS project was announced finalist in the Best Commercial RCP Application category of the Eclipse Community Awards 2009. The great winner of this category was a project called Chord Scale Generator and the other finalist was the ECR - Enregistrement Centralisé en Réseau.

The power of community recognition

To make good contracts and sustain a profitable business depends on business expertise and quality of the the management boards, but to code products that also receives the community recognition is something else - a plus in terms of software quality engineering and a prize for any company that reaches this level of competence - including Netcetera AG. I am not surprised because the Swiss profile is always focused on quality and also because I know the processes and the developers that made NeTS possible, but it is a nice moment to say congratulations NeTS team!

What is NeTS?

NeTS is an acronym for Network-wide Track Management System, a rich client application that allows the Swiss Federal Railways (SBB - Schweizerische Bundesbahnen) to organize its trains timetable. To have a better dimension on the challenge of this project, I copied some quotes from the SBB web site: Every year, SBB transports about 306 million passengers and 54 million net tonnes of freight The Swiss Federal Railway (SBB) manages to operate 96.2% of all trains with less than 5 minutes of delay. The demand is increasing - 6% last year in passenger traffic alone. Currently planned hardware expansion, with new routes and double capacity trains, is not likely to be ready until 2014. This situation motivated the desire to better exploit existing infrastructure using more ambitious software, hence the Network-wide Track Management System (NeTS).

The project has a lot of technical details, but the important message to remember from this blog is: if you are traveling by train in Switzerland, the timetable of your train was planned with NeTS :)

Deploying artifacts to the java.net repository using Maven 2 on Ubuntu Linux

One of the most useful features of the java.net portal is its Maven 2 repository, where project owners can publish their project artifacts using standard Maven features. Following the instructions of the maven2-repository project, you should:

1. Request a "Maven Publisher" role
2. Setup your project to deploy into the java.net maven2 repository. You should include the configuration in your parent pom (if you have a multi-module project). Here you can find my latest version of pom.xml, which includes the configuration like the one below:

     <repositories>
       <repository>
         <id>maven2-repository.dev.java.net</id>
         <name>Java.net Repository for Maven</name>
         <url>https://download.java.net/maven/2/</url>
       </repository>
     </repositories>
     <build>
       <extensions>
         <extension>
           <groupId>org.jvnet.wagon-svn</groupId>
           <artifactId>wagon-svn</artifactId>
           <-- suppress the version to get the latest one -->
         </extension>
       </extensions>
     </build>
     <distributionManagement>
       <repository>
         <uniqueVersion>false</uniqueVersion>
         <id>java.net-maven2-repository</id>
         <url>java-net:/maven2-repository/trunk/repository/</url>
       </repository>
     </distributionManagement>
   	

3. Create a file with your authentication credentials:

   vim ~/.java.net
   userName=yourJavaNetLogin
   password=yourPassword
   save the file and apply permission 600 to restrict the access to your personal information:
   chmod 600 ~/.java.net

4. run mvn deploy in your project root folder. Here I have problems with my Ubuntu installation, because the default maven installed by the Synaptic Package Manager does not work with the java.net repository protocol java-net. I explain below how to workaround on that.

Cannot find wagon which supports the requested protocol: java-net

After following the java.net instructions, I got a strange error in the terminal:

~/svn/footprint$ mvn deploy
Deploying artifacts to https://download.java.net/maven/2/
Deploying the main artifact pom.xml
[INFO ] Retrieving previous build number from 
ERROR: Error deploying artifact: Failed to transfer file:
https://download.java.net/maven/2//net/java/dev/footprint/footprint/1.0-SNAPSHOT/footprint-1.0-SNAPSHOT.pom
Return code is: 401
[INFO] Error retrieving previous build number for artifact 'net.java.dev.footprint:footprint:pom':
 repository metadata for: 'snapshot net.java.dev.footprint:footprint:1.0-SNAPSHOT' could not be 
 retrieved from repository: java.net-maven2-repository due to an error:
 Unsupported Protocol: 'java-net': Cannot find wagon which supports the requested protocol: java-net

I double checked the ~/.java.net file and other permissions around - like the settings.xml in the mvn folder - but the error was in a tricky detail:

The maven installed by the synaptic package manager of Ubuntu is not the latest apache maven distribution. You should remove the Ubuntu default maven package and manually install the Apache Maven for Linux.

This detail is particularly difficult to figure out due to the fact that most of Java developers do not use Linux - so many of the responses in the mailing lists are something like never heard about it... did you follow the instructions properly? The first sign of something related to the OS configuration came from my Eclipse, because when I tried to run the same maven commands through the IDE, the maven started downloading again some libraries - on that moment I realized it was using a different repository. After that, a tip of Julio Viegas helped me to replace the default Ubuntu maven package by the latest Apache distribution - problem fixed!

You can find the instructions to install the software here:

• How to download and install Apache Maven 2 on Linux
• How to install Java 6u12 on Ubuntu

If everything works, you should see something like this in the terminal:

~/svn/footprint$ mvn --version
Maven version: 2.1.0-M1
Java version: 1.6.0_12
Default locale: en_US, platform encoding: UTF-8
OS name: "linux" version: "2.6.27-11-generic" arch: "i386" family: "unix"

Special hint for Hudson installation

If your system hosts a Hudson application, be sure to update the installation folders of Maven and Java in the Hudson before starting your next build sessions - otherwise Hudson will get lost. Just login in Hudson, go to https://localhost:8080/hudson/configure and update the path of the applications.

Hudson SVNCancelException: No credential to try. Authentication failed

As soon Fabrizio published his blog about the quality assurance of BlueMarine (blueCAT), I invited him to host his continuous integration in my personal Hudson lab. Everything nice and easy except for a strange error during the first attempt:

started
ERROR: svn: No credential to try. Authentication failed
org.tmatesoft.svn.core.SVNCancelException: svn: No credential to try. Authentication failed
	at org.tmatesoft.svn.core.internal.wc.SVNErrorManager.cancel(SVNErrorManager.java:37)
	at org.tmatesoft.svn.core.internal.wc.SVNErrorManager.cancel(SVNErrorManager.java:32)
	at org.tmatesoft.svn.core.internal.wc.DefaultSVNAuthenticationManager.getFirstAuthentication(DefaultSVNAuthenticationManager.java:167)
	at hudson.scm.FilterSVNAuthenticationManager.getFirstAuthentication(FilterSVNAuthenticationManager.java:38)
	at org.tmatesoft.svn.core.internal.io.dav.http.HTTPConnection.request(HTTPConnection.java:518)
	at org.tmatesoft.svn.core.internal.io.dav.http.HTTPConnection.request(HTTPConnection.java:257)
	at org.tmatesoft.svn.core.internal.io.dav.http.HTTPConnection.request(HTTPConnection.java:245)
	at org.tmatesoft.svn.core.internal.io.dav.DAVConnection.exchangeCapabilities(DAVConnection.java:454)
	at org.tmatesoft.svn.core.internal.io.dav.DAVConnection.open(DAVConnection.java:97)
	at org.tmatesoft.svn.core.internal.io.dav.DAVRepository.openConnection(DAVRepository.java:664)
	at org.tmatesoft.svn.core.internal.io.dav.DAVRepository.testConnection(DAVRepository.java:96)
	at hudson.scm.SubversionSCM$DescriptorImpl.checkRepositoryPath(SubversionSCM.java:1519)
	at hudson.scm.SubversionSCM.repositoryLocationsExist(SubversionSCM.java:1620)
	at hudson.scm.SubversionSCM.checkout(SubversionSCM.java:455)
	at hudson.scm.SubversionSCM.checkout(SubversionSCM.java:418)
	at hudson.model.AbstractProject.checkout(AbstractProject.java:801)
	at hudson.model.AbstractBuild$AbstractRunner.checkout(AbstractBuild.java:314)
	at hudson.model.AbstractBuild$AbstractRunner.run(AbstractBuild.java:266)
	at hudson.model.Run.run(Run.java:896)
	at hudson.model.Build.run(Build.java:112)
	at hudson.model.ResourceController.execute(ResourceController.java:93)
	at hudson.model.Executor.run(Executor.java:119)

The authentication failure warning was useless because we tried our passwords some times without any luck. After few minutes of frustration, we figured out the problem was caused by a misconfiguration of the SVN repositories accessed by blueMarine. It is probably documented somewhere in the Hudson pages (the impedance between humans and manuals, you know :).

The problem: SVNCancelException ... Authentication failed

When you configure a module in Hudson, it offers you a text field where you type the SVN URL and it also gives you a chance to type the user/password required to access the repository. Problem is: it only asks you 1 svn credential, but sometimes your module and its submodules access different repositories - what was exactly the case of blueMarine.

Solution:

The solution is simple but the useless error message and the lack of information in the Hudson GUI didn't helped at the first moment.

Hudson allows you to map diverse SVN URL to user/password credentials (or other authentication mechanism) - and not only the one asked by Hudson after you leave the text field. In order to do that, you need to click on the Help icon beside the text field and then to map all SVN repositories used by your application to the respective credentials.

After clicking the above buttons, an authentication mapper is shown and you have a chance to type how many repositories and password you need.

Nothing else to say, it is really simple to fix the problem as soon as you know what is about :) A last hint: for java.net projects you can use guest as user and leave the password blank - what is recommended to protect your password and also to guarantee the code downloaded in the host machine will have read-only access to the SVN - protecting also the code in case a hacker comes for a visit...

Hudson rocks !

Jazoon Rookie deadline: 15 March 2009

Jazoon Rookie freed your voice, and give you a chance to win a fully sponsored Jazoon'09 conference, including voucher + air ticket + accommodation expenses. Some criteria for the competitors: Aged 26 or younger (on 22 June 2009) 20 minutes technical talk Submission Deadline: 15 March 2009 Companies are invited to assist their Jazoon Rookies. Procedure: Submit until 15 March 2009 Program Committee selects the top 10 submissions Jazoon Rookies record a part of their talk on video and submit it Voting of the videos Top 3 Jazoon Rookies will be invited to Jazoon'09, where they present their 20 minutes talk to the audience and Jury (incl. Q&A) Audience and Jury evaluate the talks and select the winner Benefits: Free invitation to Jazoon'09 Free Conference pass Free Travel and accommodation to attend Jazoon'09 Jazoon Rookie Cup Each Jazoon Rookie participant receives a diploma

Important: this is a speech competition, Jazoon is looking for creative, exotic, smart and captivating speakers - the best you perform on a stage, better your chances to win - a good English and a technical background in Java also helps :)

GO FOR IT - take your camera and record today your Java Holidays at Switzerland (it is a global wide promotion)

Google Summer of Code 2009

Few days ago I was prospecting collaborators to my open source project when Björn Jensen - JUG leader of Hamburg - called my attention to the Google Summer of Code 2009 . After a brief reading of the program rules, my teacher vein started to pulse - yes, that's exactly what I was looking for.

How it works? I strongly suggest you to visit the program web page and check the official information, but in essence it works like that: Organizations publish a list of ideas and pending features of their open source projects. The companies also nominate mentors to follow the students work. Students select one of those ideas to work on during the summer 2009 After the completion of the work, the mentor checks the quality of the work and - if the code is approved - the student receives some money. The most important feature is the promotion of a learning environment based on real world requirements, a fantastic and natural idea for everyone committed with the education of the new generation of computing professionals.

java.net participation?

Reading the program documentation and asking the program organizers, I've soon realized the role of open source organization as an important criterion for the selection of the participating organizations. It is hard for Google to check the quality of the mentoring provided by individuals or projects without much visibility. The natural selection of the applying organizations points to the big players of the open source community.

Discussing that issue with other JUG leaders, we quickly target java.net as our best representative organization. The idea is simple:

Java.net projects would be nominated by SUN/java.net to participate in the Google Summer of Code.

It is just an open suggestion but the first feedback from SUN was quite positive. Important disclaimer: I do not represent SUN, it is just a personal wish to see that idea implemented in the next few years.

Congratulations Google !

What else can I say, I am following the mailing list of the program since last week and I have only claps for the Google initiative. Other positive point is the professionalism demonstrated by the managers of the program and the excitement around the open possibilities - a lot of young students eager for a chance, and a set of companies looking for the clever minds ...

Don't miss that :)

April 2009

Search this blog:

Categories

Archives

April 2009
March 2009
January 2009
December 2008
October 2008
September 2008
August 2008
July 2008
June 2008
May 2008
April 2008
March 2008
February 2008
January 2008
December 2007
November 2007
October 2007
September 2007
August 2007
July 2007
June 2007
May 2007
April 2007
March 2007
February 2007
January 2007
December 2006
November 2006
September 2006
August 2006
July 2006
May 2006
March 2006
February 2006
January 2006
December 2005
November 2005
October 2005

Recent Entries

A Generic CRUD Facade for your @Entity Beans

JavaONE 2009: here we go...

Google App Engine to support Java applications

Articles

The Requisites of a Question-Management System
The Quaestio module of the java.net Schoolbus project hopes to make it easier for teachers and professors to manage the questions they use on tests, quizzes, and homework. As project contributor Felipe Gaucho explains, hammering out the needs, goals, and concepts of such a system is tricker than it looks. Sep. 2, 2004

All articles by Felipe Gaucho »

This work is licensed under a Creative Commons License.