Code
Agile Management
I have recently been involved with a project that had a great development team – project manager, BA, server-side and UI developers and a QA team – all co-located and pulling merrily and effectively along together towards the same objectives.
Whilst we undertook some pretty serious refactoring efforts as the Product Owner (rightly) demanded a change of direction and focus, there were numerous issues that arose as senior managers who had little knowledge or understanding of the project – or possibly more importantly Agile – came under increasing pressure to “do something” as the timelines wore on due to the change of direction.
Kelly Waters’ post on why Agile must be adopted and understood from the top-down pretty succinctly sums up many of the challenges we faced, particularly around stakeholder management and expectations.
As I’ve mentioned before in response to a similar post by Mark Schumann, it’s a shame and a surprise to me that those who do not understand or are not involved directly in an Agile project, but are nonetheless in positions of influence and supposed control, cannot do a little more to understand what is in essence a fairly simple, and I doubt particularly uncommon, scenario.
Java Reflection & Constructor Varargs
I had a spot of trouble getting reflection to work with a Vararg constructor. Without being entirely sure, I think this is because Generics are implemented by type erasure whereby the type information is only available at compile time. At runtime i.e. when the Reflection API is invoked, the type information has been erased by the compiler. It looks as though this is the case to ensure legacy backwards compatibility.
Anyway, the trick with the code below was to double-wrap the constructor argument array ‘y’ in another Object array ‘z’, which isn’t clear at compile-time. This avoids an IllegalArgumentException: wrong number of arguments exception.
public A1C0(final List<RoomStream>... occupancyLevels) {
// constructor
}
public static void main(String[] args) throws Exception {
final List<RoomStream> a = new ArrayList<RoomStream>();
final List<RoomStream> b = new ArrayList<RoomStream>();
final Class[] x = {List[].class};
final List[] y = {a, b, d, e};
final Object[] z = {y};
final Constructor c = getClass().getConstructor(x);
final Object o = c.newInstance(z);
System.out.println(o); }
Agile Evolution
Charles Darwin: “It is not the strongest of the species that survive, nor the most intelligent, but the one most responsive to change.”
Agile Hype?
There is now a lot of “hype” around the Agile development methodology, possibly because it’s producing better results than traditional approaches, or perhaps it just makes people’s working lives more interesting and challenging?
Either way, I read an agile101 post suggesting that ‘doing’ agile is a sign of incompetence which put my hackles up as you might expect, given that I’m a keen advocate. But the article makes an extremely pertinent point which I’d like to stress – that Agile is only something you are going to ‘become’ with plenty of practice. Picking up a book is a good place to start but that’s all it is… Agile development is an intuitive mindset, not a bunch of rules you can follow and hope to immediately be good at.
It also struck me that as Agile has gathered pace there are now many different ways of wrapping lots of processes and metrics, management techniques and so on around the basic concepts. In my opinion this in many ways detracts from the fundamentals that are ultimately going to help you deliver, and feel these demands can actually make a team less agile as the post suggests.
Here’s my mantra, if I can call it that, which I try and religiously stick to whilst leading Agile software development teams:
- Focus, focus, focus – if it doesn’t make the boat go faster then save it for another day.
- Refactor, refactor, refactor – even the smartest and most experienced developers rarely get it bang-on first time around, especially given that priorities and requirements are often less than stable.
- Challenge the business sponsor and requirements – often I’ve found that requirements are over-complicated for the problem at hand. Get to the root of the issue, understand it, and then propose simpler alternatives which actually address the real issue.
- Aim for the best in every single line of code and development practice if you can – look after all the little things and the big things will take care of themselves!
Sure, there are many tips and suggestions that can help you and your team to a place where you are able to “move light, travel fast” but as a Technical Lead or Architect (as opposed to Project Manager, say) I think it’s more important to get an intuitive “feel” for what’s a true value-add.
Although you’ll probably have to compromise at times on some of the points mentioned above, they’ve been great cornerstones for me when I feel there are too many demands on my time from what I consider to be less important techniques or deliverables.
Hibernate’s @FilterJoinTable
Couldn’t find a completely articulate example or full documentation of how to add a filter to a Hibernate Many-to-Many collection association mapping, so thought I’d would post a complete example here.
It’s possible to apply the filter to the target entity table which is reasonably well documented, or at least you can have an educated guess, but also to the association table of the Many-to-Many relationship where the docs were a little less clear.
I have the following relational association table:
CREATE TABLE departure_point_resort_association (
departure_point_id VARCHAR(36) NOT NULL,
resort_id VARCHAR(36) NOT NULL,
site_id ENUM('30', '31'...) NOT NULL,
PRIMARY KEY (departure_point_id, resort_id),
CONSTRAINT assoc_departure_point_fk FOREIGN KEY (departure_point_id)
REFERENCES departure_point (id),
CONSTRAINT assoc_resort_fk FOREIGN KEY (resort_id) REFERENCES resort (id)
);
which is mapping a ski resort to potential departure points or airports. There was no real requirement to persist an actual SITE table (which would be entirely static data) and to map to it’s foreign key value, so instead am using a simple MySQL ENUM column above, and wanted to apply a filter at the application level to the collection of Resorts based on this site_id.
@Entity @Table
@FilterDef(name = "siteFilter", parameters = {
@ParamDef(name = "siteId", type = "string")
})
public final class Resort extends BasePersistentObject {
@ManyToMany(fetch = FetchType.EAGER)
@FilterJoinTable(name = "siteFilter", condition = "site_id = :siteId")
@JoinTable(name = "DEPARTURE_POINT_RESORT_ASSOCIATION",
joinColumns = {
@JoinColumn(name = "RESORT_ID")
},
inverseJoinColumns = {
@JoinColumn(name = "DEPARTURE_POINT_ID")
}
)
private Set departurePoints;
Then it’s simply a case of enabling the filter in the client (DAO or whatever your framework dictates):
session.enableFilter("siteFilter").setParameter("siteId", String.valueOf(siteId));
Programming for grown-ups
I sent an article by Ted Dziuba of The Register around to my development team earlier this morning. As well as some well-deserved shots at Microsoft, it contained a rather acidic commentary (not like him) on the merits of the PHP programming language. Or rather lack of.
One of my colleagues replied with the following:
Hibernate StatelessSession with Transactional Annotation
I have a bi-directional collection mapping in Java which I thought was causing me problems when persisting using Hibernate’s StatelessSession API.
However, it looks as though the issue was being caused by the fact I was using the @Transactional annotation instead. The API states:
“Operations performed via a stateless session bypass Hibernate’s event model and interceptors.”
I didn’t pick up on the importance of the above statement as it’s not particularly clear at first glance, but it looks as though using Annotations via AOP just isn’t supported when streaming directly to the database using the StatelessSession.
Commenting out the annotation and using a programmatic Transaction instead corrected the problem:
// @Transactional
public List<Package> insertAvailability(final List<Package> packages) {
final StatelessSession session = sessionFactory.openStatelessSession();
final Transaction tx = session.beginTransaction();
session.insert(aPackage);
// insert collections manually etc...
tx.commit();
session.close();
return packages;
}