Software Transactional Memory – Podcast – JSpring ‘09 Preview
Posted by Robert van Loghem around lunchtime: March 28th, 2009
On the 15th of April the NLJUG (Dutch Java User group) will be holding their J-Spring conference. Four Xebians will be presenting. Every week we'll be providing a sneak preview on the podcast of one of those presentations.
The first sneak peek is about Software Transactional Memory by Peter Veentjer.
You can find more information at the NLJUG presentation page.
Peter's presentation is from 11:20 to 12:10.
Hosted by Robert van Loghem.
This preview is in Dutch. After the 15th we'll be doing a full episode in english about STM.
So head on over to the show page or subscribe to our podcast!
GWT: An introduction
Posted by Himanshu Gupta in the early afternoon: March 26th, 2009
Introduction
Google Web Toolkit is a open source java framework to build rich user interface with widgets and panels. It communicates with one technology rather with different technologies, and it works on linux, windows and mac. In GWT code is converted from Java to Java script. GWT can be compared with latest technologies as Flex, Microsoft Silverlight and Java FX. All of these technologies provide rich widget based development but GWT stands apart due to its java script code conversion.
GWT has some interesting features which brings thoughts why GWT is good. Some of these features are integration with browser back button, internationalization, code development in eclipse, fells working in desktop based application and UI code written in java.
(more...)
JPA implementation patterns: Saving (detached) entities
Posted by Vincent Partington at around evening time: March 23rd, 2009
We kicked off our hunt for JPA implementation patterns with the Data Access Object pattern and continued with the discussion of how to manage bidirectional associations. This week we touch upon a subject that may seem trivial at first: how to save an entity.
Saving an entity in JPA is simple, right? We just pass the object we want to persist to EntityManager.persist. It all seems to work quite well until we run into the dreaded "detached entity passed to persist" message. Or a similar message when we use a different JPA provider than the Hibernate EntityManager.
(more...)
HSQLDB “database already in use by another process” exceptions on UNIX
Posted by Andrew Phillips mid-afternoon: March 20th, 2009
Installing a simple Grails application in Tomcat on Linux should really have been the most straightforward of tasks. Instead, I spent a progressively more frustrating morning chasing down a "helpful" feature of HSQLDB that was causing the startup to fail with
org.hsqldb.HsqlException: The database is already in use by another process: org.hsqldb.persist.NIOLockFile@6b67bdbe[file =/myDb.lck, exists=true, locked=false, valid=false, fl=null]
exceptions. To save others from a similar waste of time, here's the cause and a workaround: (more...)
JPA implementation patterns: Bidirectional assocations
Posted by Vincent Partington in the early evening: March 16th, 2009
Last week we started our search for JPA implementation patterns with the Data Access Object pattern. This week we continue with another hairy subject.
JPA offers the @OneToMany, @ManyToOne, @OneToOne, and @ManyToMany annotations to map associations between objects. While EJB 2.x offered container managed relationships to manage these associations, and especially to keep bidirectional associations in sync, JPA leaves more up to the developer.
(more...)
Clouds… Everything-As-A-Service
Posted by Guido Schoonheim around lunchtime: March 13th, 2009
Yesterday was a very good day! After speaking at QCon the day ended with CloudCamp. An evening dedicated to everything cloud with an amazing turnout! More then 500 folks joined.
Turns out that although in general people tend to agree what a cloud is, nobody actually knows exactly what to do with it! (more...)
A general-purpose utility to retrieve Java generic type values
Posted by Andrew Phillips in the early afternoon: March 12th, 2009
In a recent post, Arjan Blokzijl discussed how Class.getGenericSuperclass can be used to access generic type information.
This can be very useful, but implementing a general-purpose method to do this isn't as straightforward as it might seem. In this post, we'll outline some of the issues and hopefully resolve them, creating a utility class in the process. After all, with luck this is the kind of code that only needs to be written once! For the curious or impatient, here it is. (more...)
Agile Distributed Development done right – QCon London 2009
Posted by Guido Schoonheim in the early evening: March 9th, 2009
Working distributed is all about handling distance. Geography, culture, methods & tools, timezones, languages are all adding to that distance. Not measured in miles but in people.
How to get a focus on individuals and interactions when your people are distributed across the globe? What is the secret sauce to use to get it running smoothly?
The classical route of bringing this 'gap' under control involves adding process and handovers. It actually forces you to go into a waterfall-like model and therefor widens the Gap instead of bridging it. All waste is institutionalized. Sounds like a horror to you? It does to me.
(more...)
JPA implementation patterns: Data Access Objects
Posted by Vincent Partington mid-afternoon: March 9th, 2009
The JPA, short for Java Persistence API, is part of the Java EE 5 specification and has been implemented by Hibernate, TopLink, EclipseLink, OpenJPA, and a number of other object-relational mapping (ORM) frameworks. Because JPA was originally designed as part of the EJB 3.0 specification, you can use it within an EJB 3.0 application. But it works equally well outside of EJB 3.0, for example in a Spring application. And when even Gavin King, the designer of Hibernate, recommends using JPA in the second edition of Hibernate in Action, a.k.a. Java Persistence with Hibernate, it's obvious that JPA is here to stay.
Once you get over your fear of annotations 
, you find that there is plenty of literature out there that explains the objects and methods within the API, the way these objects work together and how you can expect them to be implemented. And when you stick to hello-world-style programs, it all seems pretty straight forward. But when you start writing your first real application, you find that things are not so simple. The abstraction provided by JPA is pretty leaky and has ramifications for larger parts of your application than just your Data Access Objects (DAO's) and your domain objects. You need to make decisions on how to handle transactions, lazy loading, detached object (think web frameworks), inheritance, and more. And it turns out that the books and the articles don't really help you here.
(more...)
Gotcha! Watch out when overriding bean property accessors…
Posted by Andrew Phillips in the early morning: March 6th, 2009
Whilst working on a bean deep cloning utility recently (more about that some other time) I got stuck for a while on some unexpected behaviour exhibited by java.beans.Introspector. I don't know many people who use this class directly, but it's heavily used by, amongst others, the Apache BeanUtils, so if you're using those you might still come across this issue.
The problem arises if you happen to have overridden bean property accessors in your classes. (more...)
Archives
Xebia Sites
Categories
- Java (282)
- Agile (109)
- General (50)
- Testing (42)
- Performance (42)
- Hibernate (36)
- Scrum (33)
- Podcast (31)
- Architecture (31)
- Spring (28)
- SOA (24)
- Maven (22)
- Project Management (22)
- Middleware (23)
- Deployment (14)
- Flex (17)
- JPA (17)
- Eclipse (15)
- Xebia Labs (15)
- Quality Assurance (14)