Julius Ganns . netzkern

As already the Weepies said in their very own way, things inevitably change. Nearly 8 years ago, I joined one of the best companies I've always known and I probably will know in the future. Working for netzkern was not only fun and a great experience, the team became somewhat like family to me during these years. The things I learned in my various roles and having very different responsibilities were more valuable to me than most other things I came across in my life (including the years at school, university and in all other educational programs combined). But as all great times come to an end, so does this endeavor.
Tomorrow I will start my new job at Avanade, an international IT consulting company founded by Microsoft & Accenture. I feel a little bit like the former Chief Software Architect of Microsoft, Bill Gates, these days (see the great video "Bill Gates' last full day at Microsoft"). As you can imagine, this change has been in the planning for quite some time now. The newly formed steering committee for the netzkern.systems business unit is staffed with some of the finest guys I've known and there is no doubt that Thomas, Markus, Peter and Alex will lead the team into a successful future.
I also don't want to neglect the fact that it had a transforming effect on all of them. Now that my former responsibilities have been distributed among them and the technical expert teams led by Mattes and Phil, there seems to be an even larger desire to move things forward. Maybe, this change is one of the most important things that will ever happen to netzkern, as it literally kickstarted a process I tried to implement for nearly 2 years now, but it always got stuck somehow between large projects and daily activities. Putting a newly formed team in charge of the work I did for almost 4 years not only distributes the work on more shoulders, it also forces everyone to take additional responsibilities and to grow into new roles, while finally removing me as bottleneck. Of course, there are challenges, but I'm convinced that everyone will do his very best to not only keep things going well, but to finally overcome the challenges we started to move on when I was still part of the team.
The only thing I've left to say at this point is Thank You. I want to thank my partners, Thomas and Daniel, for their support and for some of the best years of my life. I also want to thank my team for all the great experiences we had together - I will definitely miss each and everyone of you and I hope to see you soon.
Of course, I will not leave work unfinished that I started. Although my blog will shortly move to www.juliusganns.com/blog, I will continue to publish the missing pieces of my SharePoint vs. Sitecore series here, as well as under the new URL.

Have a great time,
Julius

Okay guys, here is a very short list of the good and bad things in SharePoint 2010 from my perspective as software architect. Let's get started...

The Good:

