Mike-ro-Blog

RADRACE 2006 - judgement day

Starting with a lot of optimism and confidence in our toolset, we had some trouble today in saving data. This took a long time to fix, mainly because of our little experience with the OR-mapping framework and de GUI components. Building just a small test app was clearly not enough preparation (as we had expected though...). Luckily, Rene managed to push out some reports in ASP.NET, which was a hell of a job as we did not discover any support for building ASP.NET applications in MonoDevelop. So he did it by hand (and with some browsing through the examples). This is clearly something to work on, because the technology already works. We also built a webservice, deployed it on the server to run under the XSP-webserver and called that from the Forms application we were developing, and it worked right away...

And then, at 13:00 sharp the final whistle blew...leave your keyboards and the room, gentlemen. The floor is for the jury now.

The long waiting for the judgement began, as teams are called in 1 by 1 to show their results to the jury (we were 7th in line...). But luckily there was food (litterally and for thought) enough to keep us busy. Discussions between teams started on 'did you build that' or 'how did you solve this'.

To be short about our own achievements, we did not build enough of the process to get a high score. But, because of our guts to do things completely different from the rest of the teams (see my previous blog for details), we 'won' the 'innovation prize': a set of mini-screwdrivers, because the jury felt there had to be some work done on the toolset we put together to get really competitive...

It was a lot of fun to attend, and we hope we can come back next year, possibly to defend our prize with another innovative, challenging development toolset.

 Our prize:

RADRACE 2006

Well, it has been some time I wrote stuff here...because I was preparing for the internal RADRACE 2006. RADRACE is a developers competition were you create a working application in just about 1 and a half day with a team of 2. You're free in your choice of 'weapons' for this battle, and, as the main stream in our company is Oracle, Java and Microsoft these are the most represented technologies.

Because I'm in the Microsoft Competence, Microsoft .NET is a logical choice. But I and my partner in crime, Rene Schrieken, who is also a blogger here, are always looking for that extra bit of experience. So last year we attended with a CTP version of Visual Studio 2005 and SQL Server 2005. It was a 2 day struggle with the development environment, climaxing Saturday morning when I discovered that the guys from Redmond had disabled the creation of identity columns in the release of SQL Server we took...

For this braveness, the jury gave us a complimentary reference...well better that than nothing. (in fact the competition had already enough teams so this was the only reason we could attend)

Having learned from that experience, we took another strategy this year, so we''ve chosen 'proven' technology: the Mono.NET framework 1.1 on Debian Linux with MySQL as database. I can say that during the preparations alone we already had a lot of fun, strolling the Internet in search for a useable toolstack to tackle the challenging problems of our upcoming assignment.

So, this morning at 8:30 sharp, the race began. We started with 10 teams, 3 Oracle teams, 3 Java teams and 4 Microsoft teams (including ourselves). We got the assigment (the job to do) from the organisation with an hour of explanation. Then at 9:30 we finally could hit our keyboards. I can say things are rolling, not always as fast as we like but we're reasonably steady going towards a working app...at least we are far enough to come back tomorrow (if you're too far behind the others, your race stops at day 1)

For the interested, here's our complete toolset (and hardware)

Hardware

- 1 desktop (acting as server and workstation 1) and 1 laptop (workstation 2) running Windows XP as host OS and Virtual PC

- 1 network switch

- 1 portable 160GB harddisk containing copies of all Virtual PC images plus lots samples and documentation

- a spare laptop in case of trouble

Software

1 Virtual PC image for the server containing:

- Debian Linux

- Apache2 (webserver, serving all our HTML documentation)

- MySQL 4.1 (relational database management system)

- Samba 3.20 (server for Windows file/printer sharing)

- Subversion (version control system)

