This week we had another lunch with geeks.  The attendance was good and we talked about a number of things.

The first thing we talked about was broadening the scope of this group to other technologies. We are looking for people from RoR community and the Java community. We do have 1 java person that attends our meetings regularly but we’d like to get some more. So if you’re in Wellington and you do development these lunches may be something for you.

Another thing we talked about was: What’s the best microsoft product? And what’s the worst?

on the question of worst we had a consensus : windows ME.

on the question what is the best product I guess the most votes went to CLR/.NET Framework. Somebody also mentioned Flight Simulator

We also talked about Aspect Oriented programming and we got a little confused by what the PolicyInjection Block is about in the Enterprise Library.  It claims to do AOP but somebody pointed out that it doesn’t quite do that. It does most of the AOP features but not all of them and it’s a little intrusive because it has to be defined by the caller.

The only problem we had was that there was another group in the pizza place so I couldn’t understand most of what was being said. Please email me the stuff I forgot about or add it in the comments.

We had another geeks lunch on tuesday. We discussed a number of topics but focussed mainly on design patterns.

Some of the observations we made are the following.

The most overused design pattern : Singleton. With the remark that a singleton should only be used when you need to keep state in your object internally.

You shouldn’t care about design patterns until you figured out a couple yourself. This is a bit the chicken or the egg question because you would have to know the design patterns in order to know that you are using one.

Lot’s of programmers get by without the patterns although the solutions may not look as elegant.  Design patterns are in no way a silver bullet for creating quality software they just help you solve problems in a predictable way.

One of the ways suggested to start adopting these patterns is to write code that works first and then refactor it to use the patterns.

Next I’d like to list a bunch of resources/books that were mentioned during this discussion:

Thanks to Bevan Arps for this list of books:

Design Patterns (Gang of Four)
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
ISBN 0 204 63361 2

Refactoring – Improving the Design of Existing Code
Martin Fowler
ISBN 0 204 48567 2

Analysis Patters – Reusable Object Models
Martin Fowler
ISBN 0 201 89542 0

Refactoring to Patterns
Joshua Kerievsky
ISBN 0 321 21335 1

Ivan Towlson has put up a blog post listing the books that he remembered.

And here are some urls that hold some information on design patterns.

http://www.developer.com/design/article.php/1474561

http://www.dofactory.com/Patterns/Patterns.aspx

http://www.designpatternsfor.net/

We had another lunch session yesterday. It was a quiet session probably because of the Wellington weather, there were 7 people attending.

The first topic we discussed was mobilizing your application.

The first issue that was raised around this subject what usability issues have you got to tackle around mobile applications.  Like navigation should be vastly different because of the lack of screen real estate. navigation is mostly done with a joystick or keypad there is no mouse which in itself is already a pretty difficult problem to tackle. 

Another person mentioned that dropdownlists are pretty difficult to navigate too.  It would be naive to assume that you can use one codebase and make some style changes to get a great mobile application.  You need to take the fact of mobilizing more serious than that and be prepared to make some drastic changes in how your app flows.

One of the reasons that we haven’t really seen a great mobile app make it big is probably because of the user interface we are facing when operating a mobile device. Technology has changed a lot since mobile phones came to be but the interface hasn’t hardly changed at all. It went from a disc to buttons to buttons with a little display. Until the cell phone was there and we got a menu to operate our phones. The navigation of those menus has evolved somewhat but it’s still the same way of using it. Of course this is when the iPhone came into the conversation, and because I work at Xero i got to play briefly with an iPhone

I have to say that the touch screen navigation was really cool and refreshing and definitely a step in the right direction.

After which our conversation drifted off a little and we dreamt of futuristic interfaces and new ways of interacting with computers.

Simone has got a great post on life in wellington as a european in which he talks about our lunches and other things.

