Site Sections
Posts
114
Comments
126
Trackbacks
10
August 2010 Entries
Windows Phone 7 Boot Camps

Columbus, OH
September 7

Waukesha, WI
September 14

Grand Rapids, MI
September 14

Little Rock, AR
September 15

Cleveland, OH
September 15

St. Louis, MO
September 16

Downers Grove, IL
September 21

Southfield, MI
September 21

Austin, TX
September 22

Chicago, IL
September 23

Des Moines, IA
September 23

Tulsa, OK
September 28

Memphis, TN
September 29

Houston, TX
September 30

Knoxville, TN
September 30
Technorati Tags: ,

 

I'm registered for the St. Louis boot camp on September 16th.

The boot camps are free day-long events. Here's the overview from the registration page:

Join us for a day of Windows Phone 7 hands-on training. You’ll learn how to build Silverlight-based applications that take advantage of the many Windows Phone 7 platform features.

We’ll introduce all the basic concepts required to get started building Silverlight applications including the Windows Phone 7 platform and frameworks as well as the designer and developer tools. We’ll also cover the process for submitting your application or game to the Windows Phone 7 Marketplace. Bring your laptop! Topics covered will be reinforced with an opportunity to explore hands-on-labs using your own laptop. Windows Phone 7 experts will be on hand to help you explore Windows Phone 7 development.

If you're not lucky enough to live in "the heartland", there are also similar Windows Phone 7 "Firestarter" and "Garage" events in the eastern US.