• Improved integration with VisualStudio 2010 that goes beyond the available features in VSeWSS.
• Support for LINQ and extended support for XSLT, which will - among other things - be used for list generation (although CAML will unfortunately stay an important part of the platform).
• Better AJAX support (and I don't mean the Ribbon UI, because CSS and JavaScript have nothing to do with AJAX).

The Bad:

• SharePoint 2010 will be based on .NET 3.5 and Windows Workflow Foundation 3.5 (instead of the rewritten version of 4.0). This is especially sad because I rejected WF 3.x from the very beginning and was very pleased to see Microsoft creating a complete rewrite.

Unknown:

• It is still unknown if Microsoft fixed the annoying performance and development issues with undisposed objects (see http://www.sharepointdevwiki.com/display/public/When+to+Dispose+SharePoint+objects for more details). This is one of the major architectural drawbacks of the platform and definitely something, Microsoft's engineers should fix as soon as possible.
  

I will update this post as more information become available.

Before continuing my series on SharePoint and Sitecore development from a software engineering perspective, I created a revised edition of my last post. The series now covers the CTP version of VSeWSS 1.3, which makes developing custom SharePoint solutions much easier.

Table of Contents:
- Introduction (Part 1)
- Installation and General Architecture (Part 2)
- Configuration (Part 3)
- Customization and Designer Experience (Part 4)
- Integration with Developer Tools (Part 5)
- Feature Deployment (Part 6)
- API und Data Model (Part 7)
- Integration with other systems (Part 8)
- Conclusion (Part 9)

By the way, part 6 is currently in development and will hopefully be ready in a couple of weeks.

There are great things to come in .NET 4.0, especially Code Contracts and the Parallel Extensions. Take a look: http://msdn.microsoft.com/de-de/magazine/ee428166(en-us).aspx

Everyone knows, I’ve never been that big of a fan when it comes to ASP.NET WebForms. Instead of repeating my reasons here over and over again, just take a look at former posts of mine, for example here, here, and here. Well, unfortunately starting with today, there is one more reason for not using WebForms: A very annoying bug in IE8 that especially disturbs the way ASP.NET WebForms are working.

As those things are inherently difficult to explain, I decided to make a very short video (about 1 minute and 30 seconds) to show the strange behavior of WebForms and IE8 when opening a new browser window. In a nutshell, IE8 seems to lose its current state when a new page is opened for the first time, so it has to request the current page using GET from the server again. The odd thing is, doing the same thing a second time transfers the current state to the new browser window and no request is issued towards the server, so ASP.NET WebForms does not have a chance to react appropriately. This is especially an issue if the state and behavior of your web application depends on hidden fields and automatic framework handling of the forms collection – which is unfortunately the case in Microsoft’s primary web framework ASP.NET WebForms.

Check out the video (1:30 mins).

A couple of days ago, I needed a minor customization in my Outlook 2007. Being a developer, I just opened the integrated development environment in Office and wrote some quick VBA code. I would have done it with C# and VisualStudio, but to be honest, every time I start to work with Office components, especially Outlook, I struggle with the unnecessary complexity and the low quality COM-based API. While I was coding, I began to think about why there seemed to be virtually no effort at Microsoft to rewrite and redesign important applications like Outlook in the near future. It virtually made no sense to somehow abandon a successful product like that.

A couple of hours later, I checked my RSS reader and found an interesting article about the upcoming Exchange 2010 (or "E14" for short). Suprinsingly, when I took a look at the screenshots, they answered my earlier question.

Microsoft has not only started to rewrite its most important applications, in fact, they have completely redesigned every single one of them. Following the vision of its Chief Software Architect Ray Ozzy, Microsoft has finally understand the possibilities and the importance of the web. The new Microsoft Exchange 2010 has an Outlook interface that should be able to really compete with the “old” desktop client and as we all know, this is only part of a complete Microsoft Office application suite running within the browser.

When we started to see the web as platform for our business back in 2004 when I took over as Chief Software Architect at netzkern and our company began to focus all efforts on web and service-oriented technologies, there were a lot of people who disagreed with me on that vision. Up until today, history has proven us right and we’re looking forward what the web will bring to us in the next 5 years.

When Web UI Component Frameworks like ASP.NET WebForms and JSF were invented in the early years of this decade, they were an honest attempt to bring an additional layer of abstraction to the web. This layer was supposed to improve a couple of things, especially in the areas of usability, developer productivity, extensibility and out-of-the-box features. They were also created to attract the old guard of desktop developers, that spend so many years to learn and master their craft.

To accomplish that mission, these frameworks were composed of hundreds of invisible components to form a feature-rich environment based on abstraction and simulation. This environment targeted one specific thing: hiding away as much of the original web infrastructure as possible. To accomplish that goal, Microsoft, Sun and others created complex workarounds to overcome some of the “serious limitations” of the web. Those features were given fancy names like Postback, ViewState and CodeBehind, which we all know and have to live with every day.

The problem with these techniques is that they are not only an additional layer of abstraction, they are actually based on some quite different paradigms. At some point that inevitably creates major problems if you want to create “real” web applications and you find yourself searching for solutions to problems that you might not even have if you hadn’t started to use those frameworks in the first place.

When some developers began to realize that these heavy-weight component-oriented frameworks started to decrease their productivity, they did a very clever thing. Instead of reverting completely back to old frameworks like the original Struts or ASP, they took all the great things that the Web UI Component Frameworks had brought to light, merged them with those frameworks and included new techniques and approaches that emerged over the last few years. The result of these efforts are frameworks like ASP.NET MVC, Ruby on Rails, Grails and Spring MVC that handle requests on the server-side much more naturally and effectively, and frameworks like JQuery, ASP.NET AJAX, Silverlight, Flex and Prototype, that handle user interaction on the client-side.

The way of web development has changed and as I wrote in my post about this topic about a year ago, it’s time to rethink now. Don’t miss this one, it is a big one.

“The largest thing on earth is the human ego.” is one of that statements that remain true no matter what – probably today more than ever. In the beginning of this year, I was quite active on various social networking sites like Twitter and Facebook. In the beginning, it was really a lot of fun, seeing all the things my friends were doing and what was going on around me. Unfortunately, that feeling has changed. When I open Facebook these days, the only feeling I get is disgust about the grandstanding and ego-casting that is happening there way to much. It is the same thing that happens if people get to much attention in the real world: They get supercilious, start to actually need all the attention and feel obligated to attract all the approval of the other people around them.

The sad thing about that development is that Twitter and Facebook could really bring value to our world. They could help to stay in contact, to bring people closer together over large distances and they can help this world to overcome some of the biggest problems we face today: Biased media, censorship and ignorance.

The good thing is: Publicity is one of the most volatile things there are, and therefore, I expect those self-exposing images to be gone a certain while from now. And if we get lucky, someone will fill that void with sustainability and balance by using those great ideas for something useful.