admin

Until recently, when I moved house, I had a Raku kiln in my back yard (well, actually more of a neglected savannah). Raku originated in Japan in the late 16th Century, but has become adopted and popularised in the West. One of the exciting glaze techniques in Raku is reduction, where hot (as in 900+ C) fired oxide glazed ceramics are removed straight from the kiln and placed into a reducing environment (i.e. little or no oxygen) such as paper or sawdust, often in a sealed metal bin.

It can sometimes be a little disappointing, when after a couple of hours of cooling, you extract an all black pot, but sometimes the effects are marvelous, in all the hues you can imagine. The other source of excitement is being engulfed in flames from head to toe (we do wear appropriate safety equipment, such as casting gloves, splash screen masks and organo-metal filtered breathing masks. Also, always wear all cotton clothes, never anything made from synthetic materials).

I promised Joanna I would post a link to her (almost finished) site (that web site designer is so slack!), so here it is: Joanna Wakefield Ceramics.

The C# 3.0 language enhancements are part of the LINQ project, whose aim is to make working with data as easy as working with objects. This will be a major evolutionary step forward in Microsoft’s development landscape (John Lam’s recent addition to the Microsoft stable could also be seen as a push in this direction). LINQ provides a single, general purpose declarative query functionality that can be applied to in-memory and persisted data. These new language features are:

• Implicitly typed local variables whose type can to be inferred from the expressions used to initialize them.
• Extension methods enable additional methods to be added to existing types.
• Lambda expressions are a new form of anonymous methods that provide improved type inference and conversions to delegate types and expression trees.
• Expression trees, which permit lambda expressions to be represented as data (expression trees) instead of code (delegates).
• Object and collection initializers combine creation and initialization into a single step, allowing values to be specified for fields or properties for newly created objects.
• Anonymous types, which are tuple types automatically inferred and created from object initializers.
• Query expressions provide a language-integrated syntax for queries similar to relational and hierarchical query languages such as SQL and XQuery. This provides compile time checking of queried types, rather than at runtime. A definite productivity boost.

A great way to find out about the enhancements in C# 3.0, is to download the LINQ preview and to work through the short tutorials, which showcase all of the additions listed above. NOTE: I suggest you run up a VPC image, as LINQ does not yet have a Go Live license available. You can download BLINQ here.

I’ll explore some examples of these new language features in a couple of subsequent posts.

References:
Hands-On Lab: Lab Manual: C# 3.0 Language Enhancements

This gem comes from one of Scott Hanselman’s bosses:

Don’t let clients/users dictate the solution with their statement of the problem.

Or to put it a slightly different way:

When someone asks you to solve a problem, first discover the real problem they want solving.

Professional Visual Studio 2005, Andrew Parsons and Nick Randolph. WROX

This book is aimed at developers who are new to Visual Studio, and those with some exposure to it. It attempts to cover a large number of topics and features, and it does that admirably. It contains 56 chapters, spanning approximately 870 pages. This means that the coverage will not be quite as in-depth as other books on similar topics. For instance, compare with Apress’s PRO ASP.NET 2.0 which is longer by almost 400 pages and just 34 chapters. The source code for the examples in the book can be downloaded online.

It’s rather extensive breadth means that some of the chapters are a bit short; for instance Chapter 28 on Assembly Signing is just 3 pages long. In one or two places, I would have preferred slightly less breadth and a little more depth. Some of the chapters should have either been condensed into other sections or removed completely.

There is one omission in Chapter 4. This chapter provides a good introduction to the various kinds of projects available, but does not cover the ‘new’ Web Application Projects. This was due to the timing of the book’s completion and publication. Web Application projects are a freely downloadable add-in and will be included in Visual Studio 2005 Service Pack 1 in the very near future. They have been around for some time, and are in use around 50/50 compared with Web Site projects. They are essential for enterprise development of web sites. Another restriction of Web Site projects is that you can not use them with TSFS, as they do not have a permanent solution file.

There are a couple of places where screenshots might be confusing, such as Figure 51-3 on pg 728, because the correct line (aspnet_wp.exe) is not highlighted. There are also several sections with perhaps too many screenshots, such as pages 30-33.

The sort of coverage I would have liked to see expanded upon would have been best practices using the IDE and some worked examples. Since this book is aimed at newcomers, I think it could have contained more process based advice rather than just explaining what features are available. Even experienced developers moving from other environments would benefit greatly from advice showing ‘best practice’ ways of organising projects and solutions.

