TITLE
Duchess, Ladies in Java
link: www.jduchess.org

ABSTRACT
Female programmers are rare. Female Java programmers are even more rare. As female Java programmers ourselves, our interest in this issue led us to start Duchess, an organization to support and promote women in the Java industry and hopefully to encourage more to join. Our approach to the shortage of women Java programmers includes making the problem and
arguments for involving women in IT visible. Why is it good to have more women in the industry?

Why are there so few women in IT and why there should be more
Communications and Language Skills
First, there is the image of IT as only for men because men are better at it. However, according to an article “Why More Women Should Consider a Career in Computer Programming”, V. Berba Velasco Jr. (the author) argues that women can contribute a lot to the field because of their intrinsic language and communications skills. People with better language skill produce better code because the code would be more readable. This would in turn lead to lower development and maintenance costs. As Martin Fowler
once said, “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” A team must understand each other to produce the software together. Furthermore, better language
skills lead to better documentation, which helps the intended audience use the software.

Diversity = Productivity
A diverse workforce is more productive. Therefore, there should be more women in the IT industry. In a recent article on the NYTimes, Scott E. Page, a professor of complex systems, political science and economics, said that homogeneous organizations get stuck more often, while “diverse groups of people bring to organizations more and different ways of seeing
a problem and, thus, faster/better ways of solving it.” In his study, he used mathematical models and case studies to support the claim that diversity = productivity. Men and women complement each other. In a BBC article reporting on Helen Fisher’s speech at DAVOS, she said that “Having only men or women on your team would be like hopping on one foot instead of walking.”

Economy
A second reason for so few women in IT is related to economy. In some countries, the IT industry suffers from the same issues that lead to the general lack of women in the workforce. In these countries, the lack of affordable childcare and flexible hours in the workplace means that women often stop working completely. The price of childcare outweighs the salary of the woman in the family, so that it is often financially unwise for a woman to return to work after having children. In this case, the women staying home is the optimal economic configuration for the family. But for the economy as a whole, a shortage of labor often impedes economic growth. In these countries, governments and businesses can encourage women to return to the workplace by providing affordable childcare and promoting flexible hours.

Stereotypes
We realize that some of the things we said about women above are considered stereotypes and of course, not everyone fits in to a stereotype, but the fact is that men and women ARE different. The important thing is to be aware of the stereotypes, so you can see how a person – male or female – fit in.

About Duchess?
Duchess is an organization of women Java programmers. It provides a platform for women to organize themselves online and offline for real life networking. Our short term goals include arranging technical sessions, study groups, social outings, and discounts for external events and courses. Our long term goals include establishing local branches all over the world and reachout programs in schools and universities.

If you are a female Java programmer, why should you join Duchess?
Network. Extending your network is always good for your career.
Learn. There is a chance to learn from workshops and courses accessed through Duchess.
Share. Share your experiences will deepen your knowledge and support other women in IT.

References:
http://www.scienceblog.com/cms/does-diversity-increase-productivity-15193.html
http://www.nytimes.com/2008/01/08/science/08conv.html?_r=1&ref=science&oref=slogin
http://www.streetdirectory.com/travel_guide/10105/women/why_more_women_should_consider_a_career_in_computer_programming.html
http://www.informit.com/articles/article.aspx?p=360842&seqNum=4
http://www.unescap.org/esid/GAD/Events/EGMICT2001/apctt.ppt
http://www.unu.edu/unupress/unupbooks/uu37we/uu37we0k.htm
http://news.bbc.co.uk/2/hi/business/7209353.stm

It was first explained to me as being able to pass code around, like they had in C which I only vaguely remember. Then it became more clear when applied as the much neglected Visitor Pattern. For example, if you have a Collection and you want to do something to each item. It is really not the caller’s responsibility to loop through the collection. You just want to give the handler method to the collection and say, here you go: run this on each item. That is closure. That is a correct separation of concerns. And more OO.

Another way to use closures is where we currently use anonymous classes. Passing handler code to a listener. Still have to figure out the exact advantage here to anonymous classes.