- XSP (a standalone webserver from the ASP.NET examples for Mono, written in C#, hosting our webservices 'coz Apache2 does not do Mono yet on Debian, Apache 1.3 will)

- Postfix, Procmail and Courier IMAP and POP3 (mailserver)

2 Virtual PC images for the workstations containing each:

- Debian Linux

- Mono 1.1.10 (the implementation of the .NET 1.1 framework on Linux)

- MonoDevelop (IDE to create .NET applications)

- NHibernate (a port to .NET of the famous Java framework Hibernate for Object-Relational mapping, a.k.a. our business and data access layer)

- a starter application and mini-framework to get a quickstart, written by ourselves to get familiar with the Gtk graphics and NHibernate

- Subversion (client for subversion server)

- Meld (version control client application, for checkin, checkout, diffs etc of the Subversion system)

- Glade (a graphical user interface design tool, based on the Gtk/Gnome libraries / controls, stores the painted user interface in XML files, so we're actually having some kind of XAML already)

- KMail (email client, like Outlook)

- smbclient (to get to the Samba filesharing server)

- and on the host OS Microsoft Office (MS Access plus some VBA hacking of me to convert the supplied data into SQL scripts to create and fill the database), MSDN Help, Visual Studio 2003 (as the Mono debugger does not work quite yet)

See us 'in action':

First encounters of WWF

Recently I downloaded the Windows Workflow Foundation add-on for VS.2005 because I wondered what our Redmond friends had thought up here...

WWF is a framework full of classes and a visual designer to add workflow to your applications. It supports sequental workflows (the step-by-step kind) and state machine-like workflows.

I ran through some of the samples to see how it works. The samples don't get installed by setup, they are in a ZIP file in the folder wehre you installed the SDK (probably C:\Program Files\Microsoft SDKs\Windows Workflow Foundation); unzip them and go...

This is what you minimal do:

1. You design a workflow in the graphical designer. It comes with a toolbox full of workflow related shapes like all kinds of workflow steptypes (including calls out to web services of calls in from web services), connectors, if, while split and join flowcontrols, transaction context etc. From the design code is generated.

2. Create a simple application that creates a WorkflowRuntime object to run the workflow in.

    class Program
    {
        static AutoResetEvent waitHandle = new AutoResetEvent(false);

        static void Main()
        {
            // Start the engine.
            WorkflowRuntime workflowRuntime = new WorkflowRuntime();
            workflowRuntime.StartRuntime();

            // Load our schedule type.
            Type type = typeof(WhileAndParallelWorkflow);

            workflowRuntime.WorkflowCompleted += OnWorkflowCompletion;
            workflowRuntime.StartWorkflow(type);

            waitHandle.WaitOne();

            workflowRuntime.StopRuntime();
        }

        static void OnWorkflowCompletion(object sender, WorkflowCompletedEventArgs instance)
        {
            waitHandle.Set();
        }
    }

3. Compile and run

The samples show what techniques can be used, from simple step-by-step workflows to complexer stuff like eventsinks and methodinvokes and transactional workflows

Then I looked at the WorkflowMonitor application sample. It shows you which workflows you have runned, which activities these workflows performed and the grapical schema of the workflow if it can find the assembly in which the workflow is implemented.

Setting up this sample requires some extra work. The application used the out-of-the-box SqlTrackingService. You have to create a tracking database and run some scripts.

1. If you only have SQLExpress that came with Beta2 (like I have) there is no Query Analyzer. You can create the database with the Database Explorer of VS.2005. Remind that the SQLExpress instance is called (local)\SQLExpress.

2. To run the scripts, add a new stored procedure and copy the contents of tracking_schema.sql, tracking_logic.sql (both put by setup in the folder C:\WINDOWS\Microsoft.NET\Framework\v2.0.50215\Windows Workflow Foundation\SQL) and monitor_queries.sql (in the main folder of the WorkflowMonitor sample) into it. Then select the whole, rightclick in the stored procedure editor's pane and click run selected...

3. Open the WorkflowMonitor solution and build it

4. Open another sample

5. Add the following Settings (under Properties\Settings.settings)

6. Add the following line of code to the WorkflowRuntime instance

workflowRuntime.AddService(new SqlTrackingService(Settings.Default.ConnectionString));

This will enable use of the SqlTrackingService in this sample too.

7. Build the sample and cop the complete contents of bin\Debug to the bin\Debug folder of the WorkflowMonitor sample

8. Run the WorkflowMonitor sample (supply your SQL Server name when requested), click the Monitor button to start monitoring and start the other workflow sample.

The monitor will show the workflow runned, its activities and its design

Now what should WE do with this?

Well:

1. there are samples in which this stuff is used for UI workflow (like a process layer...), or

2. backoffice processes (like BizTalk does). It needs some more exploring on how this should be done.

3. because a workflow is run inside a WorkflowRuntime object (in most of the samples a simple console app), an application hosted under IIS to run them remotely could be a nice study project.

Adding the same features to multiple control types

Normally it's not a big issue having only single inheritance in the .NET languages. Unless you want to add a set of common features to the controls that Microsoft gives us...

I ran into this in a previous project where we rebuilt an existing application in .NET/C#. One of the features of this application was that controls like TextBox and ComboBox could have different colors depending on the state of certain data. For example: if it was a new entry some fields would have a green background to show that they were mandatory; others were yellow or white. As the state changed (i.e. fields were given a value), their controls switched colors too...

Well, you could of course code this into all Forms (yuck...that's no design), create your own control library (are you out of your mind?), convince your customer that this behavior is something you've never seen before and is impossible to build in .NET...or remember the days of VB6 and its 'inheritance' of classes.

In VB you could use the properties and methods of a class A in another class B by adding a member of type A in class B and make this one publicly visible with a property.

' Class A code

Private Sub Class_Initialize()
    ' Constructor of class A
End Sub

Private Sub Class_Terminate()
    ' Destructor of class A
End Sub

Public Sub CoolFeature()
    ' Do some cool stuff
End Sub

' Class B code

Private m_instanceOfA As ClassA

Private Sub Class_Initialize()
    ' Constructor of class B
    m_instanceOfA = New ClassA
End Sub

Private Sub Class_Terminate()
    ' Destructor of class B
End Sub

Public Property Get instanceOfA() As ClassA
    Set instanceOfA = m_instanceOfA
End Property

Then you could do things like Dim x as B and call x.instanceOfA.someFunctionOfA

' Application code

Sub Main()
    Dim b As ClassB
   
    Set b = New ClassB
   
    Call b.instanceOfA.CoolFeature
   
End Sub

With this in mind, the idea of Extension classes was born. An Extension class is responsible for implementing some common features. Further, you can inherit from an Extension class to extend it. It look a bit like a Decorator pattern (http://www.dofactory.com/Patterns/PatternDecorator.aspx), except that you don't create the Decorator classes yourself, but your derived control class does in its constructor.

I created a tree of Extension classes starting with:

• an abstract base class ExtensionBase as the root class with general properties and behavior (like storing a reference to the Control)
  • an Extension class for implementing common features for all control types (like setting colors, bordertype)
    • a TextExtension class derived for specific TextBox related features (like regular expression validation on leaving the control)
    • a CheckBoxExtension class to translate values coming from a datasource into check or unchecked state and back
    • a MenuExtension class for menu-like controls (we used an ExplorerBar control with expanding panels and clickable items to start tasks...like the XP UI)
    • and so on.

In the constructor of an Extension class the control is passed as Control type. The instance of the Extension class stores this reference internally in a private member. This way the Extension class instance can invoke methods and use properties of the control in which it sits as a member (well, most of the time you have to cast to the appropriate control class type to do that but why is the 'is' operator invented if you're not gonna use it...)

The controls we used were derived from the control class of the Framework to inherit the default behavior. They also got one or more Extension class members to add new behavior. Finally, by adding public properties and methods to the derived controls classes, the extra features were exposed publicly so that you can program something like

MyTextBox t = new MyTextBox(); t.SomeNewCoolFeature();

These properties and methods simple route to the Extension class member inside to do the job. Also, some events (like Validating) of the derived control classes were linked to a method on the Extension class to implement common behavior for them at 1 place.

Now why didn't I use the Framework's extension possibilities. There is an example which builds a HelpLabel control. Well, I looked at it and decided it would be too much work to do it that way, because your control class has to implement an interface and then the implementation of the extra features still sits in each control's implementation class. I could have put that in a normal class and route to that but what's the point of putting the interface on the control class then?

Tech-Ed 2005 day 5

The final day: I think the one with the highest session score

Starting with my first WinForms session WCD324 by Brian Noyes of IDesign.

Lots of demo's on new controls (menu's, DataGridView, BackgroundWorkerProcess). Databinding got a lot better, and got extensible by the INotifyPropertyChanged interface. The DataGridView is a combination of the DataGrid and ListView. Easy setup with designer, virtual mode for computed columns (fires an event per cell to set the value). Layout controls make us grow to the way you layout ASP pages (and Avalon in the future): just draw a table on your form and put controls into it. Also FlowLayout possible and a decent SplitContainer to replace the Splitter control that had its quirks when you put the controls in the wrong order on the Form. Also WinForms are easly localizable (property on the Form plus resources). And your get UserSettings (read an writeable) next to AppSettings. Strongly types classes are generated now for these configuration files so you can program like AppSettings.MySetting = some value instead of the ugly and error prone AppSettings["MySetting"] syntax

After that DEV466 on the new Source Control features of TeamSystem. A great step forward compared to Visual SourceSafe

• data stored in database
• web accessible
• multiple client platforms possible (demo of Linux based SourceGear's Allerton checking sources out, changing them and checkin)
• local cache for retrieved files
• diff tool extensibility
• checkin policies (on system, project, file)
• workitem integration: specify your Project Server task when checking out to get traceability of changes
• shelving: put your current work on a shelf, get a prevouis fileset, fix stuff, unshelve and go on
• delta file storage
• email checkin notification
• shared checkout and merging
• VS.2003 integration (RTM version only so not Beta2)
• NOT: keyword expansion, pinning and sharing, shadow folders

Just before lunch the ARC412 by Maarten Mullender on Designing for Concurrency. Maarten is not a CRUD lover and he explains why.

Design for concurrency is about reducing the risk and impacts of concurrent changes in your system's data. He uses the metaphor of Venetian Bankers who use a Journal to log all changes and then (at a later time) update accounts from the logged entries. This means that these recordings are not overwritten, the log just grows.

Some of his recommendations:

• Use a Journal Pattern in your design. Entries in the log must be identified uniquely, can have an expiry date, combine business related actions into a single document (there's the document centric desgin again), can be sent as request to a service, are never changed, just add corrections.
• Specify guarantees or expected behavoir (like an SLA or mortgage offer)
• Uniquely identify requests: to preserve double sending and handling of the same message
• Make sure your lies are qualified (compare with a local cache: how long is the data there still valid)

I just wonder why different speakers use this document centric approach. Last year at the smart client track I heard that Microsoft also sees a future for their Office products an UI to call services...is this their way to sell more Office licence in the future? By designing them into solutions...

We'll see next year at Tech-Ed 2006 I guess

After lunch the CTS440 session of Brian Noyes on Smart Client Offline Data Synchronisation waited. Nice story on what possiblities you have to solve these issues when working with offline data. Also a look into the Offline Building  Block of the Patterns and Practices group

Then the final CTS465 session by Christian Weyer on choosing your aproach to desing web services with .NET. Again a talk on how to avoid the pitfalls when you need to build interoperable services and a plead for the contract first design tactic. See the slides, I was tired of writing stuff down.

Tech-Ed 2005 day 3

Day 3 starts with CTS360: how to do asynchronous messaging (not so complicated according to presenter Clemens Vasters). Interesting presentation on how to combine webservices calls with MSMQ (no WSE)

Then CTS366: Indigo again, this time on Secure, Reliable, Transacted messaging. More on the configuration to get these things going by Steve Swartz and Ingo Rammer

As I do not have enough of this stuff, a CHT031 on the implications of Indigo in Service Oriented Architecturing. Well, more a quest what that A means in SOA and if it's there by purpose or just a salespoint. The end of the discussion got a bit more practical: whether enterprise wide datamodels were good or not (as with services we can get different views on presumably the same concepts: e.g. a customer has totally different properties according to the sales department than to the financials department)

After lunch ARC419: the greay area of implementing Services using OO technologies. Nice talk of Beat Schwegler on how things just might not be what you expect when building service oriented systems with object oriented tools / languages. Great examples on the consequenses of renaming parameters of a web method (breaks the generated contract if you did not use [XmlAttribute(...)] in the code to set these to a fixed name for the outside world!) and the different encoding standards that you can use for the SOAP message (use doc-literal and not rpc-literal /rpc-encoded like the Java world uses a lot if possible).

In the ARC mood to ARC313: Patterns for Service Oriented Architecture by Ron Jacobs. Great joke about Bill Gates...4 tenets revisited, then some things to watch out for:

• loosy-goosy: why you don't want flexible interfaces like QueryDB(sqlstatement, databasename) and ExecThis(cmd, args); question here is what is your contract (i.e. what is this service going to do for you and will that still be the same in 1 year)
• cruddy-interfaces: this leads to chatty interfaces, rpc-style of development, statefull interaction (a MoveNext() webservice on a previoulsy openend DataSet); and possibly methods that leave your data in an inconsistent state.

Well, what to do then?

• Encourage document centric thinking. A lot of business processes are about handling documents. So why not use that in our software...by defining request - response message schemas
• Define clear semantic in the contract (what do we mean by ...)
• Promote loose coupling by encapsulation of implementation: use no platform specific datatypes in the contract (Java does not know .NET System.Data.DataSet)
• Be easy to consume from any platform (use WS-I base profile)
• Generate objects from schema (XMLObject generator tool downloadable)
• Services should encapsulate a complete unit of work (avoid chatty interfaces)
• What about transactions: don't share distributed transactions, you surrender precious resources to possible untrusted parties
• Compensational actions are OK, but don't rely on the consumer to do these (be in control yourself)
• Use the reservation pattern

Finally I closed the day with CTS358 by Juval Lowy on System.Transactions

In the 1.0 / 1.1 Framework explicit transactions are most suitable for single objects in a single database. If you have multiple objects  and multiple databases, you're stuck with EnterpriseServices, DTC, object disposal at the end of the transaction and single-threading

The 2.0 Framework unifies the programming model. The developer does not have to choose, the Framework uses the apropriate technique withing the transaction's scope. So you create a TransactionScope object and within that do your transactional work. A try...catch around this block catches all errors (so not scattered around in different objects that are used within the transaction's scope).

Nesting of scopes is supported (directly so within a method, or indirectly so scattered over multiple objects), as is automatic enlistment (in case of transactions over multiple databases). The enlistment features only works for SQL2005...

A final thought of Juval was the use of the exensibility features here: you can define your own transactional datatypes. He showed us a transactional collection and array. Imagine the programming wealth you get when every datatypewould have a Rollback method to und changes...well, maybe in version 4.0 of the Framework.

Tech-Ed 2005 day 2

Day 2 starts with the first keynote: not as spectacular as last year (no african drum sessions) but real life situations comedy to point out Microsofts efforts to help companies doing their work more efficiently.

After that the ARC302 session about building and using software factories: you can extend Visual Studio 2005 the make the developer's work easier by providing guidance and code generation tools. Impressive, but needs some thinking before you start your project. We knew that already from the Rational environment in Resu!t. Setup your project first, then start working.

Then the CTS349 session about Beyond WSE: what the wizard doesn't do for you but needs to be done. Understanding the configuration settings when you're using Web Services Enhancements. See her blog on www.dasblonde.net

Well, I'm getting in the mood with CTS265: Address, Binding and Contract: the ABC of Indigo endpoint configuration. The configuration part of the ODBC for using services (as I like to think of Indigo). The Indigo programming model simplifies the usage of the diverse techniques that Microsoft offers today for doing remote procedure calling and stuff like that: web services, .NET remoting, EnterpriseServices (a.k.a. COM/DCOM from .NET) and MSMQ. In your code you only use the Indigo classes, your configuration describes the technique to use and the framework uses that.

Finally DAT331: report auditing with Reporting Designer. A 1 hour demo of this tool, which will be usable without the complete Visual Studio environment to create reports with Reporting Services. Forget the slides, they'll show only the presenters info and DEMO a couple of times.

Tech-Ed 2005 day 4

This time a relaxed start with SRV400 about what Windows is doing while Task Manager shows 100% Idle process time. Interesting talk by David Solomon of SysInternals on how to find your where Windows spends your precious time mainly using their ProcesExplorer tool.

Then WEB410 on Asynchronous Pages. New classes like PageAsyncTask help you to develop asynchronous working web pages; good code examples at http://blogs.msdn.com/dmitryr

After that CTS354 on some daily life problems that we as developers have to solve and what techniques Microsoft has to tackle them. Nice roleplay between the supposed speaker and a figurant from the audience (who turned out to be his boss).

Again the contract first instead of code first tactic was mentioned to avoid interoperability problems (use no platform specific types)

Examples of how to send attachments over webservices, reliable messaging and integration. Live demo on VS.NET built application that integrated with mainframe application (3rd party tool OnWeb of NetManage)

After lunch the long awaited ARC411 session on the Domain Specific Language tools to do model driven development in VS.2005

VS.2005 is extensible in that you can create your own grahpical designers (like the Architecture and Class Designers) to automate your development process. You define your domain model, shapes, connectors and a mapping between model and shapes. Then you just generate the designer (code) and build it. With the designer you generate artifacts like code, reports etc. This is done by adding script to parts of the model in an ASP-like language <#some code#>. This is done with the DSL tools

The team has still a TODO list:

• add model data access
• add model validation
• add UI & designer behavior
• add custom XML serialization
• add richer designer for models, notation and mapping
• add multiple views and multiple models (currently 1 view and 1 model so 1 artifact file)
• add designer deployment support

These tools are available at http://lab.msdn.microsoft.com/teamsystem/workshop/dsltools. Sure we will see more of these guys.

I skipped the 2nd keynote to do a handson lab with the DSL tools. Unluckily I got the bugs when generating the designer code so it would not build.

Finally thwe CTS449 on BizTalk 2004 and Indigo. Morten Abrahamsen and his team built a BizTalk adapter in VS.2003 that uses the Indigo programming style to do messaging. First an introduction on when to use Indigo (transport independency, extensibility) or BizTalk (brokering intermediary, orchestration). The challenge was to design the adapter in VS.2003 and the BizTalk Adapter Framework (toolkit for VS.2003) and run with the 2.0 Framework. There is a deployment issue: because it's a .NET built extension is uses a XML config file for it's setting while BizTalk stores it's configuration in SQL Server.

Heavy talk at the end of yet another long day, so a lot of people left the session be fore the end to go to the Tech-Ed party. The code is available on GotDotNet

Tech-Ed 2005 preconference

This year I was lucky to visit Tech-Ed the full 5 days so I want to used this blog to share some of the stuff I've been to (and through...)

My preconference day track was about ASP.NET 2.0. Keywords were zero code and extensibility. The Redmond guys made things even simpler (less coding, more configuring) and extensible to suit your own needs.

Seven hours of new ASP.NET stuff in a nutshell:

• new code behind model (classes get separated into different files so you don't see the generated code anymore)
• autocompile everything (just drop files into the right solution folder)
• precompile and deploy without source
• declarative databinding (no code)
• define datasources (5 types), connect controls to them, binding of own objects made easier, 2-way binding
• datasources support caching, less server roundtrips
• enhanced controls (GridView and others)
• master pages for standard page layout
• easier security through membership service and supporting controls, extensible
• role based security out of the box, stored in SQL Server 2005 or other datastore
• easier profiling, stores per-user data persistently
• easier localization, set the (UI)Culture at the @Page directive, global and local resources in solution folders, controls support localization
• easier site navigation with TreeView, Menu, SiteMap controls and classes, XML-controlled
• easier configuration with ASP.NET WebConfigurationManager
• build health monitoring tools by catching web events
• SharePoint webpart integration in your webapplications
• advanced features like asynchronous pages, client callback manager

About me

My first interest in computers came when the shops nearby my school started to show and sell home computers. Machines like the Sinclair ZX-80, Atari 400/600/800 and Commodore's with an amazing memory size of 4, 8 or maybe 16 KB (that's no typo). You had to use some BASIC-slang to get them doing things you wanted.

A little crowd of 'wizkidds' used their lunchbreak to show the shopping masses their latest hacks...So I went to the library to get some books on this computer programming and soon I was one of them. The sales people liked the attention we created, so most of the time we used the color / graphics capabilities of the little machines. The ideas of 'doing something with computers' was born...

When I went to college I bought my first PC. I learned the craft of writing software in Pascal and C (and some odd languages like LISP, Prolog and Simula) besides a lot of theory on datamodelling, building compilers and formal methods to prove the rightness of code.

After that, my first job was at a little company that sold hardware and developed document imaging systems. There I learned to play almost all roles in software development (because projects we mostly 1 man resourced). After 3 years of developing in Clipper, C and Pascal, I thought it was time to move on and came across this company named CMG...

There I spent my time developing more systems, again in Clipper, but soon MS-Access, SQLWindows, Visual Basic and C, and for the last years in C#/.NET with databases like SQL Server and Oracle.

Nowadays I'm a lead developer / software architect in the Microsoft Competence team of Public Sector.

My credo's in this job are: software should be maintainable (by all types of developers), should do what the customer wants and should be made within time and budget. I am a strong believer of tight user / developer interaction and early prototypes to get feedback and create acceptance for the end product and being pragmatic about things. If we want to write software in 5 or 10 years from now, we must learn to do that in the most efficient way and leave all the re-invent-the-wheel stuff to people's spare time. Therefore I'm interested in software development practices and pragmatic software architecturing.

Or to speak with my first company manager's slogan: we do the right things first and we do the things first time right.

Some thoughts on web-design

This year at Tech-Ed, I visited the pre-conference track on ASP.NET 2.0. I 'd read already on various MSDN pages about the great improvements that our Redmond friends were up to, but I think they've done a great job here. I'm not a web-developer pur-sang (since my roots are at the WinForms application development) but the 2 keywords that stuck were: zero-code and extensibility.

Finally we can easy add navigation to our web-applications, set global page layout much easier with master pages, put some security to our applications and off we go...and a lot of this stuff is customizable with properties and designers.

With that in mind I stumbled around the Internet this weekend and came across these nice sites about web-design:

http://www.adampolselli.com and http://www.simplebits.com

They are not in any way Microsoft adepts but I liked the ideas presented, especially the colour trends and style types. So maybe my next ASP.NET project will use some of the things I found here.

PS: I've used the minitabs idea of simplebits to hack this blog's style a bit...