In conclusion: If you are new to Visual Studio 2005 and want to whet your appetite with a book that covers a great number of the available features, this book is worth reading. If you are already an experienced developer, you may pick up one or two gems, but the majority of the material will probably be familiar to you. I do not think this is a book you will read cover to cover, but rather dip into as and when you come across a certain feature and want to explore it a little further.

Disclaimer: I know one of the authors, Nick Randolph, personally (Nick has been the main organiser of the Perth .Net UG until his recent journey to New Zealand). I borrowed a copy of the book from the User Group library, as Nick had kindly donated a copy. Use of the library is free to User Group members, which is just one reason to join and participate.

One thing I noticed was the book states (pg xxxix) that the minimum requirement to use the book is VS 2005 PRO but I did find just one feature that requires VSTS. I’ll leave finding it as an exercise for the reader!

Sometimes the seemingly simplest problems set you seething. Today I wasted at least 30 minutes trying to discover the reason why, when I clicked on a web page file download link, it would automatically download the file and open it without giving me the option to save it.
If you’ve worked in any kind of support role, you will have heard this many times: I hadn’t changed anything! At least knowingly. At first I blamed IE (the universal scape goat!).

A few days ago downloads went off with a bang everytime, today the touch paper was fizzling and going out! I’m sure I didn’t change anything… It’s times like these, you realise how frustrating technology must be to someone who is not computer literate.

I could have fired up FileMon to find where it was temporarily storing the file, but this seemed the wrong answer. The answer in the end was very simple, but I still have no idea why it had changed…):

1. Open Windows Explorer
2. On the Tools menu, click Options
3. On the File Types tab, select the appropriate file type in the Registered File Types list
4. Click the Advanced button and ensure the “Confirm open after download” checkbox is ticked
5. Click OK, and then OK again
6. Repeat for any other offending file types

If you are creating a new application with a clean slate, please don’t do what a developer I had first hand experience with did. This is the sort of material I would expect to find on the daily WTF!

Warning! Coding Horror follows. Don’t do this!

1) Ridicule code generation saying it won’t work, and that no one is using it anywhere. Reject the fact that several industry luminaries with great architectural experience have designed excellent code generated frameworks. Don’t generate anything. Do it all by cut and paste. Write your stored procedures by hand, despite the fact that 90% of them have a similar structure.
2) Design and implement your own less than optimal scheme for a data access layer and business logic layer, despite the fact that a quick internet search and a few hours reading would quickly show you the gaps in your knowledge. When I say less than optimal, what exactly do I mean? How about using reflection between your data access and business logic layer! Oh and while you’re at it, for good measure create your own non industry standard nomenclature, just to make it more confusing.
3) Ignore advice on inheriting from BindingList instead of List; plus completely ignore the fact that you probably will want to implement an event driven model for your object classes.
4) Create Load methods that can take different types of keys (think table primary key and rowids in Oracle). Pass one type of identifier to some methods, and the alternative to others.
5) When challenged to justify your design decisions say you did it that way in C++!
6) I could continue, but I think you get the idea…

You should definitely consider one of the many good tools already available for generating DALs and BLL stubs. Several are free, such as CSLA by Rockford Lhotka (buy the book, it’s a sound investment), MyGen, NetTiers 2.0 (although you will probably need to buy CodeSmith). Others require you to part with money such as the (IMO, poorly named) LLBLGEN Pro which has a stack of ORM features, and Wilson OR Mapper to name but a few.

I’ve spoken to one or two people recently who were amazed that someone with 10+ years of experience could do something like this, which is the reason I decided to post. It all comes back to Ego. The better programmers are usually the ones with the smallest egos. OK, I feel better having got that off my chest!

I’m being a little slack this evening with nothing but on-posts: Charles Sterling has posted that Office 2007 has been released to manufacturing. The official launch site is here.

Saw this via David Haydn‘s blog: Red-Gate’s SQL Refactor. I know a few companies that could use one or two licenses of this management studio add-in! David’s post shows a quick clean-up of a stored procedure.

OK this is probably old news by now but the .NET Framework 3.0 has shipped.

Kathy Sierra recently posted a simply brilliant article on the subject of modern learning. I think this quote from Jason Fried sums up my belief:

“Hire curious people. Even if they don’t have the exact skill set you want,
curious, passionate people can learn anything.”