The use of closures is related to AOP. Closure is passing in handler code, where the use of this code is wrapped by other code, possibly of other aspects, such as starting and ending transactions. It is like passing in the code for the implementation an abstract method, instead of having to create an entire class around it.

So, although the enhanced for-loop in Java 1.5 is a welcomed simplification to the horrid Iterator, it is only moving in the direction of closures, which they say will be in Java 1.6. Until then, the discussion on why and how will be very interesting indeed.

Besides the sessions, what I find even more valuable is the chance to have discussions and find out technologies and experiences from fellow programmers. At first glance, the main issues presented at the conference were: SOA and rich client, with a few about performance, process, testing, and Ruby.

Audio/Video with synchronized slides (also downloadable as PodCasts) are promised for free at www.parleys.com. Currently the site contains sessions from SpringOne, the other conference organized by BeJUG.

It was certainly inspiring to be in the company of some of the best Java developers in the Netherlands. It was a day of intense competition, 15-30 minute periods of stress, pushing ourselves to the limit, but it also rounded off with a sense of accomplishment and fun. It was definitely an experience and I’m glad I participated.

There were a total of 22 teams, at least 50% less than they had before. The organizers admitted that they didn’t send out as many emails as they did last year. And someone who also participated last year thought that it was because people found the assignments too hard. Last year, most people simply couldn’t finish most of the assignments. But this year, they had better QA of the tests and made sure that most people at least had a fighting chance.

The assignments were either a test on algorithm or a test on API knowledge. We did quite okay on the API knowledge, placing 5 or 6 on some assignments, but couldn’t keep it up. One disadvantage is that this was the first time I ever encountered Java 5 constructs. My partner has some but also limited knowledge. So, although I thought professionals because of experience, would have a better chance at APIs, this is only if you had the chance to work on Java 5 or spent your own time to look at it. As for the algorithms, you have to just be plain smart.

At the beginning, we made very silly mistakes that cost us lots of time. There was also a hint on one of the assignments that threw almost everybody. Better no hint than a misleading hint. At least be clear about what you’re hinting about. Anyway, in the end we are proud to place in the top half. My partner thinks that we could’ve done better if we had practiced more, but I’m not sure. I wonder which teams have participated before. It would be interesting to know.

In conclusion, experience matters, but then again, being real smart is better. :)

Congratulations to the winners, especially the first place team, Globetrotters from iProfs, who won a SUN workstation.

Charles Nutter, hired by Sun a couple of months ago to work on JRuby, will come to Rotterdam in december to give a presentation. He will talk a lot about JRuby and JVM as scripting platform and a bit about running Rails on a JVM.

Registration via:
unieke-jruby-lezing-in-nederland-door-amerikaanse-jruby-guru-charles-nutter

Scripting is the next big thing for Java programmers, so be there!

When we heard about this at JFall, we thought it would be interesting to see where we stand on the cleverness scale. The only drawback is that we’d have to take a day off work to do it, but we figured we can do it just this one time.

I find that what’s even more interesting than solving programming problems is the pair programming. So not only does this test our ability to code, but also our ability to work together. Can we function as a team? Do we compensate for each other’s weaknesses? How clearly do we communicate our thoughts? How open are we to the other’s ideas? Can our brains think as one when given a clear goal?

A few weeks ago we had a practice run just for the hell of it. We both found that coding algorithms is a muscle neither of us has flexed in quite awhile, possibly since university. I bet kids right out of school would be good at this. The Java work that is available here has more to do with OO design and good structuring of code, and rarely requires algorithms. This is because performance is often overlooked in high level applications. This work requires a different set of skills than what is being tested at the Master of Java.

As we worked through more problems, the part of our brains responsible for algorithms got a little exercise. We also had to get used to working under such intense time pressure. (minutes as opposed to days) For the first problem, we couldn’t even solve it until we stopped the pair programming. The rest went much smoother, but sometimes we came across a problem that was just badly designed and missing a lot of necessary information, just like how it can happen in the real world.

We’re not going to spend anymore time to prepare, but I’m sure glad we did this practice session. Otherwise, we’d be swimming…

Good luck for whoever else is going!