(I assume there are also "Windows Phone 7 SomeOtherMetaphor" events in the Mountain and Pacific US time zones, but I haven't heard about them.)
Posted On Friday, August 27, 2010 9:12 PM | Comments (0)
Careful with those comment images, Subtext
image

I don't know how the images used for comments are generated, and assume it's semi-random, but I would prefer not to have swastikas on my blog.

Posted On Thursday, August 26, 2010 6:20 AM | Comments (1)
LightSwitch is a golf cart?

I was listening to the latest episode of the CodeCast podcast this morning, featuring Microsoft's Jay Schmelzer talking about Visual Studio LightSwitch.

Host Ken Levy made an interesting analogy for the future choice whether to use LightSwitch or Visual Studio:

"Have you ever been to Palm Springs? It's an interesting place because a lot of times you'll see people in golf carts driving around - not just on the golf course - on the street. If someone needs to go from Palm Springs to LA, they need a car. But if you're just putting around the neighborhood, this golf cart where all you do is put your foot on the pedal and steer - that's all you need - It works, right? Most people have both a car and a golf cart in the garage, and they pick which one they need to use."

Now, I haven't seen LightSwitch yet, and I hate it when people form an opinion about something they haven't seen, but…

It concerns me when I read articles like this, and see quotes like:

It’s a tool that relies on pre-built templates to make building applications easier for non-professional programmers.

…or…

Microsoft’s idea is that LightSwitch users will be able to “hand off their apps to professional Visual Studio developers to carry them forward,” when and if needed.

I've been on the receiving end of that handoff way too many times, with Access or Excel "applications" that started with the idea that they would be simple golf carts:

golf cart

…but they bolt on a feature here and there, trying for this:

limo-cart-2

…and by the time they admit they're in over their heads and call in a professional, the "hand off" looks like this:

overloaded-golf-cart

I hope LightSwitch will automate things enough to help the "non-professional programmers" fall into the "pit of success", but I also hope Microsoft understands why professional developers view initiatives like this with trepidation.

Posted On Saturday, August 21, 2010 11:16 PM | Comments (7)
The MoSCoW Method

You can learn a lot in 140 characters (if you follow the right people).

2954825978_92e28a4c89

@skimedic(Phil Japikse), tweeting from the Cincinnati Day of Agile this morning, mentioned MOSCOW.

I was unfamiliar with that mnemonic, so I had to look it up on Wikipedia.

It's a requirement prioritization technique, and the letters stand for:

  • M - MUST have this.
  • S - SHOULD have this if at all possible.
  • C - COULD have this if it does not affect anything else.
  • W - WON'T have this time but WOULD like in the future

Speaking of Phil, I'm looking forward to seeing him at the St. Louis Day of .NET next week.

Phil, I don't know if you're a big Reds fan, but if so, this is not a good time to make a lot of noise about that in St. Louis. (And please don't wear spikes. We don't want anybody to get hurt ;)

Posted On Saturday, August 14, 2010 11:16 AM | Comments (0)
C# in Depth, Second Edition
Technorati Tags: ,,

 

SkeetShirt

I'm really looking forward to the second edition of Jon Skeet's C# in Depth book, which should be printed in September.

I took advantage of this "SkeetTweet" from yesterday:

45% off C# in Depth 2nd edition (http://manning.com/skeet2) - use coupon msa1145 at checkout. Valid until August 17th.

…to pre-order the printed book, plus "Manning Early Access Program" access to PDFs of chapters from the work-in-progress, plus a PDF copy of the complete first edition, all for just about 32 bucks!

(If you're not already, I strongly suggest that you follow @ManningBooks on Twitter. They're putting out the best development books, in my opinion, and they announce discount codes every day.)

 

Here's my review from last September of the first edition of the book…

C# in Depth is not for beginners. It assumes a working knowledge of C# 1.0, and is not so much a tutorial of C# 2 and 3 features as an in-depth examination of how and why they work.

I don’t think I learned anything I didn’t know about using generics, extension methods, delegates, anonymous methods and lambdas, but Skeet does a great job of zooming in on the inner workings of each of these features, building up to the big picture of how they all snap together to make the game-changing programming paradigm that is LINQ. It’s like a DVD of your favorite movie with behind-the-scenes features that show how the cool special effects were created.

When he says “in depth”, he’s not kidding. After re-emerging from the Marianas Trench level examination of expression trees to the C# surface level discussion of LINQ, I got a case of “the bends”.

The book reminds me of Silverlight “Deep Zoom”. As we zoom in and out between high-level syntax descriptions to low-level minutiae, everything is always kept in sharp focus, thanks to the considerable skills of the author.

I understand Jon Skeet is hard at work on updates to the book for C#4. When that comes out, I wish there would be a free upgrade to the book that I could download (I don’t think that’s going to happen ;) ), but that’s one book that I’m sure will be well worth the price.

If you’re serious about C#, “C# in Depth” is a must-read.

Posted On Saturday, August 14, 2010 10:04 AM | Comments (0)
INotifyPropertyChanged with less code using Expressions

 

Parts 1 & 2 of this unintended trilogy:

My previous post elicited a couple of good comments.

Matt noted that my use of reflection to get the property name could be a problem in due to inlining in Release  mode:

Jérôme and Mark suggested that an Expression might be a better solution than reflection. Here's what that could look like:

My shared method to update property backing variables and raise the INotifyPropertyChanged.PropertyChanged event:

protected bool CheckForPropertyChange<T>(T value, ref T currentValue, Expression<Func<T>> expr)
{
    if (value.Equals(currentValue)) return false;
 
    currentValue = value;
 
    if (PropertyChanged != null)
    {
        var body = expr.Body as MemberExpression;
        if (body != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(body.Member.Name));
        }
    }
 
    return true;
}

...and properties using it:

private string _CustomerName;
public string CustomerName
{
    get { return _CustomerName; }
    set { CheckForPropertyChange(value, ref _CustomerName, ()=> CustomerName); }
}
 
private string _PhoneNumber;
public string PhoneNumber
{
    get { return _PhoneNumber; }
    set { CheckForPropertyChange(value, ref _PhoneNumber, () => PhoneNumber); }
}

Using the lambda (e.g. "() => CustomerName") to specify the property name is an improvement over a hardcoded string because the compiler validates it and it's "refactorable". As Jérôme pointed out on his blog, the lambda is not actually called, just used by the CheckForPropertyChange method to determine the property name.

Posted On Monday, August 2, 2010 8:17 PM | Comments (2)
Archives
Post Categories
Links
Twitter










Tag Cloud