Another week, another lunch. The attendees this week were JD (Mindscape), Andrew Peters (Mindscape), Adam Burmister (Xero), Fletch Brown (Xero), Simone Charietta (Calcium), James Hippolite (Telecom), Martin Harris (Telecom) and me (Xero). 
Our meetings used to be on a thursday but we moved them to Tuesday in the hope that more people would be able to make it (Tim wink wink)

We started out with the OR mapper of mindscape: Lightspeed.  JD and Andrew were pretty quick to point out that Lightspeed is a lot faster than NHibernate for all the operations they currently support.
The analogy was made that NHibernate is like the Oracle of OR mappers and supports every single feature you could every imagine. Where Lightspeed is a bit more limited in features but still does a good job.

From that point on the discussion went on to Katmai (SQL Server 2008) and nobody seemed to know what the new killer features are, apart from the obvious one that it’s a new version.
JB of Mindscape has a the ctp installed but didn’t have time yet to have a proper play with it.  Simone asked what the killer features were for Sql 2005 and offered XPath/XQuery in the Xml columns, I offered CLR integration from then on we struggled a little. It turns out that Andrew and me were the only ones that had actually used the features in a production app.
Luckily JD threw the MAX values for varchar, nvarchar, .. on the table and everybody agreed that that one is overlooked because it should have been there all along

The next point of discussion was of course the beta release of Safari for windows. Andrew pointed out that you could go to Pimp my safari to flesh out safari with some much needed plugins.  Nobody really understood why apple didn’t take advantage of cleartype rendering on the windows platform. One of the reasons might be that the apple developers want to maintain one codebase, which is also understandable but then they will have to fix the subpixel rendering because now it isn’t up to scratch. 

James moved the discussion topic over to the fact that Silverlight supports VB.NET better than it will support C# as programming language. Which made me ask why the guys of MS not just kill of the VB language all together ?  Lot’s of C# programmers agreed on this but the poor VB guys didn’t flinch one bit.  Everybody around the table had programmed in some form of Basic in the course of their lives. For me I started with GW-Basic, did some visual basic after that but from then I moved to Turbo Pascal.
The DLR has a dynamic form VB as well so it will still be a while before that one will go away, if it ever does.  

Which brought us to the next point of discussion datasets vs OR/mappers. James is a big fan of the dataset and what he can do with it. Where most of the other people around the table liked the OR approach better. After some bickering we agreed that it’s mostly a personal choice. Both methods have their advantages and disadvantages.  Andrew was the one that enlightened us with the big difference between the 2. Domain models have behaviour attached to objects where an RDBMS approach separates the 2 which makes you maintain the code into 2 different places. 

And the last point of discussion would be XML is it a datacontainer/exchanger or is it a programming language.
I personally have a strong dislike for xml, I find it verbose and not friendly to write (number of keystrokes).
JD picked up that discussion by categorically saying that xml is a datacontainer and not a programming language, he then asked me why I asked that question.  The reason for that question is, that whenever I bring up the subject people will tell me it’s a datacontainer and yet we see the new technologies being introduced are all based on xml (WPF, XUL, …). Then people come up with the fact that if there is a good tool support for it it’s not that bad. On this point I personally agree with Ayende, in that you shouldn’t have to use a tool if you want to get on with the technology. To quote Ayende:

Here is a good metric that I like to use. Take an technology, and try to build it without any tool assistance. Is it still a good approach? If not, then there it is complex and hard to use. A lot of UI frameworks fails this test, by the way. WinForms certainly does, when you start to think about complex UI.

Which brought us to the point of DSL’s vs. XML + tools to generate your manifests (manifest => a webpage has an xhtml manifest, with javascript behaviour and CSS for representation)
Somebody around the table didn’t quite know what DSL meant, so Andrew quickly explained that it means Domain Specific Language and it makes it a lot easier for the developer to write out the manifest he needs or to make your code inside your specific domain more readable.

Ok that’s it for today, or at least that’s all I could remember, if I forgot something please let me know and I’ll add it to this post