The first keynote was represented by people from Sun, mainly trying to promote SPOT (Small Programmable Object Technology), where people can get small pieces of hardware (mainly from the States or Canada) and program Java on top. The demos included little robots on wheels that didn’t really do much yet. But the most interesting part of this keynote for me was the musical search program. The idea was to search within music (and eventually in video) just like we do with text. This is still in research state, but someone did spend the time to make a very funky GUI for it. It shows a graph of colored clusters where each dot represents a song and each color represents a certain style.

The session were scheduled in 5 rooms depending on the interest expressed in each topic during registration. For each timeslot, I was mainly torn between a somewhat technical session or a high-level session.

For the first session, I had at first wanted to go to “To Data Independence & Beyond!” – about test-driven development and testing frameworks. I think that since the agile revolution, lack of knowledge testing in a developer will become more and more old-school. I believe that there will come day where if you cannot set up a testing framework with blindfolds on, then you’re not a good developer. I also think that good testing is also a team effort, so the idea is not to leave someone else to do it.

But at the last minute, I ended up attending “Top 10 Enterprise Java performance problemen en hun oplossingen” – the talk about Java performance issues. Since developers invariably come across most of these issues, it’s nothing new. But it is still a very good list of 10 things to keep in mind while working on a project. I believe Vincent Partington from Xebia is currently having the talk translated and available online. A little regretting missing the details in the testing session, but we’ve been told that we will get PDFs of all the talks, so I hope I’ll have a chance to go into details once those are available.

For the second session, I attended “Hibernate explained with TechAnims and TechMaps”, whirlwind presentation of a 3-day course squished into just 50 minutes by two French guys – charming accent, I’d say. And good job too. The main presenter hardly had a chance to breathe. I was quite impressed with how much information they were able to present clearly in such a short time. The talk presented the basics of Hibernate while showing code, configuration, data schema, and sequence diagrams at the same time. We went through some simple mappings, user types, entity relationships (uni-directional or bi-directional and one-to-one, one-to-many, many-to-one, and many-to-many relationships), lazy loading, pessimistic and optimistic locking, and caching mechanisms. I would make more use of colors so we would know where to look and maybe sometimes a higher level diagram before zooming into code. I would find that useful.

The second keynote was nominally called “The Vocabulary of Enterprise Applications”, presented by Adrian Colyer of Interface21. However, he quickly dived into AOP – which according to him is the lesser known part of Spring and presented some examples of how you would solve certain requirements by using aspects in Spring. The best part was the idea that an object should be represented by a triangle – with the 3 sides exposing IoC, AOP, and data access – 3 things that Spring “takes care of” for you.

Next, I went to “Kennismaking met het Eclipse Modeling Framework (EMF)” where I expected to see the use of UML within Eclipse. But, what was presented was that the model was kept inside the code with annotations. We often talk about finding Java in JSPs, but this was like keeping track of scripts in inside your Java code. As far as I can see, MDA is still not there yet. The best for this is probably OptimalJ, but even then you still cannot generate an entire application at the touch of a button.

Since there seemed to be a big buzz on AOP, I decided to go to “Advanced AOP with AspectJ” next, also by Adrian Coyler. So now, I can’t remember what he said in which talk. I could follow the concepts of his examples, but not really the code, since I haven’t read up on AspectJ yet. His main advice is that if you are going to introduce aspects into your applications, do it in phases. Start with the standard aspects in Spring, then write your own aspects, then go onto AspectJ. Spring is designed to use the same vocabulary as AspectJ.

For the last session, I went to “JSF made easy with Facelets”. Although I’m not really into front-end programming, I thought it would be good to go to this just to get the main ideas presented to me on a platter. And it worked. :) The presentation was clear and the demos worked well (very important). Facelets allows the front-end to be built up from components that represent different boxes on a HTML page, much like Tiles but without Struts. Facelets makes JSF much easier to work with, by moving the effort from making tags to making components. Plus, the demos showed some seemless integration with AJAX, so you don’t have to miss out on that latest front-end buzz.

The main ideas I came away with are:

• Spring
• Hibernate
• AspectJ
• JSF/Facelets

but also:

• performance – pitfalls and solutions
• testing – unit and functional testing
• agile