DevScape

Book Review: Introducing HTML5 by Bruce Lawson and Remy Sharp

2011-08-24T20:40:00.001-07:00

The buzz in the development world these days has changed. Cloud Computing? That’s so 2010. Multi-core CPU’s? Ho-hum. Tablet computing? Whatever.

But when Microsoft announced that the next version of Windows would allow for development in HTML5 and JavaScript, the world took notice, and a lot of us are scrambling to get up to speed. Okay, so some developers have been playing with HTML5 for a while now, and JavaScript has been around for years. I’ve worked in HTML4 for quite a while, and JavaScript has never really floated my boat. I’m a traditionalist. Code compiles. Scripts are what I use to run back in college before I had a real IDE.

I say that with only a little bit of sarcasm. I’ve never liked Web UI coding. Working with the infinite number of browsers and their individual peculiarities frustrated the crap out of me. The web was for signing people up for things, watching videos and browsing news and sports. You would never write a real application in this environment. Would you? What masochistic developer would want to build a core business system in something you could never truly test, and would behave differently on every computer? What sadistic system designer would expect users who have jobs to do to wait for a page to refresh every time they wanted to know if their data was valid?

When I heard about Microsoft’s intentions, my initial reaction was to think it was a joke. After hearing it a few times, and learning it really was true, my heart skipped a beat. I was worried that I was about to be left behind again technically, and in a few years, I’d be one of those back-end developers that couldn’t change with the time. I’d be branded as a ‘.NET Developer’, something akin to the 2011 version of a COBOL programmer. It didn’t take long for that fear to turn to anger. I’d just invested the last five years working my way deep into the Microsoft .NET Stack, building my skills and my reputation, and… and it just wasn’t fair! This whole process was very similar to the seven stages of grief. I went through the depression of realizing that I was again going to have to rebrand myself and rebuild my skills, and then the realization that doing it the last time really hadn’t been that bad. I started to look at the opportunities this would present – things that I had never before been able to do, that I could now do. I started to research what HTML5 really was, and what it was that made the world so sure this was the way to go.

After doing some piecemeal research on the web, I realized I needed a book. I’m a book learning. Reading a book primes my brain. Books are generally better organized than the snippets you might find on line. I wanted to start with the basics, and form a solid base with which I could talk intelligently with my coworkers and my bosses. I wanted a book that would explain it from the beginning.

Introducing HTML5 (First Edition) by Bruce Lawson and Remy Sharp was the book I chose to get me there, and I highly recommend it. It starts by covering the Structural Elements of HTML5, how pages are organized, the new elements and the expanded role of JavaScript in HTML5 applications. It then dives into some of the more advanced features of HTML, including Audio and Video, Canvas, Data Storage, Offline mode, Drag and Drop, Geo-Location and Messaging. I skimmed the Audio and Video and the Canvas sections since I am usually designing business apps, and haven’t had the need to build an app that draws lines since I was in college. I did, however, build a Silverlight Video player on Windows Azure for Microsoft Demo Showcase back in 2009/2010, so I expect that sooner or later, I’ll be doing something similar to that in HTML5. It’s good to know it’s there.

I was fascinated by the offline storage possibilities and the future of messaging and sockets. I can see a day coming very soon where I build an HTML5 app with messaging tied to the service bus on Windows Azure that handles Windows Workflow Processes and notifies users that some long running, multiple streamed process has completed. There’s power there. A lot of it.

I do find it a little bit funny that this is the second technical book in a row I’ve read where the authors are constantly taking shots at Microsoft and Internet Explorer. I guess I’ve been buried so deep in the mother-ship for so long, that I don’t have the same level of animosity. Of course, I have worked my career around not having to do a lot of browser work. Perhaps that has insulated me far more than I thought.

This book is short and to the point, and a great introduction to HTML5. You won’t come out a world class expert on HTML5, but you will understand the basic concepts, enough to be able to talk about it, and to begin the honest discussion of whether or not that next project you are starting should target HTML5. I’m at least willing to consider it at this point, as long as we don’t implement any features that can’t be made backwards compatible by implementing modernizr.js which is covered by Scott Guthrie here.

The biggest advantage I see to HTML5 is that in the ideal world going forward, we can build an app once, and as long as it is HTML5 compliant, it should just work on all browsers. I really like that. I want to do the work once, and move on the next project. HTML5 brings the Web UI development out of the dark ages, and makes it a real possibility for someone like me. This is a good book to get up and running inside of a week, and I’ve already recommended it to my team.

Book Review: jQuery in Action

2011-07-30T09:05:00.001-07:00

A few years ago, when I first got into ASP.NET development, I worked on a project that used the Ajax Controls Toolkit. I was not a JavaScript person, and my experience with the Toolkit and all its idiosyncrasies left a very bitter taste in my mouth for ‘client-side’ web development. For many of the projects after that, I worked on the back end of the system – the database, data model and business logic, and eventually the controllers and web services. We had a UI guy who tackled the JavaScript stuff and worked ‘magic’ there.

A couple of months ago, I got involved in a project which had a very large existing code base, with a lot of jQuery and my UI guy was nowhere to be found. Before I knew it, I was neck deep in it, and drowning fast. I muddled through the project and got it out the door, but I realized that I could no longer have this gap in my education. I also realized, by working on that existing code base, that jQuery was nothing like the JavaScript and Toolkit I once struggled with, and it was really freaking powerful.

It turns out that back in early 2010, I had ordered jQuery In Action by Bear Bibeault and Yehuda Katz during some book buying binge, but never read it. It got loaned out to a couple of people at work, and I didn’t see it for the longest time. It wasn’t until I finished working on that big jQuery project that I even remembered that I still had it. I tracked it down, and it flew to the top of my reading list.

I wish I had read this book a three years ago. jQuery is really powerful. And it’s really big. jQuery in Action did a great job of introducing me to the core concepts, and giving me a refresher on basic JavaScript. Ok, not a refresher – an introduction. The unfortunate part is that I ordered this book in early 2010, which meant the version I have is the first edition published in 2008. The second edition came out in May 2010. The first edition covered up to jQuery 1.2. The second edition covers jQuery 1.4. As I recall, there are some fairly major differences in jQuery between 1.2 and 1.4, but more importantly, there have been major changes in browsers. Internet Explorer was just on Version 7 when the book was written, and a lot of time had to be spent by developers to account for the way IE6 worked, and to a slightly lesser extent, IE7. With IE9 now out and promising “It just works”, I would like to think that jQuery will have gotten even easier in the last few years. The first edition of jQuery in Action has quite a few asides that detail the frustrations developers had with IE6 & 7, and I get the impression that the authors would have little good to say about Internet Explorer in conversation.

The book is well organized and the coverage of the core concepts appropriate for a beginning jQuery developer as long as you have a solid background in web development. It even has a very good appendix on JavaScript, which was invaluable to someone like me with a large gap in their knowledge of the subject. They build a large number of exercises into the book as well. Since I was reading the book whilst commuting, I didn’t get a chance to try them, but I think I understood them well enough from the written copy. At the very least, I know they are out there and I can download them when I get a chance to give them a try.

What I find amazing about this book (and jQuery), is how many times I thought back to projects I already have in production, and said “Wow, the UI could be so much better”, or “If I had only known about jQuery, the whole architecture would have changed.” The former makes me happy that I can now say “Yes, we can do that.” more often to clients. The latter makes me question my skills as a software architect. I had never even considered some of the approaches presented in the book, and not only would the UI have been more user friendly, it would have been faster and more reliable. I’m disappointed in myself for not taking the time to learn about jQuery before now. I can rationalize all I want about being busy with other things (like learning Windows Azure, MVC, WPF, writing 4 books, etc.) but the truth is that I considered the UI side to be the ‘poofy’ stuff and let other people handle it. The UI, I thought, was just for displaying the results of all the ‘hard work’ done on the back end.

No longer. Reading jQuery in Action has opened my eyes to the fact that I have to know all the layers, at least well enough to know what is possible. I have no doubt that there will be aspects (especially in CSS) that require an artist’s touch (which no amount of reading is going to give me), but I will now treat jQuery as a first class language in solving client problems. I still have qualms about jQuery, mainly from the testability standpoint, but I do like the idea of unobtrusive JavaScript which will allow me to keep a separation of concerns and allow me to build up a personal collection of functions that I trust just work.

I will, at some point, go out and get the second edition of this book to see what has changed in the last few years, and to reinforce my basic knowledge of JavaScript and jQuery. With HTML 5 and JavaScript coming at developers like an out of control freight train, jQuery in Action is a great way to get started and to get up to speed.

Using etc/Hosts to Assist in Testing

2011-07-19T11:20:00.001-07:00

A coworker and I were in the process of migrating a client’s web server from old hardware to new hardware last week, and we needed to be able to test the system before turning it on to live traffic. The web applications called web services, and the configuration of the web app included the URL for the web services.

We needed to be careful what we were doing here, because the web services were also migrating to a new server, and on this new server, were pointing to a new database server as well. We didn’t want to change all the configuration settings on the new servers, and we couldn’t change the public DNS entry.

I’ve done this before, but not everyone knows about the following trick, so here it is:

On Windows, if you go into your %WinDir%\System32\drivers\etc directory, you’ll find a file called hosts, often referred to as “etc\hosts” or “Etsy Hosts”. Open this file with notepad running as administrator on your machine. The instructions for changing this file are right in there, and it’s pretty easy. We added a new line to file on the new server, (and on the test client) like:

127.0.0.1 www.palador.com

We saved our changes, and then restarted IIS on the box. And presto…

But it didn’t work.

We reset IIS again, and did an ipconfig /flushdns from the command prompt.

And it still pointed to the old domain.

We went back to the Hosts file and everything looked fine. I scratched my head. Then I realized that we had forgotten to put a carriage return after the new line. We added the hard-return, restarted IIS and flushed DNS, and now everything worked.

I’m pretty sure I had run into this exact same issue a few years ago, and that’s why I knew to look for it. Hopefully this will help someone else avoid this issue.

Book Review: The Nomadic Developer by Aaron Erickson

2011-07-17T20:46:00.001-07:00

I don’t actually remember how I found this book. It somehow got onto my Amazon wish list one day, and it was one of those things I bought because I needed to top up an order above $25 to qualify for free shipping. I don’t remember what it was that I bought with this book, but I doubt it was as impressive as The Nomadic Developer.

It’s funny, because I tell people that I got into the consulting world back in 2008. After reading this book, I realized that I actually started in consulting back in 1994. My very first job in IT was technically at a consulting firm, albeit a very large one, (the one started by Ross Perot back in the sixties and famous for making everyone wear blue suits everywhere they went). I worked on a couple of very large accounts, so it seemed like I was just a developer in Corporate IT, but in reality, I was a consultant. I left that company in 1999, and moved on to real Corporate IT, working for an airline maintaining their revenue management systems, and later on to building and maintaining the fight operations systems. We owned those systems from cradle to grave, twenty four hours a day, seven days a week. They were horribly difficult to change. There was a tremendous amount of tribal knowledge in every subsystem, and many were already five or six years old when I started, and rewrites were impossible. By the end of my 8.5 years there, my technological skills were atrophied to the point where another year or two, and I would have been completely unmarketable outside of that industry vertical.

I jumped (back) into consulting in 2008 with little idea of what true consulting was. I wish I had had this book at my disposal back then. Not that I would change my decision – the leap into consulting has done wonders for my skills and my career. I have no doubt that making the move, when I did, was absolutely the right decision for both me and my family, and I’d like to think it was the right decision for the company I work for as well.

But in The Nomadic Developer, Aaron Erickson goes into wonderful detail of what to really expect from technology consulting, how to identify good (and bad) companies, how to survive, and how to thrive in the consulting world. He talks about how to maintain both your position and your passion during both good and bad times in the economy, and how to avoid career limiting moves. At the very least, had I read this book while still working for the airline, I could have avoided a couple of interviews that would have led to positions that I was not right for. My trouble-radar kicked in on those before I accepted, and I count myself lucky. By the time I had finished chapter two of The Nomadic Developer, I had already identified those firms as being one of the ‘Seven Deadly Firms’, and hiring on there likely would have tainted my consulting experience for the rest of my career.

The Nomadic Developer is not only for people who are thinking of becoming consultants. It’s also for consultants who are fairly new to the game, and will help you to stay out of trouble as the economy changes. I think it should also be read by owners/senior management of consulting firms, if only to avoid uncomfortable moments brought on during interviews by people who have read the book and are asking some of the hard questions Erickson suggests. Most of those questions I would be a little uncomfortable asking during a interview, but I see the value in at least trying to ask them. It’s not always the response that is important, it’s the way the response is said that will tell you if the employer is going to treat you as a partner / investment or a warm body / cost.

Here are some of the questions he suggests:

What is your annual revenue?
What is your (target) profit margin?
What is your exit strategy?
What’s the value of the sales pipeline?
What is the sales process?

I’ve done a lot of interviews of candidates in the last few years, and even though I have been on the technical side, I’ve never been asked questions like that. I’m actually pretty horrible at technical interviews because I hate trivia questions. I prefer to ask about experiences and expectations and to evaluate the personality of the interviewee. If someone was to ask questions like that, and I hadn’t read Erickson’s book, I would perceive them as intelligent but aggressive. But after reading his book, I would think that the candidate truly is trying to find the right fit. If I’m a consulting company senior management, I’m reading this book to make sure I’ve got my crap together so I don’t lose out on good consultants because I look like an amateur. I’m also doing an honest assessment of my company to see if I am making any of the mistakes Erikson lists in the Deadly Firms chapter. Unless my goal is to build an unsuccessful company, I want to be active in fixing these situations, even if it is just an employee perception. I don’t think too many people want to be unsuccessful at running their own company.

Another point Erickson makes is about passion for work, and how to maintain that during hard times, especially when the client you are working for is not in an industry you find appealing. I spent three years working for a client that did direct marketing… sending out junk mail and running those annoying call centers that call you during dinner. I slept on my office floor multiple nights while doing system upgrades, and let me tell you, that was really hard to justify to myself after a while. That experience left me quite cynical when it comes to working on projects I don’t fully believe have societal value. In the long run, that cynicism can be a career killer in consulting. It can kill your passion for software development, and once you’ve lost that, it can be very difficult to get it back. Employers, and especially co-workers, notice when your passion withers. In tough markets, not every job will be life-fulfilling, but Erickson suggests that taking pride in the work you do on each project will preserve the passion, and from there, passion will generate positive results and better opportunities in the future. It takes a while to build up the resume, and there is something to learn on just about every project.

I’m giving this book a big, big thumbs up, and making sure that my wife, who is a project management consultant, also reads this book. Very little of the book is specific to programming, and those bits can be read and parallels drawn with most other industries and job types.

Do yourself a favor, and read this book, and then get your coworkers, and your boss to read it too. If the suggestion is negatively received, you may already be working at one of the ‘Seven Deadly Firms’, and its time to find your exit strategy.

Where did I go?

2011-04-12T15:44:00.001-07:00

Judging by the activity on this blog (or lack thereof), you'd think I was either dead or retired. I am not dead.

I am still actively developing software, and am constantly hanging out on the bleeding edge. To that end, I do occasionally post blog entries on the web site of the company I work for (www.Palador.com). But most of the stuff I work on I cannot discuss in public, or is so well covered by other blogs that I don't see the need to cover. In the best case I’d just be repeating what someone else has said, or in the worst case, I’d be plagiarizing it.

So if you have a question or a comment, feel free to leave it. But I only swing by this blog once in a blue moon, so if you are in a hurry, you might want to try another search.

If you really need to get ahold of me, you can try my writing blog at www.joebeernink.com. It’s not technical in the least, but it is monitored much more frequently.

Thanks for stopping by.

MVC Abstract Controller

2010-09-28T15:18:00.001-07:00

It’s been a while since I’ve posted anything here. I’ve been busy, and most of the stuff I am working on I either can’t blog about or isn’t worth blogging about as it’s pretty much already covered in a dozen other blogs. But I have been doing a lot of very basic ASP.NET MVC coding lately on a couple of sites. I’ve stepped step back from my architect role to do some heads down coding to fill a personnel gap. I don’t get to do that a lot, and I rather enjoy it when I get the chance.

But I did come across a very interesting ASP.NET MVC situation this week that required more than a little thought. And since my monthly blog entry was due for work, I put a long entry about an ASP.NET MVC Abstract Controller on the Palador web site blog.

Feel free to leave me a note here or there. I’m always afraid of putting a big ‘code’ blog up because it’s just asking for someone to come along and rip the snot out of it and show me a better way to do it. But in this case, I’ll take the chance, as the solution was simple and saved me a lot of time and frustration.

Book Review: Microsoft SharePoint 2010 – Building Solutions

2010-08-05T09:16:00.001-07:00

The full title of this book by Sahil Malik is Microsoft SharePoint 2010 – Building Solutions for SharePoint 2010, and it was recently published by Apress. I love Apress books, and have 6 others on various .NET related topics on my shelf. SharePoint 2010 is something I needed to get up to speed on really quickly for a new project at work, as in I had less than a week to make sure I knew what I was talking about.

The book is 367 pages, and covers a wide variety of topics in SharePoint 2010. It demos a few techniques and tools, and identifies some of the differences between SharePoint 2007 and SharePoint 2010, so even if you know SharePoint 2007, it will really help you to identify what is different about 2010.

I’ve barely worked in SharePoint in the past. I tried a little bit of SharePoint 2003, and dabbled in 2007, but frankly, after seeing how painful it was to work in either of those environments, I wanted nothing to do with it. SharePoint was where good developers went to watch their career die. Once you knew it, you were guaranteed to get every crappy job out there, and because you were so valuable to the execs and their TPS reports, there was no way you were ever going to get out without quitting your job. And then, of course, you were so pigeonholed as a SharePoint developer, you could never get out from under it. Even if I knew SharePoint 2007, I would never put it on my resume. Career suicide.

SharePoint 2010 seems to be a little different. With the advent of Windows Identity Foundation and the advanced made in PowerPivot Services, there are definitely things that can be done in 2010 that would take forever in a typical ASP.NET application. And Linq to SharePoint is a godsend.

Malik covers all these topics with a few quick examples so that at least you know what is there, and how to use it. Each topic is probably worthy of a book of its own. I don’t have that kind of spare time, so I needed something at this level so I at least can speak the language and help to architect where these features can be used. Some features I will deep dive into in the future. Some features I will leave for others on my team to get familiar with. You can’t know them all.

I do have a very big gripe with this book. It does not appear as if it was ever professionally edited by a real copy editor. There are grammar and spelling mistakes on just about every page. As a fellow author, I know how hard it is to produce clean copy by yourself. A second or third set of eyes is always necessary. So I don’t blame the author for this, I blame the publishing company, Apress. I really hope this is not a sign of things to come. I know things are changing in the publishing world, and time to market on these books is critical and compressed. But in the two or three dozen technical books I’ve read in the last few years, and the dozens of fiction books I’ve read, I can only remember a few typos. This book had hundreds, and it drove me batty. I had to reread entire sentences to try to make sense out of them because words were transposed, missing or extras added in and never removed.

Also, the print on this book, and the line spacing is small. It really felt like they were trying to save paper by eliminating paragraph breaks. If the book was a fast action thriller, that may not be a problem, but in a technical book, I expect proper formatting. It helps to convey information and give your brain a break; an indication that the topic or idea is changing. Without a break, it gets really hard to read. A lot of the graphics are blurry or too dark to read, though that could have been my eyes as I was reading late in the evening. At one point, it was so bad, I wanted to hurl the book across the room.

I’m going to recommend this book, but I really hope they do another edit on it. Architects should read it. SharePoint 2007 devs should read it to get up to speed on the changes. New devs for SharePoint 2010? Not sure. It does give a good introduction to SharePoint Development, but you’ll probably end up buying another book as well to get into the nitty-gritty.

SharePoint 2010 seems to have come a very long way from it predecessors, but it still feels like it is behind the times, and a little kludgy. I’m worried that there are difficulties hidden in the practicalities of working with it that are glossed over by this book – things that you could spend a week trying to figure out, only to be frustrated by some weird case where you have to use I before E except after C when the word is in French and followed by an apostrophe. SharePoint 2010 is to SharePoint 2007 as .NET 2.0 was to .NET 1.1. The next version should be like .NET 3.5, infinitely better and more stable. 2010 is usable, but just not quite there yet.

But it no longer seems like career suicide to know it. You’ll probably just need to make sure it is not the first item you list on your resume.

Book Review: Programming Windows Azure

2010-08-04T08:30:00.001-07:00

I meant to review Sriram Krishnan’s Programming Windows Azure book a few weeks ago, but I have been slacking. It wasn’t until last night, when I was halfway through my next technical book (which I will review soon), that I realized that I had neglected to do the obligatory blog post.

I’ve been working with Windows Azure since the day after the CTP Launch. I was in the Early Adopter program. I corresponded regularly via email or via the forums with various members of the Azure Team for about 8 months between December 2008 and July 2009. I’ve led three major projects in the Azure world, and at PDC last year, members of the Azure team were finally able to put a face to the name of the guy that kept asking the questions that kept them working a lot of hours. Most of them didn’t hold that against me.

I give that background because when I bought this book I didn’t think I, of all people, would get much out of it. It was going to be another trophy on my shelf, a book read, a subject I thought I knew well enough to make this what I would consider a ‘light read’.

I was in for a shock. A refreshing one. This book taught me something new, or closed a gap in my knowledge base, on just about every page. While I had worked with Windows Azure, it was in the context of delivering a specific product, and my focus was on using Windows Azure as a tool to allow the product to launch, and a lot of the details had be bypassed.

This is a great book – one of the top 3 or 4 technical books I’ve read in the past 3 years. Every developer working on Azure must read this book. Must. Nothing beats the experience of working on a new platform, but this book will sure make it easier, and teach you the benefits and the pitfalls of this environment.

The biggest downfall of this book is that Chapters 1 (Cloud Computing) and 2 (Under The Hood) will lose a lot of developers who have no interest in the internals of Azure or the history of cloud computing. These are both necessary and interesting chapters, but for the non-architect or truly technical geek, most will skim them or skip them.

Also, the scope of the book is limited to the Azure Platform itself, and it does not cover things like the AppFabric or the role of Windows Identity Foundation in Azure. I’m looking for a good book on those as well, since I have yet to deep dive into the Service Bus, and haven’t worked with WIF since it was still called Geneva.

The rest of the book is superb, and like I said, I learned something on every page. Every Azure developer should have this trophy on their shelf.

Microsoft Word 2010 Bug

2010-08-04T07:46:00.001-07:00

I spend a lot of time in Microsoft Word 2010 writing my novels. I most often am working on my ACER 1420P laptop while doing it, and honestly, this is the only place I have seen this bug, but it annoys the crap out of me.

Here’s what happens:

Open a new or existing document
Start typing
Let you mouse cursor drift up over the tool bar (like the one for text formatting).
Keep typing.
Eventually, characters will start repeating. First you’ll see three ‘c’ characters (or whatever character that falls victim to this bug on that given day). If you see this start to happen, sometimes moving the mouse will stop the next phase from happening, but if you miss it because you watch your fingers and not the screen (which I am prone to do), phase 2 of the bug will soon kick in.
Phase 2 involves Satan taking over your computer. If you just happen to hit the backspace key or a cursor key, it will start repeating indefinitely. Next thing you know, your whole document is gone or you are sitting at the top or bottom of your document, and you still can’t get control back.

The only thing that I have ever found that works is to pull up task manager, and kill Word. But at least it will ask you if you want to save your changes before it closes. If the repeating character is a cursor movement, no problem. If it was the backspace key, you are SOL.

I find that the bug shows up most often if the cursor seems caught between tool bar buttons. It looks like a Windows event has gotten into an infinite loop, and as a developer, I would not want to be the one who has to try to figure this one out.

That said, I really hope this gets fixed soon. It happens to me at least once a week, and more than once has cost me work. I save early and save often because this one could strike at any moment.

Gradients, CSS and Overflow

2010-07-05T14:34:00.001-07:00

Last year, I built a website (http://www.joebeernink.com) to handle aspect of my burgeoning writing career. I also used it to learn ASP.NET MVC.

I had a designer do the styles and the graphics, but I did all the HTML work. When I originally laid everything out, the content all fit nicely on a single 800px long div which exactly matched the length of the repeating vertical gradient the designer put together for me for the outer background.

Once the content got too long, the repeating style left a lot to be desired. It not only repeated across the X axis, but the Y axis as well, which meant starting at pixel 801, I had this nasty black line across the bottom of the screen, and then the gradient began again. Yuck.

So instead of that, I set overflow = auto on all my inner divs, which for a while meant that the one page that had too much content had an inner scroll bar. I was kind of okay with that (I shouldn’t have been), but CSS has never been something I’ve worked with a lot, so I ignored it.

Lately, as I’ve been upgrading my site for an upcoming conference, every page began to have the scroll bar, and it was killing me. I talked to my designer at work and they shook their heads and said, “Dude, that’s like one line of CSS to fix. Don’t be such a loser.” Okay they didn’t say that, but they should have. They said it was pretty easy, and could be done in a single line of CSS. They were going to send me that line of CSS, but must have forgot. So yesterday, knowing that a single line solution existed, I got ready to do some CSS spelunking, and eventually came up with the solution.

Out with the old CSS Classes

.page
{
    background-image: url("../../Content/beernink_pagebkgd.jpg");
    margin-left: auto;
    margin-right: auto;
    background-repeat: repeat;
}

#main
{
    margin-left: auto;
    margin-right: auto;
    padding: 20px 30px 20px 30px;
    background-image: url("../../Content/beernink_insideBkgd.jpg");
    background-repeat: repeat;
    margin-bottom: 5px;
    width: 740px;
    _height: 1px; /* only IE6 applies CSS properties starting with an underscrore */
    overflow: auto;
    height: 500px;
}

And in with the new

.page
{
    background: #252E33 url("../../Content/beernink_pagebkgd.jpg");
    margin-left: auto;
    margin-right: auto;
    background-repeat: repeat-x;
}

The #252E33 is the color at the bottom of the gradient. The color nicely fills the page beyond the 800px line, and looks great.

There are probably better ways to do this, but this was simple and allowed me to say the site was ‘done-done’ for the conference later this month.

Of course, now I want to find a real blogging engine in ASP.NET MVC that I can deploy with my site. Any recommendations?

Silverlight + Azure Shared Access Policy Issue

2010-05-07T07:08:00.001-07:00

We’ve been working with Shared Access Policies in Azure for the last week or so, and for the most part it was working. But it would only work for a while, then it would stop. Then it would start working again. It took some help from Steve Marx and Jai Haridas on the Azure Team to figure out what was going on.

This first piece of code is part of our storage manager that retrieves the Uri for the blob from Azure Blob Storage, and creates a Shared Access Policy for that blob so that our Silverlight Video Player can directly access the blob without going through a very slow web service call.

        1: /// <summary>

       2:         /// Get the Uri for a specified video blob

       3:         /// </summary>

       4:         /// <param name="videoId">The unique identifier of the video</param>

       5:         /// <returns>A Uri ponting to the Video</returns>

       6:         public Uri GetVideoBlobUri(Guid videoId)

       7:         {

       8:             var log = Log4NetHelper.GetLogger();

       9:             log.DebugFormat("Getting Video for video id {0}", videoId);

  

            try

            {

                CloudBlobContainer container = GetContainer("VideoContainerName");

  

                CloudBlockBlob cloudBlockBlob = container.GetBlockBlobReference(string.Format(CultureInfo.InvariantCulture, "{0}", videoId));

                

                var readPolicy = new SharedAccessPolicy

                {

                    Permissions = SharedAccessPermissions.Read,

                    SharedAccessExpiryTime = DateTime.UtcNow + TimeSpan.FromMinutes(10)

                };

  

                var blobUri = new Uri(cloudBlockBlob.Uri.AbsoluteUri + cloudBlockBlob.GetSharedAccessSignature(readPolicy));

  

                log.DebugFormat("GetVideoBlobUri successfully retrieved for video id {0}", videoId);

  

                return blobUri;

            }

            catch (StorageClientException ex)

            {

                // If the blob was not found, return null

                if (ex.ErrorCode == StorageErrorCode.BlobNotFound)

                    return null;

                // Rethrow the exception in all other cases

                throw;

            }

            catch (Exception ex)

            {

                log.ErrorFormat("Error while retrieving video blob {0}", ex.Message);

                throw;

            }            

        }

In our Silverlight Web Service, we call this manager class and return the Uri embedded in an XElement. Originally we did this to allow us to return other information with the Uri, but at this point, the Uri is all we are passing through.

       1: /// <summary>

       2: /// Get video URI.

       3: /// </summary>

       4: /// <param name="videoId">ID of the given video.</param>

       5: /// <returns>Status</returns>

       6: public XElement DemoVideoUri(string videoId)

       7: {

       8:     var blobManager = UnityFactory.Current.Resolve<IBlobManager>();

       9:     var blobUri = blobManager.GetVideoBlobUri(new Guid(videoId));

      10:  

      11:     string xml = string.Format("<VideoUri>{0}</VideoUri>", HttpUtility.HtmlEncode(blobUri.AbsoluteUri));

      12:     var sr = new StringReader(xml);

      13:     return XElement.Load(sr);

      14: }

On the Silverlight side, we take make a call to this web service, extract the Url from the XElement, and pass the Url into the MediaPlayer like so

       1: var client = new WebClient();

       2:  

       3: var videoUri = GetVideoUri();

       4:  

       5: client.DownloadStringCompleted += (x, y) =>

       6:                                Dispatcher.BeginInvoke(

       7:                                    () =>

       8:                                    {

       9:                                        var xdoc = XDocument.Parse(y.Result);

      10:                                        var query = from b in xdoc.Descendants()

      11:                                                    select b.Value;

      12:                                        HostedVideoUri = new Uri(HttpUtility.HtmlDecode(query.First()), UriKind.Absolute);

      13:                                        mediaPlayer.Source = HostedVideoUri;

      14:                                        Log(string.Format("HostedVideoUrl = {0}", HostedVideoUri.AbsoluteUri));

      15:                                    }

      16:                                    );

      17:  

      18: client.DownloadStringAsync(new Uri(videoUri, UriKind.Absolute));

      19:  

      20:  

      21: private static string GetDemoVideoUri()

      22: {

      23:     var host = HtmlPage.Window.Eval("window.location.hostname;") as string;

      24:     var path = HtmlPage.Window.Eval("window.location.pathname;") as string;

      25:     var refererUri = host + path;

      26:     var url = string.Format("http://{0}/xxxx.Svc/DemoVideoUri/{1}", GetHost(), VideoId);

      27:     return url;

      28: }

This is all pretty simple code (and the above code works, by the way).

Where we ran into problems was in the Web Service, when populating the xml string. Originally, we used blobUri.ToString() instead of blobUri.AbsoluteUri. This caused big issues (403 errors returned from the Azure Storage Service), when the Video Player tried to retrieve the blob because the Url returned from the Shared Access Policy generator can have spaces in it. And Uri.ToString and Uri.AbsoluteUri work very differently when handling spaces. I did not know this until last night. Uri.ToString unescapes the Uri before returning it.

So why did it work sometimes, and not all the time? Simple. Sometimes the Uri from the Shared Access Policy Generator has spaces, and sometimes it does not. The former did not work, while the latter did. We were looking for a pattern in the number of times we called the web service, or the interval between calls, and the size of the video blob. But it was as simple as a single space.

I think we spent at least 8 hours over the last two days trying to track down this bug. Hopefully this saves someone else some grief.

This post is cross posted on http://www.palador.com/blog/Blog/Silverlight--Azure-Shared-Access-Policy-Issue intentionally.

Book Review: Professional Application Life Cycle Management with Visual Studio 2010

2010-04-26T12:08:00.001-07:00

We’re jumping into Visual Studio 2010 this week, and beginning the migration to TFS 2010 as well. I wanted to get familiar with TFS 2010 and try to standardize our practices a little more before we mis-configured everything, so I bought the first book I saw that seemed to cover TFS 2010. Professional Application Lifecycle Management with Visual Studio 2010 by Mickey Gousset, Brian Keller, Ajoy Krishnomoorthy and MArtin Woodward fit the bill for what I was looking for and more.

The book is broken into 5 Parts:

Architect

This was a little basic, and highlighted a few new features in VS 2010 that I once used Visio to accomplish. But it also clarified for me a few basic UML constructs that I rarely used or may have been using incorrectly. I’m not sure I’ll use all of the available UML diagrams very frequently, mainly because not everyone on the team will be able to use them or understand them, but I’ll see how it goes. Ironically, this may be the last section that is truly useful for me.

Developer

I’m going to make sure all my developers are familiar with the new capabilities of VS2010, and this is a fantastic guide to what is possible. It make take a little effort to get to add these tools to the dev tool belt, but I think these time savers make the difference between a professional development shop, and a place that is just throwing code over the fence.

Tester

A great section about brand new functionality in 2010, and an area both testers and devs should be reading. I’m hoping that I can really alter our expectations of the relationship between dev and QA through the use of these tools, and that by the end of the year, our QA process can be much more thorough than it is now, and not cost any more time than it already does. It’s definitely been the neglected child of the development process, and my goal for the rest of 2010 is to bring it up to speed.

Team Foundation Server

A solid primer on TFS and some good guidance on branching and merging. A must read for dev leads, architects and build engineers

Project / Process Management

This is the section that really got my attention at first, and the one I would like everyone here to read, even the execs, and especially the solution managers. Half the battle of good project execution is getting everyone on the same page of terminology and process. This is definitely worth a read for a shop that is will to make changes, not for the sake of making changes, but to fix issues and bring themselves into compliance with the rest of the development world to eliminate the vocabulary barrier.

I found all the sections useful as a starting point to either make slight improvements to the processes we use, or as a guideline to make wholesale changes to how we are working to improve our output.

What I really liked about this book was that while I could have figured this stuff out on my own over the next year or so, it gave me a good primer to get started, so hopefully that will result in fewer wrong steps, and let me know about hidden features that I may have never discovered.

I powered through this book in about a week, and I’m sure I remember less than 50% of it. But at least I know where to go to look things up, and can begin to plot out direct for the configuration of our TFS servers and our processes.

Book Review: Introducing .NET 4.0

2010-03-02T15:13:00.003-08:00

I recently finished reading Alex Mackey’s book, “Introducing .NET 4.0 With Visual Studio 2010”. VS2010 won’t be launched until April 12, 2010, which is still just over a month away, but I’ve been champing at the bit, ready to dive into .NET 4.0 for months now. Mackey does a great job of whetting my appetite without drowning me in the minutiae of each new or improved feature.

.NET 4.0 is all about improvements to pieces that have been slowly coming together over the past few years. There have been a number of out of band releases to the .NET Framework since .NET 3.5 launched. .NET 4.0 enhances a lot of those releases, and, in some cases, completely goes back to the drawing board. There are a few new features that will make developers happy, but for me, the money is in the things Microsoft made better.

Mackey assumes you have a good knowledge of .NET, as this book targets what is new since 3.5. He includes things which were included in .NET 3.5. SP1, since not everyone may have gotten into that yet. I was pleasantly surprised at how much of the SP1 functionality we have actually put to use here, and was able to skim those chapters.

There are parts of the book that were finished before the actual functionality of VS2010 or .NET 4 were finalized, but that’s what you’ll get when you buy a book on a product before the product is released. Caveat Emptor.

By the end of the book, I was able to make some decisions on what functionality to target for further research. My bets are on three areas that will have the biggest payoffs for my team and my customers:

MEF (Managed Extensibility Framework)
Entity Framework 4.0
Windows Workflow 4

With MEF being such an integral part of Office 2010, a good working knowledge of it is essential to provide process enhancements for our customers.

We use Entity Framework 1.0 in just about every project we work on, and the leap to 4.0 should resolve a number of significant issues and code costs that we have encountered in the past year. I expect to see a large effort reduction in application development costs due to this upgrade.

If the improvements to Windows Workflow are as good as advertised, then I believe WF will go from shunned cousin to an accepted member of the development family. There’s a lot of power in WF, but the previous implementation was lacking. I stopped considering the previous releases as viable last year after a few false starts, but I have much higher hopes for it going forward with V4.

I recommended Introducing .NET 4 to my colleagues as a good getting started guide, and directed some to target certain chapters to match up with the type of work they typically do, or areas where they have yet to become involved in to give them a 40,000 foot view.

I will probably go out and buy other .NET 4 books as they become available, but will focus on the three areas above as they will have the biggest impact to my architecture choices in the coming months.

Mackey helps to give that guidance, and gets me excited for the new features. That’s what I want in an introductory level book.

Cross Site Blogging

2010-03-02T15:13:00.001-08:00

Today, I’m proud to announce the launch of a revamped Palador.com web site. Palador is the consulting company that I work for, and as the Senior Application Architect there, I will be doing my part to blog there, as well as here, and my personal blog as well. That’s a whole lot of blogging, but I actually get paid to blog there, so hey, I’m okay with taking that on.

Occasionally, I will cross post blogs here and there. Sometimes things will be posted there and not here, depending on the topic. We’ll see how it goes.

We’ll have five or six of us posting entries on a variety of topics, which is cool as it just goes to show how diverse our skill set is here.

Anyway, take a spin over to the new site and let us know what you think. I wrote or edited a lot of the copy there, so if you find issues, let me know.

Living the Evolved Digital Life

2010-02-01T10:45:00.001-08:00

Okay, it’s been a couple of months since I evolved my digital life, cut the cord to Premium Digital TV, and got my house in order. So where am I now?

1. Lesson Learned: You cannot run digital video over a wireless router, especially if you have more than 1 wall to go through. Bite the bullet and pull the ethernet cable if you can. I was always at 4 bars with the XBox 360, but the router would shutdown every hour or so (sometimes 3 times in a single episode of CSI). Pulling the cable through the floor was a PITA, but worth it now.

2. Spend some time and tune your Harmony remote. It’ll take a lot of time to get it right. I still have work to do on mine, but each improvement is noticeable, and after a while, you can’t believe you used to use 3 (or 4) remotes. That said, sometimes it still is a big pain, especially when the kids are sleeping and you switch video inputs, and the sound is cranked up and you can’t get back to turn down the volume down fast enough. I find myself planning my moves with the remote.

3. Make sure you have enough disk (at least 1TB) on your Media PC. I still haven’t hooked up my HD tuner because I haven’t wanted to spend any more money on the setup right now to add enough disk to record HD shows. I’d also like to have a dedicated Media PC with faster processors that can also host PlayOn, but since we have multiple laptops floating around the house, most of the time the PC is a dedicated Media machine.

4. 2010 will be the year Internet TV really takes off. My wife says we were probably a year or two early jumping online, and maybe we were. I’m looking at things like Boxee Box and thinking that was probably what I wanted.

5. We miss having a channel guide on our TV. We currently have to switch over to the Media center to get it, and because we get more channels on the cable than what the media center allows us to see, we don’t always know what is on at any given time. This might be worth a little more research.

6. I don’t use Hulu near as much as I thought I would. I just don’t want to go back and watch old shows that often.

7. I watch a lot more Netflix and am willing to break movies up over multiple nights if I need to.

8. The kids don’t miss on demand that much. We have a few videos laying around at home, and a few lined up on Netflix. That seems to get us through rainy Saturday afternoons.

9. Maybe I’ve just been busy the last couple of months, but I am watching less TV. That was a side effect I hoped for. I’m reading more, and watching better TV when I am watching it. When there is a little resistance to the inertia of just keeping the TV on all evening, you find other things to do pretty quickly.

10. I haven’t sprung for the XBox Live Gold Membership since I get everything I want through PlayOn, but as I was watching a movie last night, I definitely noticed that the hop across my HomeServer through PlayOn left dark scenes a little blocky. For $40 a year, it might be worth it to get the membership.

These things always turn out to be a little more complicated than you think they will. I feel pretty good about it now, but it’ll be a few months before I really forget the pain of the conversion.

.Net 4.0 and Azure

2010-01-14T13:07:00.001-08:00

We were mapping out a release schedule for one of our Azure based applications today, and a major part of the application needs to be completely refactored to eliminate tight coupling between our WPF client and our server application. This coupling is exacerbated by the inability to properly XML serialize some of our Entity Framework 1.0 objects due to the recursive traversal capabilities of EF 1.0. We’d like to push the refactor back until EF 4.0 is available, but that brought up the question of when .NET 4.0 would be available on Azure.

There is no set release data for Azure with .NET 4.0 support at this time. However, Scott Guthrie mentioned on his blog on Dec 17^th that

“We are working with the Azure folks right now to try and get .NET 4 installed on it as soon as possible. Unfortunately I don't have an exact ETA yet.”

However, the Azure team this week (today since Thursday is their deployment day) did a release to include an ‘OS Version’ attribute for roles so you could specify a particular Azure Build level when deploying. It will default to the most current version if you don’t set it, so it is a way to ensure that if you don’t want to be upgraded, you won’t be. Right now, they only support one version of the Azure OS. This has to be a precursor to the .NET 4 rollout, and something we have been trying to get them to include since our very first meeting with the Azure Team back in November 2008. I haven’t looked at the feature in detail, but I’m glad they’ve addressed the concern.

My guess is that they will have to spin up .NET 4.0 support well before the commercial launch of .NET 4 because of the integral role of Azure in VS2010, and that in order for final testing to happen, they’ll have to allow full .NET 4.0 Azure deployments. Kind of a chicken and egg thing. Stay tuned.

Setting up VS2008 For Windows Mobile 6.1 Development

2010-01-14T11:48:00.001-08:00

There are a few tricks to setting up your PC for Windows Mobile 6.1 Development that are needed to get moving. Of course some of this will depend on exactly what you want to do in Windows Mobile.

My project was pretty simple.

Create a Windows Mobile Forms app that interfaces with a Motorola M9090-G scanning device that allows a user of the scanner to scan their employee badge barcode, a barcode for a shipping document, and a barcode for a series of packages.
The user will scan a large number of packages, and then send their scan records in a batch to a central database for further processing. The user may or may not be close to a wireless access point at the time of the scan.
The app has to be fast. The folks using this device will fly through dozens of packages a minute, and there will be multiple scanners working to unload a truck, but there are logical gaps in the loading and unloading where the app can upload to the database.

It’s pretty obvious I needed a client cache for the data. I chose Microsoft SQL Server CE. For the backend data store, we’re using SQL Server 2008 (with Change Tracking turned on)

I didn’t want to custom build a synchronization methodology, and since I played with Microsoft Sync Services a bit last spring on another project, it seemed like a good place to start.

First off, VS2008 SP1 comes with a number of emulators built in, but no Windows Mobile 6 emulators. In order to get the right emulators installed, download the following, and install in the following order. You’ll need to shut down VS2008 to complete this install.

Windows Mobile 6 Profession and Standard Software Development Kits Refresh
Windows Mobile 6 Professional Images (USA).msi
Microsoft Windows Mobile Device Center Driver
Microsoft SQL Server CE for Devices
Microsoft Synchronization Services for ADO.NET for devices – note that you cannot user Sync Services 2.0, as it is not device ready yet.

You should now be able to fire up VS2008 and create a new Smart Device Project. Make sure you set it up for Windows Mobile 6, or you’ll not have all the options you need, and will have to start over.

One mistake I made, was not realizing that there is a different version of Microsoft SQL Server CE for Devices than for PCs. You will need to download the correct version to get everything to work.

I strongly suggest creating two solutions for this type of an application. One for the Mobile client, and one for the WCF Service, whether it be a Windows Service or a Web Service. It makes it a lot easier to debug, and helps to ensure that you don’t try to deploy Mobile targeted assemblies to the server and vice versa. The IDE should prevent you from doing it, but it doesn’t hurt to take this approach anyway.

I like writing code, but I like getting projects done even more. So if I find code out there that works, I’m not afraid to put it to use. There were a couple of projects I found that really help to do some of the heavy lifting:

SyncComm on Codeplex. This provides you with all the plumbing you need to get Windows Mobile Sync working in your project. If there is one thing I would change (and did) in the project, it was to break the ClientService.cs up into another partial class to remove the customizations that were done to it. I have found three methods that I moved into a separate file. Otherwise the code gets wiped out when you regenerate it. Cost me an hour of work. See code below.
Custom Message Encoder: Compression Encoder on MSDN. Download the sample there. The download link is trickily hidden under the title of the article. This provides you with all kinds of samples. The one you want to go to is under <installroot>\WCFSamples\WCF\Extensibility\MessageEncoder\Compression\CS. Take the GZipEncoder and add the project to your server solution.

     public ServerClient(System.ServiceModel.EndpointAddress endPointAddress, BindingType bindingType)

            : this(GetBinding(bindingType), endPointAddress)

        { }

        static Binding GetBinding(BindingType bindingType)

        {

            Binding binding;

            switch (bindingType)

            {

                case BindingType.Basic:

                    binding = CreateDefaultBinding();

                    break;

                case BindingType.Compressed:

                    binding = CreateCompressionBinding();

                    break;

                default:

                    throw new ArgumentException("BindingType value not excepted");

            }

            return binding;

        }

        //NOTE:

        //set compressed endpoint binding custom properties here

        public static Binding CreateCompressionBinding()

        {

            // Create a CustomBinding

            var customBinding = new CustomBinding();

            // Create a compression binding element

            var compressionBindingElmnt = new CompressionMessageEncodingBindingElement();

            // ..and add to the custom binding

            customBinding.Elements.Add(compressionBindingElmnt);

            // Create an HttpTransportBindingElement and add that as well

            var httpBindingElement = new HttpTransportBindingElement();

            //TODO

            //Set here desired values. Take care to match such values 

            //in app.config in SyncComm host project

            //max buffer size

            //httpBindingElement.MaxBufferSize = int.MaxValue;

            //max received message size

            //httpBindingElement.MaxReceivedMessageSize = long.MaxValue;

            //max buffer pool size

            //httpBindingElement.MaxBufferPoolSize = long.MaxValue;

            customBinding.Elements.Add(httpBindingElement);

            return customBinding;

        }

In order to get WCF to connect from the Windows Mobile 6 Emulator to a Web Service on the local host, you’ll need to follow the steps listed by Chris Brandsma on StackOverflow. This is critical and can cause a lot of frustration if you don’t do it.

So as of today, I have a client on my Windows 6 Emulator, a Web Service, and the basic data flowing, though I have a lot of work left to do to test and refine the processing, and to test on an actual device. I’m sure I’ll find a few more issues, but I wanted to note what I had done to this point, just in case I need to replicate the process on another PC or build server here in the near future.

Let me know if this doesn’t work for you.

Windows Mobile versus Windows CE

2010-01-11T20:17:00.001-08:00

As I explore the wonderful world of really small screens, I’m having to choose between Windows CE and Windows Mobile. There are pros and cons to both, and what I’m going to list below is just what I think I know at the moment. Of course what I thought I knew on Friday has changed a bunch, so I’m sure I’ll be contradicting myself in later posts, if not calling myself a complete idiot.

Windows CE is a term used to describe a variable set of OS components that can be deployed to small devices with limited memory and storage. If you look at the .NET Framework options available in CE apps, you’ve got very little available. Certainly no WPF, no Silverlight, no native WCF. You basically need to build up your OS as you go with these components.

Windows Mobile is built on top of CE, but comes with a more standard (i.e. heavier) package of components and applications built into the OS. The basic environment to run the application is baked in, but you can add elements from CE type SDKs as needed.

At this point, there seems to be the following CE Environments:

4.2 – Deprecated and generally not supported
5.0 – Most devices can run 5.0. Its like the XP of the Device world.
6.x – Various incantations of 6.0 are out there, but the adoption rate by the major vendors is slow. Motorola (who bought Symbol), is the big player in the scanner market, and they’re just releasing their 6.x machines this year, and 6.x hit the market in 2006.

Windows Mobile is on a slightly different pace

5.0 – Seems to be fading fast
6.0, 6.1 – Are the mainstay of the Windows Mobile Market place, though being surpassed on phones by 6.5
6.5 – The current version, though wikipedia says it was never really planned. It just sort of happened. I hate it when that happens.
7.0 – The light at the end of the tunnel, coming out sometime this year. Rumors are swirling that the whole OS will be built in Silverlight. Microsoft has to come out with something just kick ass to stay relevant in the market. If Windows Mobile 7 is still based on CE, then that’s a good indication, that they’ve given up on everything except bar code readers.

As I was evaluating the various options, I got that creepy feeling with Windows CE, that if I tied my client to it, or worse, spent the year learning it myself, it would be obsolete before the calendar read 2011. I was also finding it really difficult to just get going with it, finding the tools I needed to build the software, figuring out how to deploy it, and how to build an emulator for it. I can’t say that from an architectural perspective, it’s a bad product, but in my gut, I knew it was a dead end. It hasn’t updated in 4 years. Even COBOL has been updated in the last 4 years, right?

So I switched my project over to target Windows Mobile 6.1, and within an hour or two (most of that being downloads of SDKs), I was up and running, and realizing just how little real-estate is on a 240px-320px screen. Now it’s a matter of figuring out Windows Synchronization Services, and I’m off and running.

Tomorrow, I’ll post what I did to get my Visual Studio 2008 ready to build and test the Windows Mobile app, which is something I need to document anyway, since I’ll be getting a new work computer soon, and will need to reinstall it anyway.

Let me know if you think my evaluation is off target. I’d appreciate the feedback.

Windows Devices

2010-01-08T17:19:00.001-08:00

I recently took on a new project at work to build a custom scanning app for one of our customers. It’s a brand new system, likely to be built on the Motorola (ex-Symbol) MC3090-G or MC90900G platform using either Windows CE or Windows Mobile as the base environment.

I’ve never worked on a mobile device, and the first three days has been something of an adventure. I’d love to use Silverlight, but the 3090 doesn’t seem to support it. I’d love to use the Microsoft Sync Framework 2.0, but it looks like that SyncFX 2 does not work on CE, and I’ll have to use 1.0. I may end up spinning up my own sync processor since the database is dead simple (1, maybe 2 tables).

What’s weird is that a year ago I was struggling as an early adopter to learn all new concepts for Azure, a new technology with little documentation and an unstable base. Now I’m trying to use technology that’s been around for quite a while, and changes a lot more slowly than Azure and Windows Desktop, yet the process of learning is just as hard because the documentation all dates back to 2006-2007 and my gut says ‘don’t trust it, it’s old’.

So over the next few weeks, I’ll be blogging more about CE / Win Mobile. Hopefully others will find this useful to get started, and maybe, just maybe, someone will read this, and be able to point me in the right direction.

Anyone at Microsoft need an early adopter for Windows Mobile 7 + Silverlight on a scanner? Let me know. I may consider it if I can’t figure out the other ways sooner than that.

Moral Responsibilities

2010-01-08T17:18:00.001-08:00

If you work in the software industry long enough, sooner or later you are going to be asked to do something that comes into conflict with your conscience. Whether it be to ship with defects in the hopes that no key users will find them before you can get it fixed so you can ship on time, or whether it be to include some arcane EULA agreement into the software that no one will ever read, but gives the software or the company to do anything to your PC, or to gather and distribute any personal information the company wants to sell. Sooner or later, you will review the strength of your convictions.

When I started out in the industry fifteen years ago, I was an idealist (aren’t we all when we are young). I can remember tracking my hours religiously to ensure that I got paid for every minute I worked past 40 (this was in Canada and overtime was required… that was nice). Now, I track hours so I can bill clients, but I have adapted to the term ‘salaried employee’, and I just do the work. It took a few years to get the ‘overtime’ idea out of my head, but I’m paid well for what I do and I want the small company I work for to be a success. I also know that I must spend my own time to improve my skill set. That was something I didn’t see as my cost of working, just a few short years ago. My moral values changed over time.

A few weeks ago, I upgraded all my personal PCs to Windows 7. One thing I hadn’t done was to install the HP driver software so I could download pictures from my HP C6180 All in One printer. I could print to it, but I couldn’t see the SIMM card reader to get the photos. We had a bunch of pictures on the camera I wanted to post for family to see. I went out to HP’s website and started to download the installer for the drivers.

I stopped the download when I saw it was 340 MB.

Yes, 340 MB. For drivers.

Now I’m not an expert on driver software, but I recognize bloatware when I see it. I stopped the download, and attempted to find driver software just to get the ph0tos. You know, something that will allow me to see the SIMM as a USB device. HP’s own site (in small letters off to the side), said that if you wanted just the drivers (no network), to search for the Basic package. I did that. The only package that came up was one for XP and Windows 2000 Server. Hmmm.

I got impatient. I didn’t plan to have my whole evening sucked up with just trying to get pictures off the camera, That’s supposed to be the easy part. So I decided to download the 340 MB package and install it. I knew that the previous version of the software had some really annoying apps that I didn’t want, so I figured at some point during the install I would have a chance to opt out of those. I started clicking through the install. I got to the page that asked you to accept the EULA. I clicked to accept (like anyone reads those), and then clicked next. I then noticed that the install was about to start without giving me an option to opt out of the bloatware. Hmmm.

I went back a screen, and re-read it. On the screen were a series of links that look like they are part of the text, but are really optional installer screens that let you go an opt out of some of the options. Okay, my fault, I missed it. But reading on, I see a part that says failure to install all of the options will probably cause the installer to fail. What? Scare tactics or honest truth? Bad software? I was about to commend them for their honesty, until I went into the screens, and started to see all the crap (pure bloatware) and all the really dangerous stuff (outright spyware) they were about to try to install. Holy Mother of God. I’ve never seen such a blatant attempt to take my personal information.

Let me stop here for a second, and go back 29 hours. The previous day I got a call from my wife that she got a call from our credit card company that they had noticed some unusual activity on our credit cards, and sure enough, someone had stolen our number and was buying stuff at BigLots! and Target in California. I live on the West Coast, but nowhere near California. So we cancelled our card, had the charges removed, and everything was taken care of in a couple of hours. I was a little upset, and briefly talked about the death penalty for credit card theft (a damn fine idea if you ask me), but after a few hours, everything was okay.

Fast forward to last night, sitting in front of my PC, looking at all of this crap. I was spitting mad. Mad at HP for creating such a mess. Mad at HP for knowingly taking advantage of the fact that no one ever reads the EULA. Mad at HP for violating the trust that we are supposed to have for large purveyors of hardware and software. They are supposed to be out there fighting against this kind of thing. Mad at HP for making software developers do this, because I have to believe that no self-respecting developer would ever do this except against their will in an effort to keep their job. Mad at the industry that slowly whittles away our moral values to the point that this is acceptable behavior. Mad at the fact that my elderly parents would install this without questioning it, and expose themselves to all kinds of corporate invasion.

I went through and eliminated the stuff I didn’t want, and installed what I thought was the barebones driver. But I missed a checkbox, and it still installed something called HP Web Printer Helper. The next time I fired up a browser, half the screen was taken up by an HP add on that kept asking for special permissions to send information HP to help improve my experience. What the fuck!?! Screw that. Search though the add on list and disabled it.

But then I realized that disabling it wasn’t enough. My other logins for the rest of the family may still have it installed and active. So I went back into Control Panel and removed anything from HP that was questionable. I was still pissed.

I popped on to HP’s site, looked through their contact page, and fired off a long note to the HP CEO Mark something or other. There was a 3500 word limit. I may have been close. I doubt if I’ll hear back, and I doubt even more if HP will change their evil ways. I was ready to call for an all out boycott, but I realized that I liked the HP EX 490 Home Server I recently purchased too much not to recommend that one to other people.

Instead, I’ll simply document my experience here, and hope that my tale takes root, and those roots break the concrete of corporate greed and malfeasance.

So be forewarned, those of you who blindly approve all EULAs from supposedly trustworthy companies. They know it, and they’re starting to take advantage of that fact. Scary.

Bug in Entity Framework

2010-01-07T10:52:00.001-08:00

I found a great little bug in Entity Framework this morning. One of their exception handlers can throw an exception, that hides the true exception. Here’s how to recreate this:

Set your thread culture to a neutral culture: i.e. ‘en’ instead of ‘en-US’
Create a new EF Context
Find an object (A) that has a dependency to another object (B) via foreign key and B has a dependency to object C via another foreign key.
Create a new object of type A called ‘a’
Get object B and detach it from the database (as if you were getting it in via a web service call). B should lose it’s link to C
Add object B to A
Attempt to add A to the database via the context.AddToA(a)
Call context.SaveChanges().

What you should get is

System.Data.Entity Type: System.Data.UpdateException Message: Entities in '[contextName].B partticipate in the 'FK_B_C' relationship. 0 related 'C' were found. 1 'C' is expected.

What you will get is:

System.NotSupportedException: Culture 'en' is a neutral culture. It cannot be used in formatting and parsing and therefore cannot be set as the thread's current culture. at System.Globalization.CultureInfo.CheckNeutral(CultureInfo culture) at System.Globalization.CultureInfo.get_NumberFormat() at System.Globalization.NumberFormatInfo.GetInstance(IFormatProvider formatProvider) at System.Data.EntityUtil.ConvertCardinalityToString(Nullable`1 cardinality) at System.Data.EntityUtil.UpdateRelationshipCardinalityConstraintViolation(String relationshipSetName, Int32 minimumCount, Nullable`1 maximumCount, String entitySetName, Int32 actualCount, String otherEndPluralName, IEntityStateEntry stateEntry) at System.Data.Mapping.Update.Internal.UpdateTranslator.RelationshipConstraintValidator.ValidateConstraints() at System.Data.Mapping.Update.Internal.UpdateTranslator.ProduceCommands() at System.Data.Mapping.Update.Internal.UpdateTranslator.Update(IEntityStateManager stateManager, IEntityAdapter adapter) at System.Data.EntityClient.EntityAdapter.Update(IEntityStateManager entityCache) at System.Data.Objects.ObjectContext.SaveChanges(Boolean acceptChangesDuringSave) at System.Data.Objects.ObjectContext.SaveChanges()

The only way to get the real error, is to change your current culture from a neutral to a specific culture. I’ve never seen this one before, and I had a few minutes of head scratching before we got the real cause.

Evolution

2010-01-01T16:44:00.001-08:00

I have evolved. Well, not me personally, but the technology in my house has definitely undergone an evolution over the past few months. Or at least a refresh. It was a long time coming, and there’s still a way left to go, but here’s where I started from, where I am now, and where I think I still need to upgrade.

Last year at this time I had the following:

Home Computer: Dell XPS 410 pretty much a standard ship from the factory (without the TV card) running Vista Ultimate bought in 2005
My Laptop: Toshiba U405-2854 running Vista Ultimate bought in 2008
My Wife’s Laptop: Dell Latitude 550 running Windows XP bought in 2004
Phones: Qwest RAZR with limited texting (2 phones bought in 2005 appx $70/month charges)
Internet Connection: Qwest DSL 1.5 MB Download, .3 MB Upload ($30 / month)
TV Connection: Comcast Basic Cable ($78/month with DVR and 2 cable boxes)
Game System: Standard XBox circa 2004
Backup Strategy: Used Windows Live Mesh for my writing and personal docs, plus a Maxtor 300 GB US Backup drive with Norton Backup (Never worked right)

A number of factors came together over the past year to cause me to spend a bunch of time and a bunch of money upgrading various technical aspects of my life

1. We upgraded from the basic Qwest Phones to Apple IPhone 3GS with unlimited data from AT&T last spring. I was happy with the phone I had, but Qwest was discontinuing wireless in our area, and we had to choose a new plan. I left it up to my wife to pick a new plan / phone for us. I’ve been fairly satisfied with the IPhone on the whole. I use the phone every day, for far more than I thought I ever would (who needs web / email on their phone, I used to say), but I actually regret having email on my phone. I have it linked into my work email, and at times I feel obliged to answer emails at odd hours of the night. There is nothing worse than getting home on a Friday night, ready for a good, relaxing weekend, only to see an emergency email pop into your box at 6:00 PM. A year ago, that email would have waited there just fine until Monday morning, and no one would have cared. I may not work two jobs like some people I know, but I have one job that takes up twice the time it used to.

I am not happy with ITunes, but that is a whole other story.

2. My wife’s computer, the Dell 550, is a beast, both in weight and in the heat it puts out. It would literally burn your legs if you left it on your lap for too long. In November, she finally ordered a new laptop, an HP. That was the same week I went to Microsoft PDC, and received a new ACER 1420P laptop running Windows 7 courtesy of Microsoft. We promptly returned the HP unopened, and swapped / upgraded laptops. She got my Toshiba (just over a year old) and I got the Acer. If you’ve read my blog, you know what I think of the ACER. I got the raw end of the deal, and would switch with my wife if it wasn’t such a pain to move ITunes from one machine to another. Unless I can find a glare reducer for the ACER, I’ll probably replace it before 2010 is done.

We upgraded my wife’s Toshiba to Windows 7, and the Dell XPS 410 to Windows 7 as well.

3. With the money we originally had budgeted for the new Laptop, we bought an HP-490 MediaSmart Home Server. I love this box. Easy to do the initial setup, looks good, runs quiet. I added an extra 1.5 TB of disk into it so it could spread the load over multiple disks.

4. I then splurged on a new XBox 360 Elite with the 120 GB hard drive, with the idea that I could use it an a media extender for my home server. I also got the idea that with a little planning, I could drop the $78/month Comcast bill, and make back the money I spent on the XBox in less than 6 months. This is where my plan started to run into some trouble, and also where the story gets interesting.

First off, I wanted to put my media server and XBox 360 in my Home Entertainment center, hard wire them to my wireless router and DSL line, then run my desktop off a wireless USB receiver. A few problems cropped up.

a) Running a desktop PC off a USB Wireless G (Linksys WUSB54GC) when you are frequently remote desktopped into you work PC from there is a complete disaster waiting to happen. Of course the morning after I set this all up, I had to be up at 4:00 AM to talk to someone in India, and my connection kept getting dropped, and I had to go pull the router back out of the entertainment center and put it back into my office just to finish the chat.

b) 1.5 MB download over Qwest DSL is not fast enough to watch movies on Netflix or TV shows on Hulu. I thought initially I’d be able to upgrade to 7 or 12 MB on Qwest, but that level is not available in my neighborhood. Time to call Comcast.

c) In order to watch internet TV on the XBox 360 from the HP Homeserver, you need to install a product like PlayOn Media Server. The product works pretty well, though the install on WHS is not straightforward. Follow the special directions as best you can, and do lots of Google searches. The HP 490 does have one critical flaw for those of you who want to run PlayOn to stream Internet TV. The CPU is a little slow. In hindsight, upgrading to the 495 with the Dual Core CPU would have been a better deal.

I also went out and bought the XBox N Wireless antenna, and had Comcast Upgrade my router to N as well.

Once I confirmed that Comcast could give me the service level I needed, I was able to drop my TV cable plan from the $78/month to $13.50 a month by going with their very basic plan, and getting rid of the Comcast DVR. I bought a Hauppauge 1850 Win-TV-HVR PCI-E card and popped that into the last PCI-E slot on the Dell XPS 410 to act as my TV guide / tuner. That brought up another issue though with the Dell 410. Drive space. The Dell is supposed to have dual 175 GB drives set up in a Raid 1 configuration. When I upgraded the machine to Windows 7, it appears that I lost the Raid Configuration, and now I have 175GB C: drive, and 48 GB on the D: drive. If you try to set up the DVR on the D drive on the digital tuner, you can only record about 4 hours of TV. If you set it up on the analog channel, you can get about 30 Hours of shows (due HD vs std output.).

5. We bought a Harmony 900 universal remote. This thing is a beast, but it does work with everything we have, though not quite perfectly. We’ve been talking about getting something like this for a very long time, but using the XBox controller as a remote for the DVR was the final straw.

So what was the cost of all this (Roughly, tax excluded)?

IPhones: $199 each + $170 per month (We’ll keep those out the final numbers, since my wife can’t hold those against me.)

HP 490: $475
Extra 1.5 TB for Home Server: $90
XBox 360: $350
XBox 360 N Connector: $99
USB G Receiver: $50
Hauppauge WinTV Card: $119
PlayOn Media Server: $40
Windows 7 3 Pack for Toshiba and Home PC - $149
Microsoft Office 2007 Home edition 3 pack - $129
Harmony 900 – $274 ($138 by using a bunch of Christmas Gift certificates)

Total Hardware / Software Cost: $1501

New: Comcast TV – 13.50 / month
New: Comcast Internet: $20/month for 6 month (25MB down, 8 MB up), $45 / month after 6 months
New Total Cost / Month: $33.50 / 58.50 after 6 months
Original Cost / Month: $30 (Qwest) + 80 (Comcast) = $110.
Savings after 6 months: 450
Savings after 12 months: 450 + 300 = $700.

So after 1 year, I will have saved about $700, so it will take me about 2 years to break even.

But I also gained a more reliable backup system (worth quite a bit to me).

I also turned my WHS into a Web Server and Host my own website there (www.joebeernink.com), which I was hosting on Windows Azure, but since they are about to start charging outrageous amounts of money, I was going to have to switch to GoDaddy.com ($4 / month). But this way I can try more things with my web site and set up others as well. Not a big savings in money there, but honesty, going out to godaddy.com when I’m at work makes me feel like I’m looking at porn on company time.

All of this was a learning experience. I had some grandiose plans about getting rid of Comcast for good if I could get fast enough DSL speeds, and find all the TV content I wanted on-line, but alas, neither the former or the latter is completely possible, yet.

For someone about to go through all this themselves, here are a few tips.

Confirm your DSL provider can give you the speed you want before you start.
The HP Home Server is great, but get the 495.
Don’t try all this with Windows Vista. Wait till you have Windows 7
Upgrade your wireless to N before you start
Really investigate what you think you will do with you gaming system. The PS3 might be a better choice if you want to watch BluRay. The XBox doesn’t support it. The number one reason I bought the XBox was because most of my friends have it and they play on line. I haven’t yet had time to play on-line, so maybe that wasn’t the wisest decision
Don’t buy a USB Wireless card for a desktop PC. Waste of money.
ITunes doesn’t play well with anything. If you think you will be able to backup your ITunes library to your home server, then play your playlists on your stereo, you will be sadly disappointed. ITunes playlists are a proprietary format, and not compatible with Windows Media Server. So don’t promise your wife that this is possible.
If you want to stream music from your media server to your stereo, and you have a TV like mine, you may have to leave your TV on all the time while listening to music, and you’ll have to watch those seizure inducing graphics. My TV doesn’t pass audio through when the TV isn’t on, and I haven’t yet invested in the XBox to component out audio connector.
Your life will be more complicated with this setup. Instead of just checking your queue on Netflix and seeing what’s on TV / your DVR, you’ll have to do the following:
1. Check your Netflix DVD queue
2. Check your Netflix Instant Play Queue
3. Check your PC to see what is on your DVR
4. Copy the shows you don’t have time to watch now over to you media server so your PC doesn’t run out of space.
5. Look through Hulu for stuff to watch
6. See what you can watch on-line that can be streamed through the XBox. Not everything can be. To me, there’s a whole lot of collusion going on out there that is preventing the internet from being THE source of entertainment content, but the FTC is in the hip pocket of big business, and not going to do what is best for consumers, which would be to give everyone a choice of how to get their content. My hope is that over time, more content will be integrated into PlayOn so that everything I want to watch is in one place.
Be prepared for things to not work right the first time. In fact, if you are doing this just to save money, forget it. You won’t at least not right way, unless you already have most of this hardware.

What’s really weird is that since we’ve started setting this up, I’ve barely had time to watch TV, and I haven’t really missed it.

So what’s on the table for 2010?

Add more disk to my Dell XPS. Disk is cheap now, and if I added a couple of TB into it, it would go a long way to allowing my to record everything I want to.
Add a second cable splitter into the line coming in to the Dell 410 so I can have both HD and analog feeds, and choose which format to watch / record.
Clean up the directory structure on the Home Server to make things easier to find.
Develop a Home TV guide for everything we might want to watch (how to get to it, restrictions, etc.)
Figure out if I can access my Windows Media Center remotely to allow me to set up recordings while I am away.
Test my backup strategy. It’s a common saying that you don’t have true backups unless they have been tested.
Replace the ACER 1420P. We’ll see how long I can cope with this one.

Give me a few more weeks, and we’ll see if I get this all working just right, or get outsourced as the VP of technology in my own home.

New Year’s Technical Resolutions – 2010

2009-12-23T10:03:00.001-08:00

I’m a goal oriented person. Always have been. I hear management really likes that in developers, and now that I am more management than developer, I know I like that in my developers. The key is to make sure that the developer and management have the same goals.

To that end, I’ve spent some time over the past few weeks looking forward to 2010 and planning the technology goals for the company for 2010, so that we can take those goals and make sure that they both mesh with the vision for the company’s growth in 2010, and with the career goals of the developers for 2010 and beyond.

Personally, I want to maintain my technical edge over the next few years, to delay the inevitable full time move to management. It’s not just my backup plan. As an architect, I need to be able to see around the next corner. I may not have to delve deep into how exactly JQuery Validators work, but I’d better at least be able to read JQuery and know what it’s capable of doing.

To that end, here are my technical goals for 2010:

Visual Studio 2010 / TFS 2010 – I can’t wait for this release. I believe this will have the single biggest impact of any technology on my day to day work life in 2010. We have already identified major areas where our processes fall short, and hope that technology can help to address those issues.
Entity Framework 4 – After spending the last two days debugging a large project written with EF 1.0, I really hope that this version justifies the immense amount of time we’ve invested into EF and fixes the many aspects of EF that I would currently give a score of' ‘WTF’ to.
Azure – 2010 should be a huge year for Azure, with the full production release, and the stabilization of the environment. As an early adopter, I’ve seen a lot of breaking changes smack me in the face every Thursday morning, and I’m hoping that the pace of these slow (stop would be nice) so I can begin to recommend this platform to my customers as a viable solution for their products. I will also be doing deep dives into SQL Azure, the Service Bus, AppFabric and WIF as part of extending my Azure expertise
SharePoint 2010 – I really liked what I saw at PDC, and we’re champing at the bit to get going.
Windows Mobile 7 – I’ve never done mobile device work before, but I have high expectations of WM7. I’ve actually had some great ideas for IPhone apps that’s I’ve had to discard because I have no access to a Mac to do the development, and the more I work with Apple products (and their inability to work with anything else), the more I despise them. If WM7 delivers, I can see dropping my IPhone and going to a Windows based phone so I can actually work with it. I’d have to pry my wife’s IPhone from her hands with a crowbar, but we’ll see what options come out before I even suggest it.
RIA – I think this is a year away from being Prod ready, but there’s definitely power there, and something I want to play with in 2010
WCF Data Services – Ditto above
Learn JQuery - I was supposed to do that this year, didn’t make it.

My technical reading list has been fairly vacant the last few months as I put the finishing touches on my novel “The Forgotten Road” and the sequel “Nowhere Home”. But with the release of VS2010 coming up in the 2nd quarter of 2010, I expect that the list will fill back up. Here are some of the titles I’m looking forward to reading:

Introducing .NET 4.0- with Visual Studio 2010

Pro C# 2010 and the .NET 4.0 Platform, Fifth Edition

Pro ASP.NET 4.0 in C# 2010, Fourth Edition

Professional Application Lifecycle Management with Visual Studio 2010

SharePoint 2010 as a Development Platform

Pro SharePoint 2010 Solution Development- Combining .NET, SharePoint, and Office

I should also be able to blog more often. Most of the NDA’s I’ve been working under will expire with the production release of Azure, so hopefully I will have topics to write about that are both timely and interesting.

Happy Holidays!

ACER 1420P - Another Review

2009-12-15T11:42:00.000-08:00

After using this PC for a few weeks now, I have the following thoughts.

1. The screen is so freakin glare prone that it's almost unusable while commuting with overhead flourescent lights on the train. I mean, you eventually get used to it, but it's like a railroad spike being slowly driven through your brain. You can't find a position for the screen where the view is still good, and the lights aren't right in your eyes.

2. I really dislike the keyboard. I'm not the greatest typist in the world, and the sharp edges on the keys really catch my fingers and make bad typing worse. Combine that with the really small cursor keys in the right hand lower corner, and navigating a long Word document is pretty painful.

3. I still get occasional character repetitions for no apparent reason, despite having turned down the character repeat speed in the configuration significantly, to the point where if you are using the aforementioned cursor keys, you have to wait almost a second for them to repeat, and by then, you've gone past where you wanted to go.

4. On the plus side, I love the weight and the battery life. Definitely better than my Toshiba U405.

5. I haven't tried to make use of any of the advanced features of the system, partially because I don't want to spend any more time staring at that screen than I absolutely have to.

Based on the monitor, and the keyboard, and the fact that I never use the Touch screen, I would never buy this machine for myself or my family, and really miss my Toshiba, though I would probably buy the Toshiba T-135 if given a do-over. Maybe in the new year.

Acer 1420P Review

2009-11-22T16:14:00.000-08:00

Fully paid attendees of Microsoft PDC recevied a rather neat little treat: a new Acer 1420P Laptop. I've been playing with it for a couple of days, and while I haven't fully experienced the entire capabilities, I have seen the basics.

The battery lasts forever. I've been synching my ITunes from my current Toshiba U405-2854, and I've had the Acer unpluggeed most of the day, but had to put the Toshiba on the grid after an hour and a half of use.

This laptop is light. I'd almost say too light. At least the base is too light to support the display once the angle of the display to the verticle exceeds about 15 degrees, at which point the laptop flips over. The hinge on the screen is a little weak as well, and once past 25 degrees to vertical, the display slowly falls to horizontal.

The keyboard is really different from my Toshiba. Not necessarily a bad thing, but I write novels, and I'm a bad typist. So every adjustment in key position is a double whammy. The keys are more comfortable for me now than I first thought they would be. They are a lot rougher in feel than the Toshiba, but a lot of people like that. Maybe I will too after a while.

I haven't done any performance tests yet, so I can't give stats on that.

It took me half a day to figure out how to disable the Tap to Click feature on the touchpad. It turns out that the version of the Synaptics drivers shipped with the unit are not up to date, and that by upgrading to the current version, you can get the option to turn it off. I sent this question to ACER support before I figured it out myself, but they were completely useless didn't read the question, and answered something I didn't ask). I also had a problem with my keys repeating while typing, and spent a few minutes changing the settings on the keyboard so I could type without every letter repeating twice.

They've done a nice job keeping the bottom of the laptop cool while working. I'm wearing shorts right now, and while it's a little warm, it's a little better than the Toshiba, and a heck of a lot better than the old Dell my wife has been using.

The screen is crisp and clear, so no issues there.

I'm definitely going to pop a couple more GB of memory into it so I can run my usual suite of work apps.

I think this is a keeper. Would I have bought it for myself? Probably not. I never had ambitions to have a tablet PC. It'll be interesting to see if I use it for what Microsoft intended.

PDC Day 4

2009-11-20T09:32:00.001-08:00

Day4 was all about hitting as many sessions as possible. It was also all about trying to keep the brain from entering a totally cramped state.

I’ve spent a lot of time in the last year working on Windows Azure. The one thing I haven’t gotten to use was the Service Bus. The Building Hybrid Cloud Applications with Windows Azure and the Service Bus session was a great introduction to practical usage of the service bus, and I couldn’t help but to try to come up with ways to integrate it into my clients’ applications. However cool it is, it still has a huge dependency on ACS for security, and as I said yesterday, ACS isn’t quite ready for prime time. It’s pretty apparent that ACS has to be the focus of Azure development over the next few months. The coolest thing was the multicast of errors from one client to another. Spectacular solution to a problem I face today and was going to resolve with an RSS feed, but hadn’t yet due to security issues.

Next, I sat in on a Lap around Microsoft Visual Studio and Team Foundation Server 2010. I loved the new features for burn down charts and hierarchical tasks. We built in the iteration date functionality into our TFS by altering the database and building web sites to show us our statuses, but VS2010 is obviously a lot more complete. We’re going to have a hard time waiting to use it in production right now.

I watched Brad Abram’s excellent presentation on RIA services next. I had intentionally avoided learning anything about RIA services this year until that moment, so everything was completely new to me. It’s something that really shows promise, and I’ll want to try it out soon. The main thing I want to make sure is that we maintain the separation of layers, and the close binding between the UI and the models is a little disconcerting. We’ve been down that road before, and it always comes back around to bite us. I hate to say this, because I really have only seen RIA for that one hour, but I couldn’t help but thinking I was being Visual Basic’d. Not that the code was written in VB. It just seemed VBish. Too much power that leads to bad design. I hope my first reaction was just fear of being replaced by code automation.

I missed the lunch session I wanted to go to on Microsoft Visual C# IDE Tips and Tricks, but will definitely watch that video. I heard it was packed. Instead, I talked to the Visual Studio Team and talked through some TFS issues we’ve been having, and hopefully, we’ll be able to resolve them with their help.

The most disappointing session of the conference was the Scrum in the Enterprise. The first half was not bad and worth a watch. The second half was mind numbing and I, along with a bunch of others, took an early leave. I spent a little time in the Application Server Extensibility session, but honestly didn’t understand a thing that was said there.

The final session of the day was Automating Done Done in the Team Workflows with Visual Studio Ultimate and TFS 2010. Great session, definitely worth watching. When they had a little problem with the demo, I couldn’t help but to suggest that the problem might be connected to the VSMDI file. That got quite a few laughs, and was told that they guaranteed that the VSMDI file could not be the cause. I think it’s finally dead.

A quick shuttle trip to the airport, a quick (and half decent meal at LAX) and a lucky break to catch an early flight home meant I got into Seattle at 9:00 instead of 11:30. Nice to be home.

Overall, PDC was a great experience, and I hope to get to do it again, ideally with more of the senior folks from my company so we can cover more ground. The guys up on stage were all pretty much top notch speakers, with one or two exceptions, and really show that they are some of the best and brightest in the world. I don’t know I could ever do something like that.

I came out inspired to get back to learning. I’ll be drawing up a technology target chart for myself and the company in the next few days, to set up goals for the coming year. I’ve got a bunch more videos to watch, and side reading to do. But first, I need to get some products finished and out the door before the end of the year.

This blog entry was typed completely on my new ACER 1420P laptop courtesy of Microsoft. Initial review? Not bad. Need to figure out how to turn of Tap to Click and how to slow down key repeating. The laptop is light and probably needs a couple of GB’s of memory to make it useful at work. Screen is nice and clear. Windows 7 will take a little getting used to. I’m not completely sold on the keyboard compared to my Toshiba Satellite, but I think I can get used to it, as long as I can turn off Tap To Click. Otherwise, I’m giving it to my wife.

PDC Day 3

2009-11-19T07:59:00.001-08:00

PDC Day 3 was kicked off with the keynote that began with a focus on how devs can use the new features in Windows 7 to maximize the use experience, and emphasized that devs need to learn new ways to code to take advantage of parallel processing and built in capabilities to shunt processing to video cards and other areas of the system. A lot of this talk was above my head, but I guess that’s the point. It can’t stay that way.

Scott Guthrie launched Silverlight 4 BETA on stage, and though his demo had some technical issues, there was a collective gasp and cheer from the crowd during his demo of a built in capability of Silverlight to make a jig-saw puzzle of a video. Pretty freaking amazing. Scott Hanselman demoed new OData services and ties to SL4. Simple demo, but there’s a lot there some programmers might take for granted that was really hard if not impossible just a few months ago.

The last segment was on Sharepoint 2010 and Office 2010. Truth be told, I almost walked out, since I was scarred for life by my brief experienced with Sharepoint 2003. But I stayed, and was glad I did. They’ve really gone back and fixed the Visual Studio integration and everything from debugging to deployments just works. I’m ready to give Sharepoint another chance, and with a little work, I think I will soon consider it a viable platform for solutions for my clients.

The first session of the day was on Windows Identity Foundation, formerly named Geneva. I’ve spent a lot of time working in Geneva, but it was good to level my knowledge and get a refresher. I don’t know how Vittorio will come across on video, but in person, he was fantastic.

I briefly sat in on a lunch session for ASP.NET MVC – Share Your Stories From the Trenches. Good session with everyone putting their experiences out there. I was pretty proud to know that our approach is pretty damn close to spot on, with one exception. Never put an ‘if’ statement in a view. Factor that out into your ViewModel. If you have to put a null check in to determine whether or not to show something, add a bool to your view model and bind the isVisible property of the control or group to that. Great advice.

ADO.NET Data Service: What’s new with the RESTful Data Services Framework. First off, ADO.NET Data services has been renamed to WCF Data Services (Pablo pointed that out in his talk). Pablo is a very fast talker, and covers a lot of ground very quickly. He lost me at first by using JQuery to attach to a web service, but showed some very cool features out during the demo. Be prepared to watch this a few times to see it all. There’s one hell of a lot of power there, but it’s pretty intimidating.

Enabling Single Sign On to Windows Applications: This one moved fast, and even less than 24 hours after it, I can’t say I remember much. But as soon as I have a project with an ADFS 2.0 server in place, I’m going to go back and watch this one again.

Rest Services Security in Windows Azure using the Access Control Service: Justin Smith is a very passionate speaker about this topic and a great guy. Unfortunately, a lot has changed in ACS since last year, but it doesn’t look much more mature that it did a year ago. They’re launching another CTP, which is understandable as the first one didn’t quite cut it. There’s also a management change going on with ACS with the architect of WIF taking over the group. I suspect that they’re 6-12 months out from a release that’s usable, which is also unfortunate, because this is a really critical piece of the puzzle.

At Ask the Experts, I spent a lot of my time with the Azure Team. Anu, Steve and Vikram are all great guys. Anu remembered working on some of my bugs from the early days of the CTP, and we talked for quite a while.

What I find amazing is how accessible Microsoft has made all these guys this week. I know that while I’m gone, the work doesn’t stop coming in, and I can’t imagine what they’ve got going on, yet they took the time to let me bring up my laptop to look at code to try to figure out a bug I’ve been working on for a few months.

Anyway, on to Day 4.

PDC Day 2

2009-11-17T21:50:00.001-08:00

Highlights from Day 2 of PDC.

The Keynote: I got the feeling that this was less about new stuff this year than completing stuff from last year. A lot of Azure announcements, and a little about server tools, but the message was clear. Microsoft is banking on Azure for the next big thing server wise. It released pricing model for bigger instances of Azure, and outlined the plan for supporting tools and infrastructure. They also talked about Microsoft Pinpoint. I expect to hear more about that in the coming weeks. Project Dallas is also pretty cool.

There were a couple of ‘aha’ moments for me: System Center for Azure rocks, but won’t be available until a Beta sometime in 2010. The next version of Microsoft’s mobile platform won’t be available until Mix 2010. They’re falling behind badly but I’ll give them credit for not knee jerking a half baked solution to production before it’s ready. The other ‘aha’ was around he new data access technologies ODATA. My catch phrase for ODATA… “There’s gold in them there hills.” If you can only watch part of the keynote, catch the ODATA portion.

After the keynote, I went into session overload, including:

Data Programming and Modeling for the .NET Developer.

The most fun session of the day. Don Box and Chris Anderson showed off a lot of the new functionality in EF 4. As a guy who spends a great deal of my day working with EF 1, I’m very tempted to grab the bits for EF 4 now and push it to my clients.

Lessons Learned: Migrating Applications to the Windows Azure Platform

Didn’t learn a whole lot here that I either didn’t already know from my own experience with Demo Showcase, or from Chris Auld’s session yesterday. In retrospect, I should have jumped to a different session.

Windows Azure Present and Future

Pretty deep dive into the Azure story by Manuvir Das. Gained some insight into where things are going, but again, I already knew much of it. I wish I had gone to the Agile Session

Evolving ADO.NET Entity Framework in Microsoft .NET Framework 4 and Beyond

Awesome session. Highly worth a rewatch to learn how to use some of the new functions. Very, very fast pace. These guys love their jobs.

Advanced Windows Presentation Foundation Application Performance Tuning and Analysis

I’m going to recommend this to our UI guys to help make the apps that incremental step better to make the difference between sent out and shipped.

Quick stop at the Partner Expo. Ran into Justin Smith. Great guy who was really generous with his time back when we were getting ready to ship Demo Showcase and ran into a security issue. Looking forward to his session later in the conference. I watched a lot of his presentations from PDC08 when we were getting started with DSS, and I’m going to jokingly blame him and Steve Marx for getting me into this mess.
Went to an INETA Meeting. Informal, interesting round table. Two themes emerged:

a) People perceive that technology is changing faster than ever and that it is impossible to keep up.
b) Microsoft is making a mistake targeting big business and highly variable sites with Azure.
I disagree with both statements.

Technology always changes fast. We’re just more aware that it is changing than we used to be. We also need to know about more types of technologies than we used to because a lot of organizations are smaller and you have to know about more of them in order to do you job. There’s less compartmentalization. People who want to compartmentalize their work, and focus on just one thing, carve too small of a niche for themselves, and can’t find home in the do everything small companies.
Azure is perfect for what Microsoft is asking it to do. It is not perfect for what the individual devs want it to do. They aren’t going to make money spinning up VM’s for http://www.joebeernink.com unless they charge a lot more for it to make entry prohibitive for guys like me. If I am willing to pay the price, I can get almost the same service the big boys do. So once they start charging for it, I will move to GoDaddy or soemthing like that until I have enough business to justify the load (how long till I have that first book on the NYT Best Seller List?")

Scott Hanselmann had the best quote of the night, but I’ve seen it misquoted a few times on Twitter already. He said that the greatest power an architect has is to break the build. That is, to put controls in place like FXCop to prevent bad code from being checked in. What’s being quoted is that the greatest power Jr. devs have is to break the build. Jr. Devs should never break the build. If they are truly junior, they should be mentored and guided into checking in code that never breaks the build. If they are junior, but only due to seniority and not skill, then they need to gain the cred to add to the build process when needed. If no one in the organization listens, and that situation won’t change, move on.

Looking forward to tomorrow’s keynotes and a ridiculous number of sessions at 11:30 that I want to attend.

PDC Day 1 – Architecting & Developing for the Windows Azure Platform

2009-11-16T18:13:00.001-08:00

Day One isn’t quite over yet. Next up is a movie on the origins of Visual Studio. I figure if I’m going geek this week, I'm going all in.

Chris Auld from intergenz.com did a great presentation on all kinds of aspects to take into account when architecting Azure applications. He paid special attention to economic factors and how they play in to decisions on what Azure Technologies to use, and hen to use them. He’s got street cred because he’s built out a very large application on Azure for selling tickets for events.

His blog is http://www.syringe.net.nz and he’s on twitter at http://twitter.com/cauld

He’ll be posting his presentation deck later this week, and it’s well worth the read, especially for architects and technical management. Some portions of the presentation would be good to walk sales teams who are trying to sell Azure as a platform through so they understand what the advantages and disadvantages are. The presentation should also be on-line soon. It’s long (an all day event isn’t going to be short).

I still have some Azure questions I need to resolve, but many of those are specific to the areas I’m working on, so I didn’t ask them during question period. Hopefully I can have some productive hallway conversations.

On a side note (as I’ve already complained about this on twitter and Facebook)… Why do people put onions on everything? I couldn’t find a single lunch option without onions today, and as someone with a food allergy to onions, it drives me crazy, because they never label things as containing onions. Eggs, wheat, soy, milk, no problem. Onions, we’ll just let you bit in before you figure it out.

Demo Showcase Suite – A History – Part 9

2009-08-03T20:11:00.001-07:00

Continuing on my series recounting how we got going on Demo Showcase Suite

7. I wanted a reliable build and deployment process from the start

Okay this is pretty basic, and something I’ve insisted on for each project I work on. You can’t afford to build production software on a developer’s machine. It’s a no brainer though I’ve seen it done many, many times. What we did on this project, was to convert from using CruiseControl.NET to TFS Builds. This was new for me. Why would we do this you ask?

First, we had converted from VSS to TFS. I thought it would be better to be consistent and use the integrated tools we had. Second, we were also having scaling problems with our current CruiseControl server, and we were going to need to upgrade it anyway. So we made the leap to TFS with the plan to retire the CC.NET Server.

The other thing converting to TFS did was to take me out of being the expert on the builds, and I was able to delegate learning about it, and doing the setup to someone else. I didn’t have time to do it, and as long as we were using something that I had put together, the likelihood of me continuing to be ‘the build guy’ was too high. My very first job when I started in IT in 1994 was managing the nightly builds and version control. In the 14 years leading up to the start of the project, I was always the build guy. Now, I’m not the build guy anymore.

We ran into some issues with deployments to Azure later when we tried to build on a 32 bit machine, so we had two build servers, a 32 bit machine for the client application and a 64 bit machine for the server apps. This is probably not needed. With a better understanding of configuration manager in Visual Studio, we probably could have everything working on just one, but we had so many problems with the vsmdi files that by the halfway point of the project, we were seriously considering other options. Having a split build, and running the tests only in the Test build, not Prod and QA, helped a lot as well.

As far as the deployment process went, we scripted everything to get as far down the Azure path as we could, but we still had to manually upload to Azure, deploy and swap. There were two of us who became the experts on this, and kept everyone else’s fingers out of the Azure pie, just to be safe.

We spent a lot of time building the MSI for the client to have it do everything we wanted it to do. A lot of what we learned we are able t0 apply to other projects right away, and though it took far more time to get it perfect than we wanted to spend, it sure is nice to have a process we just always trust.

I’m feeling ambitious tonight (and wanting to get onto technical stuff sooner, rather than later), so I’ll cover #8 and #10 tonight. #9, as it turns out, is a whole series unto itself.

8) I wanted the team to be able to provide me with feedback quickly and easily and to give both myself and the PM a heads up well in advance of a red flag issue becoming critical. No surprises.

I think I’ve covered this already, but this was all about communication.

We implemented the scrums, as previously talked about.
We used task tracking in TFS to flag blocked items.
When someone is worked up about something, we dug in and broke the task down so I could see and understand what the problem was. Don’t let people stew, whether it be a technical issue or a personal one. Get it out in the open and deal with it.
We had whiteboards in the middle of the work areas. If there was a major issue, we grabbed people and whiteboarded it out with input from everyone.

I think we did really well in this one. There were almost no surprises from within the team, and the few that were came from me not listening carefully enough when tasks were starting to slide in the early days of the project. I learned to listen for the signs that trouble was brewing, and made an effort to head it off earlier.

10) I wanted to enrich my technical knowledge base.

I had no idea how much I would learn on this project. I still can’t believe how much I was working on that almost no one else in the world was doing. When it came to doing the first part of the security system, I think there were two or three of us on the MSDN Forums bouncing ideas back and forth. Dependency Injection, Rhino Mocks, WPF MVVM. I learned so much in the first few months, I thought I was going to drown.

For the record, I am not going to claim, as I begin writing about the technical aspects of the project, to be the expert in any one area. I am sure (absolutely positive, actually), that for each area I will get into, that there are a dozen people, if not a thousand, who know more. I’m just going to show you what we did, for better or worse. Some will laugh and point and snicker at some of the code. Hopefully I can get some feedback on better ways to do things. Hopefully someone out there getting started on Azure or MVVM or Silverlight or Demo Showcase will get some information that saves them some time or money.

If you have a specific area of the Demo Showcase architecture you want to hear about, let me know, and I’ll try to cover it in an upcoming entry. If you have a question about how to do something in Demo Showcase, or have a suggestion for a new feature, send it in. I’ll get it on the list.

Comparing Crafts

2009-08-02T21:22:00.001-07:00

I’m going to take a brief diversion from my series on Demo Showcase to discuss a parallel I found this weekend between developing software, and writing. As you can probably tell by the length of the entries on this site, that I love to write. I love it so much, that I have a web site completely devoted to my writing at www.joebeernink.com. I write novels. I write short stories. Hell, I like writing specs. But I also like to code. I like to dig into new technology. I like to solve hard problems. I thrive when faced with tough challenges. But back to the writing.

This weekend, I attended the Pacific Northwest Writer’s Association Conference new Seattle. This is a four day writer’s version of NerdDinner. Instead of hanging with Scott Guthrie and Scott Hanselman, I got to hang with Terry Brooks, Robert Dugoni, Will North, Joseph Finder, Richelle Mead, Caitlin Kittredge, and a thousand other writers and aspiring writers.

People talk often about the craft of writing software, and I think that has obvious connections to the craft of writing. Writing crappy software is easy. Writing crappy stories is easy. Writing good software takes education, practice, persistence, self discipline, structure and patterns, research. Writing is exactly the same.

You need to be skilled at the language you are writing, and know the vocabulary. Writing a great novel doesn’t happen on the first try. Just because you have spoken English your whole life doesn’t mean that a good novel will result when you put pen to paper, or fingers to the keyboard.

You have to keep writing, even when people give you negative feedback. If we all stopped writing code every time a user found a bug, or the compilation failed, or took it personally, we’d never get better at it.

You need self discipline to always strive to learn, to read that dull book on ASP.NET MVC, even though you think you already know ASP.NET. I mean, nothing will ever make VB 6 outdated… right?

You need to understand the structure of a good story, and the structure of a good piece of software. There are patterns and practices that have evolved, and yes, you may find another way to do something, and it doesn’t mean you are wrong, but there are some things that are just not worth reinventing. At least know what options are out there, and use the power that’s in them until you find a need to diverge. This isn’t meant to stifle progress. It simply means that not every piece of software is going to be a unique and brilliant creation. We get paid to turn out software that works. Novelists get paid to turn out writing that sells. If you don’t want anyone to read your book or use your software, go crazy.

Research the stuff that interests you. Read code from similar programs. Novelists need to read other authors from within their genres, not to copy, but to learn. Know what that code does before you copy and paste. Understand why it works. Find the patterns in plots of great novels. What tools does the author use?

None of these are spectacular revelations, or at least they shouldn’t be. But something hit me, a parallel between my career as a writer and my career as a software developer.

I started programming computers on a Commodore 64 in 1982-83. I was 11 I think. Actually, I had programmed on a PET CBM prior to that, but the C-64 really got me started. I took programming courses in high school and college, did an internship in college, and spent the years 1994-2007 working in the field taking a few courses here and there, picking up a book when I needed to, but never really taking charge of my career. But at the end of 2007, I realized my career was at a dead end. I had let my technical knowledge stagnate, and was blaming everyone else for my lack of opportunities. I made the leap from IT department at a large airline to a small consulting firm at the start of 2008, and vowed that I would spend a minimum of 3 months reading everything I could, as fast as I could, about the technology I was going to be working in, to get better, I wasn’t going to take courses, or expect someone to teach me.

I read on the train. I read at night until I couldn’t keep my eyes open. I read on the weekends. At the end of the three months, I realized that I had learned a lot, and had a lot more to learn. I filled up my wish list on Amazon with all books on every area of software development that I wanted to learn. I got a subscription to MSDN Magazine. I read the articles, instead of skimming them. I added dozens of blogs to my RSS feed. I read whatever I could there. I gradually brought my skills up to the point where I felt that I could talk intelligently about software development again.

Similarly, I started writing stories in grade school. I wrote them freehand until I had a Quick-Brown-Fox word processor for my C-64. Then I typed them out and printed them on my MPS 801 printer. I took a lot of English classes in high school. My schedule was too full to take classes in college, but I did write my first novel while there. I loved writing for the escape it provided from the pressure of my classes. I wrote a bit after college, but it was in fits and starts. At one point, I stopped altogether, until August of 2008. That’s when I got the laptop I am typing this on (a Toshiba U405-S2854 which I love).

I started writing a new novel on August 8th, and finished the first draft on January 1, 2009. But I missed something. I thought that writing was something I could just jump back into, and do without reading technical books on how to. I didn’t bother to figure out what genre I was working in. That has huge implications on what rules you need to follow. I didn’t bother to read other authors in my genre to see what was working. I didn’t practice my craft and look for feedback. I just assumed I was good, and smart, and that this writing thing wasn’t that hard.

This weekend was an eye opener for me. The successful authors study their craft. They practice, sometimes for more than a decade, before they get something published. They treat their hobby like a business. They are the CEO’s of their own corporation. They get feedback from their customers. They manage their brand. They work their asses off. You could see those in the audience that weren’t prepared to do that. They blamed agents and editors for their work not getting sold, or argued with the agents and editors about the quality of their work. For a new writer, that’s like arguing with the C# compiler that it should know what you meant, not what you entered. The compiler will be right 99.9999% of the time. If you go to three different machines, and the problem is repeatable each time, it’s your problem. If three agents tell you your writing sucks, it’s your problem. Fix it.

So why am I writing about this on a tech blog? It’s because it took me 13 years of my software career to realized that no one is going to make me a better coder / architect but me. It took me a year of writing, and a brutal slam from an agent to realize that I need to work as hard at writing as I did at improving my tech skills. And that takes time, and a plan. I filled up my shopping cart at Amazon last night with great books on writing, and expect to spend the time between now and Christmas reading those, and using the lessons I learn from them to improve my writing.

Where does that put my technical career? Right where it was. I just need to do both. To find more hours in the day. To work smarter. To learn the lessons I’ve been talking about in all these other blog entries so that on the next project, I don’t spend days regression testing manually. To do it right the first time. There’s just so much to do and learn out there, why screw around reinventing the wheel? Hopefully, after reading these entries, I help you to save time you could better use to bring your skills up to date, to create that vicious, incredible cycle of learning and doing things better and faster to give you the success and the time to do the other things in you life that mean something to you.

Good luck!

Demo Showcase Suite – A History – Part 8

2009-07-30T10:35:00.001-07:00

Goal #6: I wanted to plan for change, in scope, in the composition of the development team, in technology and in time lines.

Change on a project is inevitable. Even on short projects of a couple of weeks, there will always be a small change that causes some consternation amongst the team. I was conscious of four types of change:

1. Scope.

Everyone has dealt with this one. You can’t fight it. The best way to deal with it is to track it, to have good processes for handling it, and for providing feedback to management and the customer as to how each change in scope will affect the project.

Prior to the start of this project, our change tracking was minimal, if nonexistent. We used a web product called Gemini for tracking bugs and some feature requests for existing projects, but we didn’t track deliverables and tasks for new projects getting started. We used VSS (horror of horrors) for our source control. It was quite clear that as an organization, we were outgrowing these tools.

We made the decision to try something else as soon as the project was announced. We had access to Team Foundation Server and Visual Studio Team System Team Suite without needing to spend a bunch of money, so we used that. It was a big step forward from VSS, and it took quite a while to get up to speed on how to use it, and how to use it properly. There were definitely some very painful moments, and we’ll all be glad when we can upgrade to TFS 2010 to get things like hierarchical task trees and better integrated reports. We went back and forth on the best way to use the system, and I think, at the end, we were doing the best we could, though there are more features that we can probably gradually integrate into future projects to make us more efficient. We didn’t take advantage of the Estimate / Actual / Work Completed feature, and that is the one thing I would really like to change on the next project, to not just get a picture of how many tasks are outstanding, but how we are tracking effort to the goals. It would also greatly improve our ability to provide feedback to everyone when a scope change comes in to see how it really affects the project time line. Right now a ten minute bug fix carries the same weight as a 40 hour feature implementation on the task list, and that is obviously misleading and wrong.

2. Team Composition

We only had one change in the team in terms of losing someone from the team from beginning to the end of the project, but we did gain two new people as well. On a small team, it’s essential that in one person’s absence or departure, that another can step in and fill that role, or at least be able to understand what that person was working on so the work does not come to a grinding halt. The only way I know how to do this is for everyone to be doing things the same way. If everyone uses the same tools, writes code to the same standards, there’s a lot less chance that code will be a mess when someone turns it over. I harped a lot to the team about a couple of things in particular

a) Everyone had Resharper and was expected to make that little light at the top of the file go green every day. Okay, part of this is due to the fact that I am anal-retentive when it comes to clean code, but part of it is a matter of enforcing standards. I can’t sit over every developer’s shoulder and watch them name their variables, and set their tabs. But Resharper, and the lovely Ctrl K D really left us with some pretty clean code. It’s amazing how much easier it is to work on someone else’s code when you are not scared to open the file.

b) Nightly Builds: We used TFS to do our nightly builds, right from the start, and constant check ins were encouraged. Everyone feared the words ‘Who Broke the Build? UNACCEPTABLE!” being shouted across the office.

c) Unit Tests: As previously discussed, we could have done much better here, and we are working on making this better for the next phase.

d) Unity: We used the Unity Application Block for dependency injection (DI). I’ll go into more of the Unity overview in a later post, but because we had Unity set up early in the project, we were able to create mock objects and able to swap code in and out easily so that itwo people were rarely dependent on one another’s work. This was especially important prior to bringing on the new people to fill a void in some of the back end code areas so that UI development could proceed until they were up to speed.

I also spent some time creating a ‘Technical Overview’ document that summarized some of the technical decisions we made early in the project, some of the issues that were left to be resolved, and a quick reference for some of the more complex processes we were using. I don’t know how much this helped the new guys, but it made me feel better that I had at least tried to help them come up to speed without them needing to spend a week constantly asking questions we should have documented.

When I started my first IT job back in 1994, my boss gave me ownership of the New Employee Orientation / Standards book, and told me to update it when I found a question it didn’t answer, as I would be handing the book off to the next new person, who would then come to me first to ask questions. I love this chaining of documentation pattern. It gives the new people immediate ownership and responsibility. Of course, some people weren’t as robust in their documentation as others were, but if we held true to the pattern, everyone would see the benefit of keeping the document up to date. It made sense back then, anyway.

3. Technology

We knew the technology was going to change, and change rapidly during this project. Managing this change was a constant challenge. Again, Unity and DI played a large role in helping to resolve this issue. There were many times where we had issues with Azure, or did not know where the data would actually reside at the end of the project, but that didn’t stop the developers from continuing their work. We built interfaces and mocks, and swapped the managers in and out using the configuration files.

During most of the project, there were only two of us who ever touched Azure, just to insulate the team from the environmental changes. We defined the processes and worked through the issues, but the rest of the team barreled forward, not needing to know the specifics of how the system would work on Azure. This was true for deployments, data storage, security and configuration. Almost everything we built could run directly in IIS7 or in the dev environment without Azure being available. Pieces were converted over to run on Azure one at a time as they were ready with a few configuration changes. I can’t emphasize enough how important this is when working with dependencies that are constantly changing. Isolate them, mock them, keep the team moving.

4. Time Lines

The final date was not moving, but that didn’t mean that there wouldn’t suddenly be a need to give a quick demo of what we had to the customer in the middle of a big dev cycle. The builds saved us there, and having two (I would have preferred 3) environments to run the app in from early in the project allowed the devs to keep working, while the ‘PROD’ site was only updated as we achieved more stable releases. Having the multiple environments saved our bacon more than a few times.

Demo Showcase Suite – A History – Part 7

2009-07-29T11:33:00.001-07:00

This is the next in the series of entries about Demo Showcase Suite and the goals I wanted to accomplish.

5. I wanted the team to feel the urgency of working hard and smart early in the project to avoid the death march mindset at the end

Here were the things we knew, right at the start of the project:

a) The deadline was July 13th. It was not moving. No matter how many times I wished we had a few more months, weeks, days (or even hours), we were launching during the keynote on opening day of WPC.

b) We had huge technological hurdles to overcome on areas we had never seen before.

c) The customer wanted frequent updates on the work, samples of what we were doing.

To cope with all of this, we implemented some project management processes

1) We broke the project into 3 week sprints. This was our first time doing this, and I think we took the word sprint a little too seriously. We were always up against a deadline of some sort, but that was driven by the final, immovable deadline. When we saw our iterations slipping, we weren’t able to slide requirements to follow-on releases, but we did see that we were behind, and worked harder earlier in the project to get back on track. We also were able to keep the developers focused on the important features instead of getting wrapped around the axle on something that wasn’t supposed to be started for a couple of months.

Iterations worked for us as well, as we were able to better manage the customer expectations for the functions they would see in the next release. They knew what to expect, and knew what not to expect. That went a long way in keeping down the surprises for both parties.

In the end, we did one ‘Alpha’ release, two ‘Beta’ releases, and 3 ‘RTM’ releases. In retrospect, we should have called them Alpha 1, Alpha 2, Beta 1, Beta 2, Beta 3 and RTM 1 to properly set everyone’s expectations not just to the functionality, but to the quality, but that’s a lesson we learned the hard way.

2) We held a team scrum every day at 1:00 PM. We tried to keep this to 15 minutes a day, and I, as scrum master, tried to keep the team focused on three things:

i) What did you complete since the last scrum – Just a list, not a detailed dissertation. This helped everyone else know what was ready to test, or what dependency they had been waiting on was now complete.

ii) What are you working on between now and the next scrum - Just a list. If this was the same list you provided the day before, we hadn’t broken the tasks down far enough. If that continued for more than a few days in a row, it was time to take it off line, break down the tasks some more, and add resources if needed.

iii) What red flags are still outstanding that are keeping you from completing your work – Details as needed, especially if the task was taking much longer than expected or progress could not be made without more help

We tracked all of the tasks in TFS, though not as consistently as I would have liked, and added details / blocked status as needed.

At the end of the scrum, I stepped in to try to work any red flag issues to get the tasks back to green flag with each developer.

I’m a morning, person, and do my most effective work early in the day, so holding the scrum later in the day enabled me to break my day into two pieces. Some days, some of the red flag issues carried over to the next morning, but usually, I was able to focus on the big picture tasks that were assigned to me in the morning. The afternoon was spent solving problems, to keep the developers moving. It stopped a lot of wheel spinning (I’d like to think) and made sure no one was stuck on an island.

Having the daily scrums gave me, and the rest of the team, constant feedback on how we were doing to meet our next milestone, and how much effort we needed to drive into the current iteration that week to get it done. Sometimes that meant a weekend in February or March was spent in the office trying to clear up the backlog. But we knew we couldn’t grow the schedule, so it was better then, than to wait till the last minute when other problems would undoubtedly arise.

I know for absolute certainty that without these two processes, we could not have been successful. I also know that far more ‘project management’ time was charged to this project than was planned because of these scrums, but we probably saved just as much dev time by stopping the wheel spinning, and allowing me to focus on my tasks in the morning without constant interruptions. With a team of more than two developers on a project, I would absolutely do this again.

Demo Showcase Suite – A History – Part 6

2009-07-28T15:37:00.001-07:00

Honestly, I’m trying to do these once a day, but I took 3 days off for a vacation, and it’s taken me a couple of days to get caught back up. Here’s the next installment on my series of goals that I had when we stated on Demo Showcase.

4. I didn’t want to get to a week from the delivery date, need to make a change, and have to regression test everything by hand.

As I write these entries, what I thought were distinct topics, all seem to be related. This is talking about unit testing, right? No. Wrong. Different topic altogether. Application regression testing has always been a thorn in my side. I’ve never had the chance to put a good test automation tool to work for me to help with UI regression testing. Along with unit tests, I wanted to have a tool that would let the QA’s quickly and efficiently automate their tests so that the tests they did in March would be instantaneously rerunable in July. Sure, unit testing will get you part way there, but nothing beats a human looking at the screen and seeing if the right result is a reasonable result.

If there was a swing and a miss on a goal on this project, this was the big one. In fact, I didn’t even get the bat of my shoulder. In the post mortem discussions I’ve been having with the team, this one popped up to the top of the list for the QAs as something that directly affected their personal satisfaction with the project and with their jobs. With the rapid pace that we were kicking out builds each day, the QA’s rarely got a chance to work on a stable version of the application for more than a few hours, and some tests would take an hour to go through by hand if they didn’t run into bugs. They had a ‘happy path’ test they repeated each time, and there were many versions of the application where they never got to complete the full test. If we were to look at the number of hours spent testing on this project, I would think that we spent far more hours testing than the value we got from it. That is, since so much time was spent testing the same thing over and over, little time was available to test edge cases until the build really stabilized.

So coming out of this project, we still have this as an open item to find an automated regression test suite that works for what we do. I don’t think you can really evaluate the return on this investment prior to becoming proficient in the use of the tool, so it may take a few projects before we really see the benefits. But it is definitely something we will be carefully considering before the end of the year, and likely before the next release cycle.

Demo Showcase Suite - A History - Part 5

2009-07-21T09:21:00.001-07:00

Lesson #3: I wanted unit tests.

I’ve been on a lot of projects where we took a very short sighted view of the world, and planned for the initial release, and did no planning for life after that. It was always blamed on a lack of time in the project. “When we get this done, we’ll do our documentation.” or “Next time, we’ll do it right, and write some test cases”. It never works out that way. We all know it, and every time we utter those words, we know we’re lying to ourselves.

If you have enough time after a project to go back and write tests, your business is about to go down the crapper because the sales guys haven’t sold anything new, and there’s no backlog of work to get done, and you sure as heck know that your customer, who didn’t plan enough time for you to get your work done in the first place, isn’t going to plan budget for you to go back and write tests they expected you to write in the first place. If you ever admit to a customer that you didn’t test all of your code, you’ll probably lose that contract. They assume you have tested everything.

I started buying in to the idea of Test Driven Development last year on another project that involved building a dynamic search engine completely written in LinqToSql. The engine sat over a huge database, and some of the combinations of search terms they wanted to use involve 23 table joins. There were 50+ possible search terms, range searches, boolean searches, ‘like’ searches, and enum searches. This all took place in a legacy .NET Win Forms app built in VS2005. I built a VS2008 dll with Linq2SQL, and began adding test cases, one at a time, as I added the capability to do each type of search.

The engine itself was rewritten 2 or 3 times as it evolved, sometimes for speed, sometimes for maintainability, but those test cases that I wrote on day 1 were still my measuring stick to see how close the new engine was to returning the right results after each refactoring. To this day, I still trust those cases, even though I haven’t touched that app in almost a year.

At the same time that project was going on, I was working on another project that had no tests. It was a large ASP.NET application, with a couple of dlls. The majority of the code was in code-behind files of the pages, user controls, and a few internal classes. It was a pain in the butt to test, and every time I opened the code, there were code smell areas I wanted to fix, but was too scared to. I couldn’t afford to regression test the whole app just to make one small change. I’m still scared to work on it.

At the start of the Demo Showcase project, I did a lot of reading about Test Driven Development, looked into mock objects, and tried to get the team to buy into the concept. Unfortunately, I misunderstood a key premise of TDD, and made promises to the team that would prove to be inaccurate. I thought that we could have the QA group take the specs, and begin to write the test harnesses, and the developers would just have to make the tests turn green. I thought that MSTest and TFS would work together flawlessly, and take away any excuses that tests were too hard to write, or they didn’t know what was out there. I thought everyone would see the value of Mocks and Stubs and have an epiphany, and that TDD would sell itself. All I had to do was to sit back, show that my tests were working, and how great my life was, and everyone else would be jealous and follow suit. Not so much.

It took a conversation with Glenn Block and Jim Newkirk at a NerdDinner in January to help me clear up a key misconception. The QA’s could not, and should not, write the tests. At least not the first tests. The first tests were supposed to help the developer flush out the functionality of the code. When I brought this change back to the group the next day, the QA’s were relieved. The developers were disappointed.

The biggest problem we had with our TDD approach after that, was depending on MSTest and TFS. MSTest in VS2008 (and 2005) has a really annoying bug (that is supposed to be fixed in VS2010), relating to VSMDI files getting checked out and locked by developers or testers. I’d get our tests all organized and working, then next thing I know, the test lists were blank or out of date. I’d get upset with our team, and wonder who kept wiping out all my work. It turned out that VS2008 kept creating new versions of the VSMDI file if it couldn’t get a lock on the file, and would jump you into a new version without telling you. Running a specific set of tests became a frustrating step, and people stopped doing it. And when they stopped doing it, they stopped writing them in the first place.

The other big issue I found was that if you wrote a bunch of tests too far in advance, and set ‘Not Implemented exceptions’ in the code, the light on the builds stayed red for days, weeks or possibly months. People stopped trusting the tests, and stopped looking at them. I fell into this trap as well. I’m not sure how to fix this, except to flag tests that I know are not ready yet as ‘Ignored’. Write them, then ignore them until the code is ready to be worked on, then re-enable them. Put a To-Do Task in the code to remind yourself to come back and re-enable them. Never take a Not Implemented exception out of the code without writing a test for it first.

With regard to Mocks and Stubs, I chose RhinoMock, but I didn’t understand that there were two versions of it floating around, and started with the older version, which, in my opinion, is much harder to use than the Act, Arrange, Assert style of the 3.5 version. And I didn’t truly understand how to use it correctly until I read Roy Osherove’s book ‘The Art of Unit Testing’ just last month. I highly recommend this book, and have been pushing it down the throats of all the developers and QA’s here.

Finally, trying to break the cycle of developers not thinking they have enough time to write tests is a huge effort. It does take time to write good tests. It takes a lot more time when you don’t know what you are doing, when the technology and the concepts are all new. Learning TDD and RhinoMock, on top of learning the other new technologies that were part of this project became a daunting task for everyone. Learning TDD was pushed to the bottom of the list as we strived for results in early stages of the project, and the unit tests suffered. Later in the project, we came back around, and made a few other valiant attempts at it, but we definitely could have done better, and I know we will on the next one. It’s about educating ourselves, a little at a time, on processes that do and don’t work, and making adjustment as we go. We tried a lot of big changes on this project, and it may have been too much, too fast. But TDD is definitely something I am not giving up on, and will use it where ever we can in the future.

Demo Showcase Suite – A History – Part 4

2009-07-20T08:34:00.001-07:00

A continuation of the lessons I learned from previous projects.

Lesson 2: I wanted to accurately track scope changes

If you’ve never been burned by a scope change that wasn’t accurately tracked, this might not seem important. This is an agile environment you say. You should be able to adjust your plan every couple of weeks. You start the project knowing full well that you don’t know everything. That’s what agile is all about. Well, as a developer I used to work with said frequently, yes, and no.

I’m not an expert on agile. I’m sure I’m doing it wrong, and about to give bad advice. I know requirements will change as the product comes to life. Feedback will drive changes. Features that were once viewed as critical will be swept aside as new features take center stage. I know this. I just don’t like it. I like having a nice stable target, and a plan to get from there to here. I hate surprises. In my work, surprises are never good. I’m never pleasantly surprised by a customer request. I’m never optimistic about a conversation that starts with ‘What would it take to…?’. Remember, I’m not in sales. I have to get the app built. I rely on sales and the product owner to drum up new business. I have to get ‘er done.

I know these changes are going to happen, and I know I’m going to grump about it as I try to protect the team. That’s my job. But I also know that customers have extremely short memories. They never remember, and they hate being reminded, that the change they asked for resulted in the two week launch delay, or another feature being pushed to a follow-on release. I’ve actually been on projects where I had multiple customers who all thought they were in charge of the product, and didn’t like the final product because someone else made a change to our marching orders without informing them.

This all comes back to the change tracking section at the top of the requirements document. Every change has to be annotated there, even if the change tracking is turned on in the document. Changes can be ‘Accepted’, and the history can be lost. Religious adherence to updating the change tracking section is the great equalizer to the argument over why something changed, was late, or was missing.

As time went on, and the project evolved, we began adding the changes into our change management system (TFS), but at the start, we used plain old Word documents. I’ll get into TFS and our development infrastructure later. That’s a whole other conversation.

Was this approach successful? I think so. Unlike other projects, there were no last minute surprises from the client. There were no gaping holes in the product that were missed requirements. The customer was (I think) quite happy. But I haven’t had to go back to those documents yet. Maybe we just did a good job with them in the first place, or maybe we haven’t stepped back and looked hard enough yet.

Regardless, it’s a practice I intend to keep doing, one way or another.

Demo Showcase Suite – A History – Part 3

2009-07-17T11:05:00.001-07:00

In my last post, I detailed 10 things that were on my mind when we started the project. I’m going to go into a little bit of depth on those now.

1. I wanted specs that were easy to write, easy to read, and easy to maintain.

I’ve done a lot of projects, in a lot of styles. My first project was back in 1994 working for EDS on a General Motors project called ASPEN, building the new Assembly Line Support and Production Environment. To this date, it is still the largest project I’ve ever worked on, even though I was just a minion on the production support team running the nightly builds, managing the source code repository and fixing bugs. It was a typical waterfall project with 60+ developers and analysts and thousands of pages of specs written and managed by an entire team of people. That works great when you have an entire team of people to manage the docs.

Most of the rest of my career has been on projects with 5 or fewer people on the team, where once a spec was created, it was forgotten about, or rarely ever referred to again after the initial development was done. In one of the projects I worked on last year, the specs were pretty sparse, the details and functionality hidden in poorly formatted emails that were chopped up and inserted into a Word doc. Some emails never made it into the docs. Some changes were done by a phone call request or hallway conversation. There was no continuity, and the specs were never maintained after development began, even when change requests came in from the customer. Scope creep was inevitable, and it led to a lot of issues in the final release as to what was, and what wasn’t supposed to be included in the final deal. We had to hunt through email to figure it all out. That memory was fresh in my mind when we started Demo Showcase, and I vowed to prevent that from happening again.

Still, with a small team, limited time, and final requirements that weren’t yet ready, I couldn’t implement full fledged specs. I started simple, using very simplified UML diagrams like the following built in Visio:

I stole this concept from someone else’s blog (don’t remember where now, or I would pass the credit). My wife, who is a project manager by profession, had never seen something like this, and really liked it. It allowed me to build up a list of high and medium level functions and to group those functions into our release plan. We could easily sit down with the customer and review what would, and wouldn’t be in each release, and walk through the app functionality. We took this diagram into meetings with a projector, edited it, and moved things around. If something needed a deeper level of documentation here, we added it, but in general, two levels was enough, and we never went deeper than three. If a function had more than three, it was a candidate for a ‘use case’ of its own.

It’s extremely easy to train management, customers and developers to read this diagram. It’s almost obscenely easy. The only problem I had was with Visio trying to move the bubbles around for me when I was adding a new one.

Once the diagram was flushed out, we split up the work between three of us (the Project Manager, the Product Owner, and myself) to create a set of Word documents with more detail for each function, which became, not coincidentally, the Functional Spec.

For each level 1 bubble (use case), we had a section in the document. This document was maintained throughout the project by the QA Team and the Project Manager. It had a change log at the top, and changes were tracked. We did a final walkthrough of each document prior to starting the development on that part of the project that caught a lot of issues. That’s not to say we had completely flushed out all the details, but it was amazing how much we could put down in a short amount of time.

The QA’s test cases came right from this document. If there was a discrepancy between the test and the app, the document won out, or at the very least, it was updated to reflect the change. If changes started to sneak into the app without being updated in here, the QA knew pretty quickly.

Again, this document didn’t go down to the line level in the code, but if there was a particular architecture I wanted to use, a trick in program flow, or some other note I wanted to add, I put it in here. No searching around for miscellaneous emails, no arguments about who told who what.

I’m not saying this was perfectly executed all the time, but our QA’s did an excellent job of holding both the developers’ and the PM’s feet to the fire and trying to keep this in good shape. Hopefully, on the next project, and the one after that, this becomes second nature, and it just gets done.

Of the things we did right on this project, this has to be at the top of the list. Before we did this, we were headed down a very chaotic road, and the developers had that look on their faces that signaled we were in for a mutiny if we didn’t get our management act together. This at least put off the mutiny for a couple of months.

Demo Showcase Suite – A History – Part 2

2009-07-16T15:31:00.001-07:00

Before I go into the details of what we did during the project, I’m going to cover two areas: my role in the project, and the lessons I learned from previous projects and what I tried to do in this project to use those lessons.

First, I was the technical architect on the project. At a small company, that can be a blurry title, and there were times where I ranged outside of what would normally be expected of the application architect. What it meant to me was that I focused less on what the application did, and more on how it did it. For instance, I chose the technologies, and resolved technical problems, but there were screens in the applications that I never saw until the project was almost complete. There may still be screens out there that I have never seen. I know for sure I have never looked at the help file in the application. As long as it is there, I wasn’t concerned with it. It is there, isn’t it?

In an ideal world, the application architect is the second busiest person during the first phase of the project. The busiest should be the Project Manager / Product Owner as they gather requirements, get customers to sign off and kick out specs. During the first months, I spent a lot of time trying to figure out how I wanted the project to work, what technologies I was willing to work with, and which ones I couldn’t risk. This project was all about new technologies, and we were banking a lot of our project success on technology that didn’t even exist yet, but that was due to be delivered to us by a certain date. i.e. The ability to run native code in Azure apps didn’t exist when we started in January, but was delivered in March.

Once the project gets going, gets traction, the architect should be able to slowly step aside and let the developers develop, and let the testers test. My role was to then became the problem solver. When a problem popped up that blocked development, I stepped in, took the issue, and tried to find a solution that worked within the overall architecture. Sometimes that was a matter of interfacing with the Azure team, sometimes that was a weekend of trying to figure out how to create Undo / Redo patterns in Entity Framework with SQL Server CE.

The theory is that by the last few releases, the architecture work is done, and I could move on to the next phase, or the next project, gradually reducing my time dedicated to the project so that when the devs are done, the next project was ready to go, and a consistent pace could be sustained throughout the project and the year. In theory. We’ll come back to that later.

As far as lessons go, I’d learned a lot in the last year working on those three or four other projects, and, of course, had a dozen plus years of experience on other projects. Here were the chief thoughts on my mind when we started:

I wanted specs that were easy to write, easy to read, and easy to maintain.
I wanted to accurately track scope changes.
I wanted unit tests.
I didn’t want to get to a week from the delivery date, need to make a change, and have to regression test everything by hand
I wanted the team to feel the urgency of working hard and smart early in the project to avoid the death march mindset at the end.
I wanted to plan for change, both in scope, the composition of the development team, technology and time lines.
I wanted a reliable build and deployment process from the start.
I wanted the team to be able to provide me with feedback quickly and easily and to give both myself and the PM a heads up well in advance of a red flag issue becoming critical. No surprises.
I wanted an architecture that minimized code smell, and one I could proudly show off as the best we could possibly do
I wanted to enrich my technical knowledge base.

Only one of these goals would I consider an architectural goal. But all of them tie into making the project, and the company successful. Some of these goals we achieved, some we got close to achieving, and some I plan to work towards achieving on the next project with the lessons learned on this one.

I’ll go into each one of these in the next entry in this series.

Demo Showcase Suite – A History – Part 1

2009-07-14T11:37:00.001-07:00

I work for a small software consulting company that had been doing work for Microsoft for a number of years, creating the original Contoso Demo Showcase demos that were available on the Microsoft Partner web site. By October of 2008, we had created over 200 of these demos in eight different languages (so about 25 in English that had been translated 8 times), with each one taking anywhere from two to six weeks to create. Much of this work was done before I had ever joined the company in January 2008, but I witnessed many of the late nights and long weekends that it took to get a demo just right by manually shooting each screen, and building a WPF executable from a series of screen shots. Some of these demos had 200-300 screen shots in each, and a missed step or slightly misplaced hotspot would cost hours of work. The developers had built some tools, and an engine to run the sims, but both needed a lot of work to make them usable for a non-developer user. I think the developers on that original effort are still having nightmares about it. They do get the shivers when you mention it.

In October of 2008, I had just finished three projects for other customers, one small ASP.NET website, one large ASP.NET website, and a major upgrade to a very large Win Forms application in C#. Throughout those three projects, I kept a mental list of what we did right, and what we did wrong, with the intent of applying the lessons to the next project.

Dan, one of the owners of the company I work for, who doesn’t like being called my boss, told me at the beginning of October that he was lining up my next project, and that it would be huge. It would involve this idea they had sold to Microsoft to automate the production of these demos. Dan and Benjamin, the other partner here, dropped some big Microsoft names into the conversation to entice the glory hound in me out of hiding. I didn’t know anything about the project at this point, and though I was flattered by the trust they were putting in me, and excited by the possibility of working on a big, high profile project, I was nervous about being associated with this Contoso project and the late nights that I heard had come with it. They assured me those days were over. This was a completely different project. Yes. It was.

I was a couple of weeks late getting started on the project as I had to wrap up one of my previous projects. It’s never good to start out behind the eight ball, but in the scheme of things, that wasn’t a major impact on the project. I officially started looking at the project documents on Friday, October 24th. I remember going home all excited to be working on something new, starting from the ground up. I returned on Monday morning, October 27th, and started digging in to the project in more detail, and started to outline my approach. We were going to do this one right.

On Tuesday, October 28th, my boss sent me a note, asking if I heard of this Azure thing Microsoft had just launched, and wondered if it might be worth looking into for this project. Sure, why not? The Microsoft PDC in Los Angeles was going on that day, and info was coming out fast. I spent the afternoon watching the PDC presentations on my pc. By noon the next day, I reported to Dan that Azure looked pretty cool, and that it would save us a bunch of time doing the hard things. Scaling with load, synchronization, blob storage, queues, security. All things we had dealt with on previous projects that caused us major issues. Developers could focus on the business app, and not on the environment. Perfect. I don’t remember his exact words, but it was something like “Good, because the customer wants the site built on Azure.”

I had never worked on a project with an OS that was in CTP. Hell, I had never worked on a project that involved any CTP technology. I came from a business systems background that waited at least a year and a half after software was released before using it. In 2007 at my last job, we were barely upgraded to Visual Studio 2005. I didn’t know what CTP meant. CTP is after Beta, right? Well, not exactly.

We started the project with a Proof of Concept application. There was the web site (at the time called Simulation Server), a web service (SimSync), a web app (SimBuilder), a WPF Simulation Engine (SimEngine) and a Windows Service (SimCompiler). Azure wasn’t quite ready for us to use, and we were still working out the details of getting into the Azure early adopter program, so we deployed the POC in a Win2K8 / SQL Server environment. We delivered the POC a week or two before Christmas to give the execs a chance to look it over, and to get a feel for the project before we really dug in.

We took the time during the Christmas lull to get fully indoctrinated with Azure, to begin to flush out a few details, to organize ourselves, and to begin to look at some of the more complicated features. We also took the time to take a well deserved break while the details of the system got worked out. We knew there would be a lot of work to do after the New Year.

We were accepted into the Azure early adopter program in late December. The execs signed off on the project in early January. Everyone was rested and raring to go. It was time to get coding.

To be continued…

Demo Showcase Suite Launch

2009-07-13T12:29:00.001-07:00

This blog has been a little devoid of content for the last few months. It’s not because I had nothing to say, it was because everything I had to say, couldn’t be said. The three letters a blogger hates to hear are ‘N D A’, non-disclosure agreement. There are still a few things I can’t talk about, but by and large, the ban has been lifted.

This morning, at 9:00 AM Central Time, Allison Watson, Corporate VP of the Microsoft World Wide Partner Group, announced the release of Demo Showcase Suite.

“Microsoft’s® Demo Showcase Suite is a collection of demonstration resources that includes the new Demo Showcase application for creating your own click-through demos as well as this community site to manage your demos, search for demos, distribute demos you’ve created and stitch different demos together to make your own. Sign in with Windows Live ID and take a look through this site and download the Demo Showcase application to get started creating your own demos that you can share through Silverlight or download as standalone executables”

For the last 9 months, I have been immersed in this project as the lead architect. It’s the biggest project I’ve ever led, and a high water mark in my career. With a small team of developers and QA’s, we turned out a product that we are all quite proud of.

You can see what the app does by going out and using it. I’m going to focus my next few blog posts on the architecture of the product, the history of the project, and lessons and technology we learned while doing it. For those of you that can’t wait, here’s a brief sample of the technologies we used (in no particular order):

Windows Azure
Windows Live ID Authentication
Unity Framework + Enterprise Application Blocks
Entity Framework
LinqToSql
WPF
MVVM in WPF
Silverlight 2
ASP.NET
Test Driven Development
Microsoft Geneva Framework
ACS
SQL Server 2008
Custom ASP.NET Handlers
Object Graphs in EF using QuickGraph.NET
ASP.NET Dynamic Data
WCF
REST
RSS Feeds
Custom WPF Compilation Engine
Log4Net
ASP.NET AJAX
Resharper 4.5

As you can imagine, things are still kind of hectic around here today. I’ll try to update the blog this week with more details. For now, go give the app a try. If you can’t get to it because you are not a partner, please contact Microsoft Partner Group, and get enrolled today!

Allow MSI Downloads on ASP.NET Web Site

2009-07-09T07:54:00.001-07:00

I can't tell you how many hours I spent over the last few weeks trying to debug a problem with a web site where we were trying to allow users to download an MSI from a blob. Sometimes it would work the first time, and then the next time, the site would try to download the .aspx file the code was running in.

What made it really confusing was that this problem only happened when we were running in Azure with IE 8. In IIS 7 running on Win2K8, it was fine. With Azure and FireFox, it was fine. At one point, we had it working on everything except IE 8 running on Windows 7 with a backend of Azure.

What I finally had to do, was to create an ASP.NET Generic Handler (ashx) that did the heavy lifting for me. To give credit where credit is due, the suggestion came from someone I met while at the latest NerdDinner in Bellevue, WA on July 7. (I wish I could give you his name, but I do know he was on the ADO.NET Services Team at Microsoft) This is the second time that I have attended one of those dinners, and the second time I was able to solve a problem the next day based on advice given to me by someone there. Many thanks to Scott Hanselman for getting these events put together.

Here was the final code:

     public class MsiDownload : IHttpHandler

    {

        protected readonly ILog _log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        public void ProcessRequest(HttpContext context)

        {

            string msiName = ConfigurationManager.AppSettings.Get("MSIName");

            byte[] returnedBytes = null;

            var blobManager = UnityFactory.Current.Resolve<IBlobManager>();

            try

            {

                returnedBytes = blobManager.GetMsi(msiName);

                if (returnedBytes == null)

                {

                    _log.ErrorFormat("Error obtaining MSI from blob storage service. Returned bytes is zero length.");

                }

            }

            catch (Exception exc)

            {

                _log.ErrorFormat("Error obtaining MSI from blob storage service. Exception type: {0}, Exception Message {1}.", exc.GetType().ToString(), exc.Message);

            }

            if (returnedBytes != null)

            {

                context.Response.Buffer = true;

                // force download

                context.Response.ContentType = "application/x-msi;";

                context.Response.AppendHeader("X-Content-Type-Options", "nosniff");

                context.Response.AppendHeader("content-disposition", "attachment; filename=" + msiName);

                context.Response.AppendHeader("Content-Length", returnedBytes.Count().ToString());

                context.Response.OutputStream.Write(returnedBytes, 0, returnedBytes.Count());

                context.Response.Flush();

                context.Response.End();

            }        

        }

        public bool IsReusable

        {

            get

            {

                return false;

            }

        }

    }

Rhino Mock Error - rhino mocks requires a return value or an exception to throw

2009-02-19T08:55:00.000-08:00

Sometimes it's just a matter of googling the right thing. I was trying to show someone how easy it was to develop mocks to help test, and wouldn't you know it, I kept getting errors in my test harness that I couldn't figure out. I thought it was because we were testing an object with a read only property and using the AutoMockingUnityContainer, but when I was finally smart enough to google the real exception being thrown:

rhino mocks requires a return value or an exception to throw

It immediately led me to this wonderful solution.

http://codemonkey.nmonta.com/2008/09/19/previous-method-requires-a-return-value-or-an-exception-to-throw/

Google FTW.

Book Review: Architecting Applications for the Enterprise

2009-02-19T07:26:00.000-08:00

This morning I finished reading Dino Esposito's and Andrea Saltarello's book Microsoft .NET: Architecting Applications for the Enterprise. The highest praise for a technical book is that it immediately affected not just the work I was doing, but the way I work. This one did just that.

I've been writing code since I was 8 years old on my school's Commodore PET. That's was almost 30 years ago now. I've been doing it as a career since 1994. I started designing applications (as opposed to just being a code monkey), in 1997. I became what my company calls an Architect last year.

But I didn't start to think like an architect until just recently, and this book, which I power read over the course of 6 days, has had a profound impact on how I see my role within the company, and how I need to work to make myself, and my team more efficient. I've been bringing in tools and processes the last year or so to fix the low hanging fruit, but I still considered myself a developer first, and considered the architect role to be something I did between writing classes and specs.

The first half of this book is about the process. And though the first chapter is a little, um, dry (probably a few too many references to ISO and IEEE), it does help to build the profile for where an architect fits into an organization (big and small). These guys have been there, and done systems development where there is a client involved in the process. They aren't people who have been at some big software company and don't know what is involved in developing line of business software with a client who has no idea what it is they want when the project starts.

The second half of the book talks about application layers: The Business Layer, The Data Access Layer, The Service Layer and The Presentation Layer. I've worked in all these layers at one time or another, but it's only quite recently that I have truly begun to understand the Separation of Concerns rules, and things like dependency injection. This book not only helped top clarify these things in my mind so I can better understand all the other reading that I do that assumes that I know what SoC mean, but it also talked about misconceptions about the layers. I found the section on the service layer particularly appropriate because for a long time, I completely misunderstood Service Oriented Architecture. They cleared this concept up for me in a way no other publication ever has. I wish I had read that 4 years ago. I once built a 'Service Oriented Architecture' application with 80+ web services! What was I thinking?

My favorite part of the book was the 10 Final thoughts, their mantra as they call it. These were spot on, and proved to me that they had been there, and done that, when it came to developing real world applications. It gave them 'geek cred'.

The target audience for this book is probably senior devs and architects. It's probably too high up for low level devs to be interested in (though they should be). I highly recommend it for anyone who is moving up out of the weeds, and anyone who wants a high level picture of some of the most common design patterns in .NET.

The next book I'll be cracking open (tonight on the train ride home), is Julia Lerman's "Programming Entity Framework". 800 pages of data access goodness. Oh My!

MS-Test - Not Executed Error

2009-02-18T07:00:00.000-08:00

I've finally found out what the issue was with my MS-Test harness, and why I am the only one currently seeing this issue in my office.

First I needed to turn on logging for MS-Test. Here's a link on how to do that.
http://blogs.msdn.com/yutong/archive/2006/10/03/How-to-Enable-VSTS-Logging_3F00_.aspx

Then, once I ran my tests, and looked in the log, I saw the following error message:

The Visual Studio performance and coverage logging engine is already running on the computer. Therefore, the test run cannot continue. Close the pending performance or code coverage session and then rerun the tests.

Here's a link to the fix
http://platinumdogs.wordpress.com/2007/12/

I'm the only one in the office having this problem, because I am the only one with VS2008 Team System Team Suite and running code coverage and analysis.

I also suspect that I'm the only one who's pounding out all the test code they need to be writing right now, but that's going to change. Soon.

Windows Explorer --- Grrr

2009-02-18T06:43:00.000-08:00

Okay, I try not to say anything bad about software that a lot of work has gone into, because, well, I know how hard it is to get it right.

But yesterday I needed to fix a problem on out Team Foundation Server. I needed to get my hands on an executable called TF.EXE. It wasn't (for whatever reason) on my TFS server. Fine, it was supposed to be on my machine (since I have just about every freaking product known to man on my machine it seems). I tried to save myself time by doing a search from my Vista File Explorer (or whatever it is officially called these days). Nothing came back. I hunted around a little bit, searched the web a little bit, and finally just gave up and worked around my problem.

This morning, while fighting another MS-Test - tests not executed issue (if I get one more of these freaking things, I'm going back to NUnit), I stumbled across my C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE directory, and lo and behold, there's TF.exe.

So can someone tell me why the hell File Explorer couldn't find it for me yesterday and save me a hour of my time? Why even bother putting the freaking search tool there if it doesn't work? Anyone? Is there a trick to making it search the whole drive? Arrrgggh.

What a great way to start the day!

MSTest - Grrrrrr

2009-02-16T11:22:00.000-08:00

I spent two hours plus this mornign trying to find out why my test harnesses all started returning 'Not Executed' when I ran in 'Run Tests in Current Context", but worked fine in "Debug Tests in Current Context". The tests worked on everyone else's computers.

The solution...

I deleted my entire solution folder, and did a get latest from TFS. What a pain in the ass. I was this close to converting back to NUnit.

Design for Reuse?

2009-02-16T08:48:00.000-08:00

I've been reading "Microsoft .NET: Architecting Applications for the Enterprise" by Dino Esposito and Andrea Salterello the last few days, and really enjoying it. It's not a detailed coding book, but discusses patterns and approaches, and is bringing me up to speed on some of the areas of development I haven't yet explored, or have explored but need a refresher on. I actually found myself sitting on the couch on Saturday afternoon while the kids were asleep, reading it because it applies directly to what I am doing this week.

One of the points it made (I should have highlighted it, because I can't find the page now), is that you put interfaces on classes not for reusability, but for replacability. That's a whole paradigm change from what I use to do, but have now adopted with TDD and Dependency Injection.

I used to spend hours trying to factor out what I thought would be common code, and got stuck just trying to figure out how loggers would work (in days before log4net) or data access for a certain class. To me, back then, the money was in designing for future needs.

Now I realize that most of those common modules have already been written, and it saves me a lot more time and money to design each class I write with an interface and to be able to swap it out using dependency injection. I can try and guess for years what my next implementation of a business process might look like, and I will fail 99% of the time. Build what you know now, put it behind an interface, and swap out the old for the new.

It seems pretty elementary now, but even a year and a half ago, I didn't get it. It's like a huge weight has been lifted off my shoulders, and I am no longer stuck in future requirements purgatory!

Good Tests Gone Very Bad

2009-02-13T08:23:00.000-08:00

I've been writing dozens of tests lately as I have completely bought in to the TDD methodology. I've even turned on code coverage in Team Suite to see just how I'm doing. This may not be a great thing to do if you suffer from OCD, but it sure has helped me to better understand my code. It helps even more when I am walking through other people's code trying to debug something, as I run their tests first, check to see if any lines of code haven't executed as expected, and then write a test to try to execute that code as I would expect. If I still don't get there, I know one of the core assumptions elsewhere is wrong. Its a lot faster than stepping through hundreds of lines of code. It focuses my attention to the problem area much more quickly.

Yesterday morning, I was flying along, writing code, and writing tests, and one of the other developers here came by to ask how to properly test his ViewModel that depended on checking various items on the file system (i.e. does a directory exist, if not, create it).

We're using Rhino Mocks, not TypeMock isolator, so the fact that these System.IO classes are static means that we can't mock them. A little searching revealed that our best option was to create an IFileManager interface with a FileManager class under it, and mock the interface. Not my favorite thing to do, but it works.

I wrote the tests for the new class, and they ran fine.

Then we added that class to my co-worker's class and exposed a property on his interface / class for the IFileManager so that we could pass in a mock.

I ran his tests for his class in debug mode. It worked. Cool.

We wrote some new tests to pass in the mock, and ran those in debug mode. They worked as expected. Awesome!

But here's where things got hairy.

We went to my test list editor, and added them to our global test list, and reran the tests. The failed with a 'Could not load type error'. Hmmm. Must be something wrong with my set up / tear down. So I reran just one of the tests from the test list editor. Still failed. Okay, back to the code. Rerun the test in debug mode. It works. Run the test in 'Run' mode. It fails. WTF?

Check my tests on the FileManager class. They work fine.

Strip the new code out of the ViewModel class. Run the original tests. Pass.

Run the new tests. Fail. Same error. Wait... the class it says it can't load is the class we have completely commented out. Except we left in the using statement. Comment that out. Build. Still failed, same message.

At this point I'm getting pretty PO'd. I force a clean on my whole solution, and rebuild. Tests pass. WTF?

Start adding code back in. Add the using statement. Pass.

Add the reference to the interface. Failed.

Pull the mocking code out of the tests, pass in a real object (not generated by the AutoMockingUnityContainer). Pass. Okay, it's somewhere in the Unity Code. We're now 2 hours into this. I went through this a dozen times, various combinations, until it finally hit me.

The problem wasn't that it couldn't load my FileManager class. By this time, that class had nothing left in it beside a couple of boolean functions that always returned true. What had happened was that immediately before I had been asked to look at this issue, I had installed the October 2008 release of the Enterprise Application Library (Version 4.1) to make use of the Validation Application Block. I had previously just installed the Unity Framework separately. I now had two versions of the Unity Framework installed on my machine, with the same version numbers, but from different locations on my machine.

I uninstalled the Enterprise Library, restarted my IDE, and ran my tests successfully. I readded all the code I had commented out, and the tests ran as expected. I think we spent three hours on this one yesterday (x2 since two of us were trying to figure it out)

Now I have to decide when to have the team install the app blocks on thier machines, and to remind them to unistall Unity and any old versions first.

Random VS2008 Crashes

2009-02-13T08:17:00.000-08:00

For the past few weeks, I've been having a lot of problems with VS2008 crashing randomly on my PC. I've been installing a lot of tools and components lately, so I have little doubt that something I've installed recently was causing it to BSOD (Black Screen of Death in this case).

This morning, I was trying to add the Microsoft.IdentityModel.dll to my tool box, and it kept crashing. I finally had enough, and decided to Google for a solution. The link below fixed the problem on the first try. Yes!

http://www.tech-archive.net/Archive/VisualStudio/microsoft.public.vsnet.ide/2008-03/msg00083.html

Sometimes it pays to spend 2 minutes fixing the problem instead of just ignoring it and hoping it will go away.

AutoMockingUnityContainer and Rhino Mock

2009-02-04T12:08:00.001-08:00

I've been putting a lot of time into understanding TDD and Mocking the last few weeks. Combine that with Unity, and it's a lot of stuff to get a grip on.

I've been going with Rhino Mock as my mocking framework, and it seems to work okay as long as you are developing new code. If I were working on legacy code, I think it's pretty clear you would want to use TypeMock Isolator. You could justify the expense pretty quickly.

I was trying to use Roy Osherove's AutoMockingUnityContainer to make my test fixtures perfect, since I am setting up the model for all the other devs to follow. Roy published this back in April 2008, and since then, Rhino Mock has released a new version that makes use of lambda expressions to eliminate the need to do the mocks.Record step. Instead, you should be able to do the following:


   ILogger logger = container.Resolve();
   logger.Stub(x => x.IsLogFileFull()).Returns(true);

I say should, because this is what I understand. I may have misunderstood.

This should force the IsLogFileFull to always return true when called in the example Roy shows. But for some reason, it always returns false for me. I went through a hundred iterations of code, and ended up going back to the original syntax, which isn't quite as clear, but works.

I will say that my "Logger" class is not passed into the constructor but is set as a property after the class is resolved. Maybe that is the issue, but I am testing a very high level function, and it calls a number of different classes that I want to mock / stub, and I would hate to have a class that has five or six arguments required in the constructor (even if it is just for testing sake). The class is wired up to Unity itself so I normally don't need to pass these in, just when I want to mock.

Maybe that is a reason in itself to go to TypeMock, but I need to prove to my folks here that TDD and Mocking is going to pay off at all, before I try to prove that we need to spend more money to do it.

So much, so fast

2009-01-21T19:28:00.000-08:00

One of the toughest things about being an application architect at a small company is needing to know everything about everything, yesterday. I'm working on a very large project right now, and I need to get in depth with a huge number of topics, all at once, just to get the project kicked off. Other parts of the team are sitting on their hands waiting for me to get stuff done, and I hate being a bottleneck. It makes for some very busy days where I don't seem to get a lot done, or get to know as much about a topic as I really need to to make sure I am pushing us in the right direction.

For instance, today was a fairly typical day.

I spent an hour reading through emails and blogs this morning as I ate my breakfast and chatted about the inauguration in my office.

I then reviewed a spec I had written yesterday on Security Authentication, Authorization and Threat Modelling for my project. I had to go back and dig into the Geneva Framework and the .NET Access Control Service to see how close I was to the mark. I've got a real fear that I need to become a lot more familiar with threat modelling before I can consider this spec complete, or I need to con someone else in the office into become the SME on Security.

I spent two hours writing an application specific functional spec for a WCF Based Azure Web Service, mostly dealing with the 'what' side of the house, i.e. what it's supposed to do, but leaving out the 'how', i.e. how it's going to do what it has to do. This particular piece of the project is one of the more important aspects because the service has to be very secure, has a lot of validation built into it to prevent corrupt data from being uploaded or downloaded, and I had to build in a migration path to eventually move from one version of the service to the next without breaking existing clients. I actually took the time to put a lot of thought into that mechanism, but the spec isn't close enough to be ready to turn over to a developer (unless it is me), because I didn't cover any of the aspects of Azure or Geneva that need to be covered in a 'how' spec.

I spent an hour and a half re-arranging projects in my Team Foundation Server project to try to get everything organized and clean, the way I want it. This involved changing some namespaces, and working through a real bastard of a problem involving a confusion between the Silverlight Unity Framework and the Windows Unity Framework. Somehow the Silverlight Unity DLL had been linked into one of the non-Silverlight projects, and nothing was compiling. This problem came on the heels of a similar issue yesterday where the ICommand interface I was using in one of my projects got linked to System.Windows.Input instead of the PresentationCore library. That cost me three hours yesterday. I really need to lock down my project files (usually from myself).

I then spent 2 hours delving back into the MVVM pattern for WPF development to figure out how exactly to launch dialog boxes and other windows from a view in the 'correct' way. Where exactly does the code go to 'new' the view, and which view model do you bind it to? That's a whole blog post unto itself. I've just started with the MVVM pattern, and it's powerful, but in trying to explain it to a junior dev, he kept asking me how the View Model in our scenario wasn't just a big global variable, albeit a global variable with a lot of pizazz. It's those type of questions that lead me to doubt my understanding of the pattern, and I ended up spending a lot more time trying to explain the pattern to myself again, but we all came away with a slightly more enlightened view.

I spent an hour this afternoon trying to turn an XSD file into classes using XSD.exe and then trying to figure out how to turn those classes into database tables. We probably should have gone the other way and started with tables, but that's a whole other discussion. I'll have to finish that task tomorrow.

I also spent twenty minutes trying to help our project manager tie TFS Work Items to MS Project properly. We want to have two different project plan views, one for internal use, and one, a higher level view, for the customer, but we don't want to maintain the tasks in two places. We're working through some theories on exactly how to do that. I've never used TFS prior to this project, so we're learning some interesting lessons.

Tomorrow, I need to get a handle on the project plan as it is due by Friday. I need to review the WCF spec I did, get the classes converted to database tables, spin up an entity framework model for them, dig into SDS and attempt to migrate a SQL 2008 Data model into SDS, and then I'll need to map that back to my Conceptual Object model in EF. That exercise is also an upcoming blog post. And oh yeah, I need to build out the Access Control functionality so I can set up the 'how to' spec for the WCF services. Right after I finish the first draft of some other functional specs for the other applications we're designing so the QA team can start writing their test plans.

Nerd Dinner, Recap

2009-01-20T08:29:00.000-08:00

I didn't quite know what to expect when I decided to go to my first Nerd Dinner last night. I was a little nervous, a little intimidated, and a lot worried that I would look like a complete idiot. I shouldn't have been nervous. I was more in awe of the opportunity than intimidated by the folks there. And I hope I wasn't a complete idiot.

I got to meet Scott Hanselman right off the bat (He sat down next to me). To my left, was one of the architects of VB.NET. I spent time talking with them about LINQ to SQL and my experience with the Entity Framework, and Scott encouraged me to blog about my experience working with both in the real world. I'll try to do that as soon as I can catch my breath and test out one more feature of EF.

We shuffled seats every 15 minutes or so, and I took the opportunity to get to meet a bunch of folks on the F#, C#, VB.NET teams, as well as the Silverlight Teams (working on the Line Of Business Toolkit, something I am really excited about), and the Powershell/WPF Team. Everyone was so friendly, and genuinely interested in hearing about my projects, and giving pointers on how to do things a little better and a little easier.

The last group I sat down with included Glenn Block, the Project Lead for the Managed Extensibility Framework. We got into a deep discussion of test driven development, something I am working on implement at my company. He brought in a crowd of people to contribute to the discussion and I learned a lot! I wish I had written down everyone's names to thank them later. Here are some of the points they made, paraphrased of course. My ehad was spinnign by this point in the evening.

They stressed a couple of fundamentals for how to do it (we all understood why TDD is important).

1. There are two types of unit tests: functional tests, and acceptance or validation tests
2. Functional tests should be written by the developer as they are writing the code to exercise the code they are writing. They should still write the test before the code, but the two are written at roughly the same time. Test what you are coding so you know why you are coding it.
3. Validation Tests can be written by the QA’s to test edge cases and to try things to make the dev cry, but have the benefit of being repeatable to save the QA time from needing to show the developer exactly what they did to break the code.

This is a little different from my original understanding of TDD and how I had envisioned we would implement it, but they were quite clear that we were headed for trouble if we tried to let the QA’s write all the cases. Not because the QA’s couldn’t do it, it was that the developers lost the advantages of writing their own tests to help them understand the requirements they were developing against. It helps to make the code clear and concise and to expose code ‘smell’ early on in the process.

The QA’s can still help to identify and clarify the requirements of each function, but it’s not until the developer believes they have met the functional requirements of the component that the validation tests should begin.
Anyway, I hope to go to many more of these dinners, and highly recommend it for anyone who wants the opporutnity to talk with, and listen to some of the really big thinkers in the development industry. My head was spinning the whole way home.

Nerd Dinner

2009-01-16T07:59:00.000-08:00

Scott Hanselman is hosting the January Nerd Dinner in Bellevue, and it looks like I am going to be able to make it this time. I'm excited to get to meet all these folks that provide so many answers to my questions. If you see me there, and you ever read this blog, say hi if you see me.

A New Year

2009-01-08T20:10:00.000-08:00

Yesterday, was the one year anniversary of starting my new job. So at this point, I guess I can stop calling it my 'new' job, and just call it my job.

Professionally, it's been a whirlwind of a year, and 2009 looks to be even more of a technical blizzard. When 2008 started, I was pretty proficient at C#, knew Informix pretty well, and knew a lot about the airline business. But when I made the jump from the IT division at an airline, to a position as a Senior Systems Analyst for a small software consulting firm, I viwed to learn some new skills, and to really put my nose to the grind stone for a few months to get 'caught up' on technology. Little did I know that it's pretty much impossible to get 'caught up'. But here's what I did get experience in during 2008. This isn't just 'I read the book', but real, systems to production experience.

1. Visual Studio 2008
2. Resharper 4
3. LINQ to SQL
4. Microsoft Component Application Blocks (Version 1 for VS 2005)
5. The Model - View - Controller Pattern
6. SQL Server 2000
7. SQL Server 2005
8. ASP.NET 3.5
9. VB.NET
10. ASP.NET AJAX
11. SQL Reporting Services

All of that before the beginning of November 2008. I draw the line there, because in November, I started a new project that currently has me buried in the following technologies

1. WPF
2. Silverlight 2.0
3. SQL Server 2008
4. Team Foundation Services
5. MS Test & Test Driven Development
6. Microsoft Azure
7. Microsoft SQL Data Services
8. Microsoft Sync Framework
9. Microsoft Unity Dependency Injection Framework
10. Rhino Mock
11. Geneva / Microsoft Data Access Control Service
12. SQL Server CE
13. Microsoft Entity Framework

By the end of the year, I hope to be proficient in all of these topics. Actually, hope isn't a strong enough word. I need to be proficient in all of these topics. Right now, my head is spining a bit, and the new stuff is coming faster than my brain can absorb it all. But a year ago I had no idea what LINQ was, now I can't work without it.

I just have to wonder though. If this is what I have planned, what else could possibly come along later in the year?

Getting Started with Azure

2008-12-10T09:24:00.000-08:00

Since the Microsoft PDC at the end of October, I've been tasked with digging into Windows Azure to see where it might fit into plans for a project we are working on. I've had to merge this responsibility in with the rest of my daily responsibilities designing and building other applications, so I end up starting and stopping a lot on my research. It's great that my job offers me not only the opportunity to do these things, but the flexibility to even consider using technologies that are barely CTP for projects that we need to deliver within the next year.

I've done a lot of research, but I don't think I've even seen the tip of the iceberg yet on what is involved in designing a real, production application for Azure. There are so many things to consider when jumping to a completely new platform, that it's not just almost overwhelming, at times it IS completely overwhelming.

The best suggestion I could give someone who is just starting out, is to do the Hands On Labs for Azure. In fact, there are all kinds of samples to try. The difficult thing is to try to remember which ones you have done, and which ones you haven't. If I could make one suggestion to Microsoft is that they need to pull all the various SDK's and Toolkits and Samples together into one "Cloud Computing Toolkit Package" that a developer can download once, installs into one location, and provides a unified index for finding what you need quickly. I find it quite embarassing to post what I think is a valid question onto the MSDN forums only to find out that topic was well covered in an SDK Sample I just hadn't found yet. I take a lot of pride in not wasting other people's time in having them do my research for me.

Here's a list of the SDK's / Toolkits and samples available regarding The Microsoft Cloud

Azure Services Kit: Contains the Hands On Labs - Installs to c:\AzureServicesKit by default. Start with this one and go through all the labs. Every case is quite simple, but well done, thought here are a few errors in the code

Windows Azure SDK - Samples are included in a Zip file. On my machine, this installed to C:\Program Files\Windows Azure SDK

Microsoft .NET Services - Samples include AccessControl, Service Bus, Workflow and are installed on my machine to C:\Program Files (x86)\Microsoft .NET Services (Nov 2008 CTP) SDK

Microsoft Sync Framework - C:\Program Files (x86)\Microsoft SDKs\Microsoft Sync Framework

Silverlight - C:\Program Files (x86)\Microsoft SDKs\Silverlight

Microsoft SQL Server Data Services SDK - C:\Program Files (x86)\Microsoft SQL Server Data Services SDK

Windows Live ID - C:\Program Files (x86)\Windows Live ID\WebAuth\Sample

Windows Mobile - C:\Program Files (x86)\Windows Mobile 5.0 SDK R2

I'll add more links as I find them.

Fun with Entity Framework

2008-11-24T11:21:00.000-08:00

So despite spending the first 6 months of the year becoming proficient and LINQ to SQL, the realization that Microsoft was casting aside LINQ to SQL in favor of its grumpy old uncle Entity Framework made me take a serious look at the EF for my latest big project. Luckily, it hasn't had too much of a learning curve, but I haven't gotten to the hard stuff yet either. I'll need to pick up a book on it at some point, but I'm still thrashing my way through WPF at this time and don't need another book to read right now.

One thing that frustrated the crap out of us here last week was not being able to go from a child entity to a parent entity easily. That is, until I learned the trick. And there's always a trick, isn't there.

Say you have a collection of warehouses, and each warehouse has a collection of doors. Given a door id (GUID), get the warehouse it is at. The WarehouseID is foreign keyed to the Door table.

You would think (based on LINQ to SQL), that you could go Door.WarehouseID or at the very least Door.Warehouse.WarehouseID... but alas, no can do. EF hides the relationship through an object called an Entity Key. In my brain, this was a little ridiculous, since I knew what my key was, just give it to me.

But I guess this is why I don't design frameworks for a living. The Entity Key is a dictionary collection, of all the keys that make up the relationship. Thus, if you have more than one column in the key, the EntityKEy collection contains both keys, but you can access it to use those values with a little care.

By adding a property to the Door object in a partial class, you can access the dictionary to extract the value. If you have multiple values in your key, be careful to index the Key properly.



public Guid WarehouseID
{
  get
  {
     return new Guid(WarehouseReference.EntityKey.EntityKeyValues[0].Value.ToString());
  }
  set
  {
    WarehouseReference.EntityKey = new EntityKey("ContextName.Warehouse", "WarehouseID", value);
  }
}

Back from the Great Beyond

2008-11-04T10:28:00.000-08:00

Ok, I haven't been dead, I've just been time travelling. No, really. I jumped back in time to work on a big client project in Visual Studio 2005 using the Microsoft CAB and MVC pattern. While I did learn quite a bit about the client's business (which is not a bad thing), it wasn't technically challenging. In fact I slowed down on my reading of technical stuff, spent more of my free time (ok commute time), reading for fun, and writing for fun. Yes, writing can be fun too.

I also spent a lot more of my nights and weekends doing work for the project, which meant less tech reading as well. A lot of the changes I needed to make to the client systems in preparation for the rollout had to be done off hours to minimize impact on the user.

Sure, I learned a few tricks and tips in the last couple of months. I got very familiar with the Infragistics NetAdvantage Product Set, including the UltraWinGrid (very nice) and UltraWinSchedule (a little buggy in the version I had). But for the most part, I've been just churning code, doing database work, and doing rollouts.

That project is just about over now, with final rollout scheduled for this Saturday. My new project is all new technology, and I'm jumping in with both feet. I've spent the last few days watching videos, reading blogs, and running sample code.

What's got my attention, you ask? Windows Azure. Windows .NET Services. Microsoft SQL Data Services. WPF. Silverlight2. LiveMesh. Yep, 4 of those 6 things are still in CTP, and I'm jumping in with both feet. I'm not just going to be on the bleeding edge, I'm fully stabbed in the chest, in a full out ebola like blood letting.

We'll see how I feel about it in a couple of months, but right now, I'm really excited. My night stand reading is piling up with tech books and blogs. I'm not sure how much I'll be able to post, but I'll try to post hints, tips and other cool things to look at as I learn.

By the way, the current book I'm reading is Pro WPF in C# 2008. I'm just a chapter or so into it, but WPF is something I need to know inside and out for this project, so expect a few blogs on that.

Autocomplete Extender Lesson Learned, Part Two

2008-08-22T11:29:00.000-07:00

It turns out that the problems with the AutocompleteExtender actually go even deeper than the dispose problem. Or not as deep, depending on how you think about it. At some point in my effort to make my website pretty, the problem of the extender not extending after a partial postback reappeared. After spending a large, large amount of time on this, I found reference to another bug in the AJAXControlToolKit that happens if you programmatically set the focus back to the textbox associated with the extender control after doing a postback (partial or not).

I removed the set focus statement, and I am back in business. Again.

But dude, seriously?

Converting from a Web Project to Web Site

2008-08-15T08:30:00.000-07:00

If you've converted from a VS2008 Web Project to a VS2008 Web Site, and tried to bring pages from one over to the other, you may have been stuck with the issue that your code doesn't see the objects created by the aspx. i.e. the text boxes, the drop downs, etc.

After you spend a while trying to match up namespaces, and letting Resharper fix a bunch of issues for you, you may still be stuck.

Here's one thing to check:

In your page directive, check to see that the compile has chnaged the CodeBehind attribute to read CodeFile. That's got me twice now. That's reason enough to blog about it.

AJAXToolKit Autocomplete Extender Lesson learned

2008-08-15T08:16:00.000-07:00

I was migrating a series of web pages from a small web project in VS2008 to a large client web site (not a web project, a web site). One of these pages included a predicitve text field which I used the ASP.NET AJAXToolKit to implement. The Tool kit worked almost flawlessly. I say almost flawlessly because there is a major bug which prevents the AutoCompleteExtender from working if you host the control in an update panel and you have already done a partial page postback.

Luckily Aaron Schnieder has already solved this issue.
http://weblogs.asp.net/aaronschnieder/archive/2008/03/11/ajaxcontroltoolkit-autocompleteextender-bug-in-an-updatepanel.aspx

Not sure why they haven't kicked out a new version of the tool kit onto Codeplex yet, but they haven't, so you must apply this change yourself.

So after I finished migrating my pages and my web service into the web site, I went to try to run my page with my autocomplete extender, and viola - WTF? Nothing happened. Crap.

Dork around with the pages. Add break points. Google a lot. Did I recently install any VS2008 service packs? Possibly. Uninstall them. Still nothing. Google some more. Add a new web site to my solution, with code right from the AJAXToolKit (converted to VB.NET of course). Still nothing. Two more hours of trial and error. Call it a night.

Log on this morning. Dig in again. More Googling. Hey, what's that? In the new Web Service code behind file I added?

' <System.Web.Script.Services.ScriptService()> _
How come that line is commented out? By default? Yikes.

Remove the comment. Try the app again.

Presto. Back in business.

UM, um, I mean UML

2008-07-22T08:51:00.000-07:00

I'm taking a little break from Windows Workflow to refresh my knowledge of UML and Use Cases. To tell the truth, I never really bought into the whole use case stuff at my previous job. I can give a hundred excuses, all valid of course, for why I didn't believe in UML, but it was mainly because I didn't see my customers buying into the process of software development. They wanted the software. They wanted it now. They didn't want to do any work. Whatever tools we used, whatever diagrams and documentation we drew up, was for our own purposes. They never saw the use in it. By the time the diagrams were done, there was a new crisis du jour, and the last project was already passe.

But I was in a meeting with a new client last week, and one of the reasons I was being brought in to help with this project was to help build an industry standard set of requirement documents which could be handed off to the developers, whether it be my team, or someone else. I was there to do the architecture.

And on the way home that night, it hit me. I might not be there in six months to answer a developer's questions on what was needed. And they might take my name in vain. And they might say that I was incompetent. I can't afford that.

So I picked up my UML book this morning and started re-reading. Realistically, most of the stuff I already knew, but I had never formalized the terminology. I have never put UML / Use Cases on my personal resume because I lacked this formal experience with the process. So with the goal of not looking incompetent, and knowing that I would immediately apply this knowledge to my current daily responsibilities, I am digging in and now seeing the positive side of learning something that I consider 'non-technical'.

In fact, after reading the first 5 chapters this morning, I'm convinced that I can give this book to a project manager I work with, and that with both of us using this style my consitently, we will be better able to understand each other.

Who da thunk it?

Initial Impressions of Windows Workflow Foundation

2008-07-16T08:02:00.001-07:00

In my last post, I mentioned I was reading Pro WF Windows Workflow in .NET 3.5 by Bruce Bukovics. I also used the words Whoop-Tee-Doo.

Well, I'm now 335 pages into the book, and into the concept of state machines, and this morning I finally had an 'Aha!' moment. See I've been trying to solve a problem at work, and knew that Workflows would probably help me, but the Sequential Workflows weren't blowing my mind. They just seemed like a lot of overhead to implement something that I could do inmany other ways.

However, the State Machine Workflows are definitely something I can see real possibilities for. I'm going to mock up my problem as a state workflow today, and see if I can get it to work.

I have two concerns:
1. Will I be able to call a .NET 3.5 Workflow DLL from a .NET 2.0 Application. I think so, as long as the .NET 3.5 Framework is installed on the clients (which it is)
2. Should I, as the architect, introduce another new technology into an application which is already difficult to support, even if it makes the problem I am trying to solve easier to solve. I am conciously trying to not alter the core of the application because of the size of it and the cost of fixing stuff that isn't broken, but the framework of the application is really limiting what we can do, and I think I can just peel out some pieces and make the application better. I also don't want to be the only one able to support it going forward, and if the rest of the team doesn't take their education in the new technologies as seriously as I do, I could be painting myself into a corner.

VS2008 Printing Issue

2008-07-14T11:05:00.000-07:00

Today, I wanted to print a DBML Document from VS2008. The fact that I've been using VS2008 for 6 months now, and haven't run into this shows how much printing I actually do.

Anyway, I tried to print, and I kept getting an Error 'No Default Printer Istalled', which is bizarre, since I do have a default printer installed. What it really meant was the ID I was running as (admin), had no default printer installed. Even though I am an admin on my box, the admin user itself had to have a default printer set up.

Of course, I don't have the Admin user ID and password for my machine (I've never needed it in the past), so I had to recruit one of our tech support guys to fix this. After setting up the printer, and then switching back over to my id, everything was, whoa... still didn't work. Huh? Switch back over to the admin ID, test the printer. It works. Switch back over, restart VS2008, still nothing.

Close everything, log out, log back on, openup VS2008. Print. Ta-da!

Hoep this helps save someone half an hour.

Back from where-ever I've been

2008-07-04T17:01:00.000-07:00

Not that I've totally forgotten about updating this blog, but it wasn't until I started getting some people posting questions on here did I realize that, hey, someone is actually reading it! I'm going to try to get back into updating it more regularly, though it is difficult to find time to do it when I am at work, and that's when most of my technical tips, tricks, techniques, etc. come to me.

Anyway, since I last updated this site, a lot has changed. I spent pretty much the whole month of May, and most of June, heads down in developing my first major e-commerce web site. I worked with two other developers and a QA, and we started out really far behind the eight-ball due to a number of staffing issues early in the project. I was brought in to 'pound code', which isn't my normal role in projects, but it is something I do enjoy immensely.

When I say we were pounding code, I really mean it. It's been at least eight years since I've been heads down, fully dedicated to doing nothing but coding. We built 80 screens to administer the site, and the front end was over 40. We assembly-lined the project, where I did the admin site and part of the data access layer, one developer focused on CSS and doing the grunt data access layer (99.9999% in LINQtoSQL), and one developer building the security, transaction auditing and credit card processing and the front end screens. Our QA tracked the issues and gave us feedback on every screen as it was completed (and sometimes before we completed it, to our chagrin), and we really made efficient use of time and resources. I didn't think we'd get it all done in time, but we really did, and met all of our customer's expectations, and blew them away with the site over all. Not bad for my first time. Luckily, we did have experience in the office on some of the tricks of the trade (cc processing and auditing), so we didn't have to work that all up from scratch, but still, we're pretty proud of what we got done.

These days, I'm starting to dig into a Windows Forms application which was built 4 years ago in C# using the Microsoft Application Blocks 1.0. We migrated it up to .NET 2.0 earlier this year, and now have some major enhancements to do to it. A lot of the code is auto generated from an XML file which documents the data objects, and while I can see that it kicks out a lot of code in a hurry, it also seems to saddle the application with a lot of code which may never be used. It does everything from creating the database objects and stored procedures to spinning up the Controllers and data objects. There's a lot of cookie cutter code left after that to do, and it makes it fairly easy to build, but it is missing some things, like database side referential integrity and really good error handling.

I've also touched on some Sharepoint development. Sharepoint's a product which is not ready for prime time when it comes to the development environment. It really feels kludged together and is very temperamental. The most often seen comment on Sharepoint support blogs when discussing some weird Sharepoint behavior is 'Welcome to Sharepoint Development'. That's a really bad sign. I was really disappointed because I'd heard such good things about it. Hopefully Sharepoint 2008 improves the situation.

My current reading is Pro WF: Windows Workflow in .NET 3.5 by Bruce Bukovics. I'm only in Chapter 3 right now, and while the content makes sense, I haven't yet figured out how to apply this to the real world. I need to make a leap in my brain, and right now, I'm only getting little hops. I was expecting something that really blew me away. So far, not so much. "Visual If Statements". Whoop-Tee-Doo. I'm sure in 5 Chapters, I'll know it' much more than that, but that's why I read the book. To learn.

The book I'm most looking forward to reading is Microsoft® .NET: Architecting Applications for the Enterprise. Hopefully this helps me to put it all together so I can see the big picture better.

Another book completed

2008-04-03T21:06:00.000-07:00

I finished reading Code Complete 2 today, another book in my quest to bring my technical skills into the 21st century. Definitely a worthwhile book to read, especially for the beginning programmer, though it is already 4 years old. I worked a long time in C and C++ and I've seen many of the debates which the author discusses actually happen.

That said, I found myself wanting something different at this point in my reading life. I want to read more about projects in industry which have failed, and ones that have succeeded. I want to read about the post mortems which are done on those projects. At my previous job, the developers always wanted to do post mortems, but they never happened, for one reason or another. I think the view was that management thought they would turn into massive bitch sessions, whereas developers didn't expect things to actually ever change, so they never pushed the issue very hard. I am going to reread The Mythical Man Month sometime in the near future. I first read it back in 1994, just out of college and into the workplace. It will be interesting to see how I relate to it now.

The other thing I wanted was a book that got into the design issues specifically surrounding C#. I've still got more searching to do to find that book. I'm not sure if I'm looking for a design patterns book, a Nutshell book, a recipes book, or something else entirely, but I know I still have a lot to learn about application development in the .NET world.

I am starting my reread of ASP.NET 3.5 with C# 2008, and I figure that will take me till the end of the month. Sure I only finished it a month and a half ago, but I'm knee deep in a major ASP.NET project, and it's the perfect time to reinforce the skills I learned earlier.

I plan to get back to writing more frequently here again. It's not that I'm not working hard, it's that I kind of got into the flow of my new job, and for a brief period, thought I knew what I was doing. Now that I'm back into ASP.NET, there are all new mistakes to make and lessons to learn, so expect more posts, soon.

Type inference in .NET 3.0

2008-03-13T13:43:00.000-07:00

One of the things I am having a hard time wrapping my head around is why one of the recommendations of Resharper 4.0 is to implicitly type all local variables. It goes against my anal retentive nature for clean, easy to read code.

The following article tries to explain the benefits of this practice, though I’m not sure they have me convinced though I have, at times, found myself annoyed with the redundant declarations of a new variable

i.e.


Dictionary<SearchCriteriaType, SearchCriteriaDisplay> criteriaDisplays = new Dictionary<SearchCriteriaType, SearchCriteriaDisplay>();

Can be shortened to


var criteriaDisplays = new Dictionary<SearchCriteriaType, SearchCriteriaDisplay>();

I guess that makes the code less cluttered. But is life really that much bad with the previous example that the Resharper folks found the need to suggest that it is now best practice?

http://www.programmersheaven.com/2/CSharp3-1

Visual Studio 2008 Error after upgrade

2008-03-12T08:04:00.001-07:00

I needed some capabilities from VS2008 DB Edition to go with my VS2008 TA (Team Architect, not whatever other acronym starts with T&A), so I slapped a copy of that onto my machine this morning.

However, when I fired up VS2008, it started briefly, and then crashed. It did this a few times in a row, and I checked the event log.


.NET Runtime version 2.0.50727.1434 - Fatal Execution Engine Error (79FEC5F0) (80131506)

Ruh-Roh Shaggy. Time to reboot.

Try it again. Same problem.

We're in trouble now, Scoob.

After searching the web for a bit, I came across starting the app in SafeMode. with the/safemode switch. That worked. I let the app load up, then I closed it back down, removed the /safemode switch, and presto, back in business.

I think it has to do with my recent installation of Resharper 4.0 EAP, since the app was dying trying to load the toolbox items. We'll see if it happens again the next time I do an upgrade.

SQL Thief - Last Modified Stored Procs

2008-03-11T08:13:00.000-07:00

I will admit that what I am about to put here, I stole from Pinal Dave's site. Nonetheless, I use these scripts quite frequently, but have a hard time finding them on line (you have to remember just the right search word, and I always forget to bookmark them). So for my quick reference

Here's how to get a list of all stored procedures modified in the last x days


SELECT name
FROM sys.objects
WHERE type = 'P'
AND DATEDIFF(D,modify_date, GETDATE()) < 7 --Change 7 to any other day value.

The following script will provide name of all the stored procedure which were created in last 7 days, they may or may not be modified after that.


SELECT name
FROM sys.objects
WHERE type = 'P'
AND DATEDIFF(D,create_date, GETDATE()) < 7 --Change 7 to any other day value

Dude, you're such a Tool

2008-03-10T19:13:00.000-07:00

Yes, half the fun of blogging is coming up with good titles. This, post, as it so clear states, is about tools.

As a .NET developer, I take no shame in using as many tools as I can to make my day easier. Here are as many as I can think of. Most of them you will know, some you may have heard of, and some you'll think to yourself, why isn't he using xxxxx. Well, I want to know about xxxx, so if you don't see it listed here (and it pertains to something I would need at WORK, let me know.

Visual Studio 2008 (of course, and 2005, and ack, sometimes 2003). LINQ in 2008 is quickly becoming my most important coding skill. Frankly, it had me at Hello, and I've been it's query biatch ever since

SQL Server Management Studio - if you aren't working in SQL server these days, what, are you stuck in 1995?

NUnit - Test driven development is getting a hold of me, and I like it!

CruiseControl.NET - To know it is to be the only one in the office who cares, but it makes my life a lot easier in the long run

NAnt - Part of my suite of build tools

FireFTP - Mozilla add on for FTP. Great little tool

FireBug - Mozilla add on for debugging web pages and css files

Fiddler - Helps for debugging http traffic. Ethereal is another good tool to. I just haven't used it lately

.NETReflector - Lost the source code for a .NET dll? Run it through Reflector to get it back. Want to compare two versions of a .NET dll to see what changed? Run it through Reflector

ummm Visual Source Safe - better than nothing I guess. Slightly better.

asp.net AJAX Toolkit 3.5. I've been really getting into AJAX this week, and it's pretty cool, though it does not seem very forgiving.

One of the tools I am going to try soon is called Resharper. I've heard really good things about it, and I'm pretty sure it will save me time, but it is quite expensive, and I just want to make sure I'm going to use it. Time to get the trial licence, and give it a whirl.

Anyway, that's pretty much what I sue on a day to day basis (that, plus google to help me find blogs that fix my bugs).

What am I missing?

Can I By a Val please Vanna

2008-03-07T14:20:00.000-08:00

File this under gosh darn whacky wastes of time

If you have a web service written in VB.NET which has functions which are called by ASP.NET AJAX scripts, don't ever declare the values in the function declaration as ByRef. Use ByVal instead.

ASP.NET AJAX will show a Method 500 error and you'll spend much time trying to find out why that one call doesn't work.

Again, the side effects of relearning VB.NET

Oh joy.

You insensitive bastard

2008-03-07T07:10:00.000-08:00

Here's a really simple function that uses LINQ and will throw a bizarre exception when written in VB.NET. The exact same function, written in C# will work perfectly.

First, create a simple class


Public Class SearchCriteria
    Public GroupName As String
    Public Keyword As String
End Class

Then, add the following function to an NUnit test harness using VB.NET


     Public Sub BadList()
        Dim searchCriteria As New List(Of SearchCriteria)

        Dim distinctSearchCriteria As New List(Of SearchCriteria)

        distinctSearchCriteria = searchCriteria.Distinct()

    End Sub

Running that code, results in the following exception


System.InvalidCastException : Unable to cast object of type 'd__80`1[SearchCriteria]' to type 'System.Collections.Generic.List`1[SearchCriteria]'.

Do you see why? Since it's been a long time since I've done VB.NET, it took me a while to figure this out. Of course my code wasn't that simple, but here's the solution:


     Public Sub BadList()
        Dim searchCriteriaList As New List(Of SearchCriteria)

        Dim distinctSearchCriteria As New List(Of SearchCriteria)

        distinctSearchCriteria = searchCriteriaList.Distinct()

    End Sub

It goes back to VB.NET not being case sensitive. Declaring a variable with the same name as the class (albeit a different case), confused the hell out of the runtime engine.

This is just one of the many reasons I prefer C# to VB.NET. But the client wants the development done in VB.NET, so I get to (re)learn another language.

Book on Pre-Order

2008-03-06T07:41:00.000-08:00

I don't think I have ever put a technical book on Pre-Order before, but I did just that this morning for LINQ Object Relational Mapping

I can honestly say that I spend hours every working day thinking about ORM. In fact, a large percentage of my time over the past 4 years has been trying to map database tables to usable objects and to try to find a good architecture for applications that really works in the real world.

I have really high hopes for this book, and deep fears as well. I'm hoping I read it and think "I can just tweak a little bit of my design here and there and I'll be right on track."

I'm fearing that I'll read it and either a) not know what the hell they are talking about and realize I am still in way over my head, it's time to start flipping burgers, b) OMFG, this is better than what I have by a huge factor. I have to rebuild everything, or c) WTF, do none of these guys who write these books ever spend time in the real world? With most books, it's a little of all of these at one point or another.

I guess I'll just have to wait and see. The book is scheduled to be released April 28, 2008.

NAnt and .Net Framework 3.5

2008-03-05T12:28:00.000-08:00

When I went to build my first LINQ application on our build server running CruiseControl.NET, the first message I got was:


Solution file error MSB5014: File format version is not recognized.  MSBuild can only read solution files between versions 7.0 and 9.0, inclusive

I figured all I needed to do was to force NAnt to use the .NET 3.5 Framework, so I added a line to the NAnt Script as follows:


<property name="nant.settings.currentframework" value="net-3.5"/>

However, then I got the following message


Target framework could not be changed. "net-3.5" is not a valid framework identifier. Valid values are: net-2.0, net-1.1.

So after a little digging on the net, I found that the version of NAnt we were using (0.84) did not yet handle the .NET 3.5 Framework. However there is a Beta version of the 0.86 NAnt tool available, so I downloaded that and installed it to my build server (copied it actually, there is no installer)

The I got the following error


Object reference not set to an instance of an object.

Hmmm. I cleaned up my build server, removing all previous versions of NANT, copied the files from 0.86 back into my NAnt directory, and tried again. Same problem.

Next, I downloaded the latest nightly build from SourceForge and tried my build again


Invalid element . Unknown task or datatype.

WTF!? Where the hell did my msbuild task go? Panic strikes. OMG, I just killed our build server! My boss is gonna kill me!

After a little digging, it turns out that when I cleaned up my server, I'd also removed the latest NAntContrib bin directory, where the msbuild task comes from. So I downloaded the latest NAntContrib package, copied the files to the NAnt directory.

And.... PRESTO! Project building! Well at least it would have been if I hadn't had a path error in my NUnit task. A quick fix, recheck the file into (gah) Visual Source Safe, and a green build light made me feel all warm and fuzzy inside.

All that took me a good chunk of my morning. It would be really nice if SourceForge offered a standard install with the latest NAnt and NAntContrib packaged together for us lazy asses who don't really have 4 hours to blow on getting a build running.

I think that's the number one argument against build servers is how long it takes to set them up. The time they end up saving is tremendous, but you have to be really determined to get it done, and then cross your fingers that you have accurately documented every step in the setup so it doesn't take so freaking long the next time.

My next task... upgrade CruiseControl 1.2.1 to 1.3, though I have heard rumors circulating about CCNET 1.4. Maybe I'll wait till then, and get some real work done.

ThinqLinq

2008-03-05T09:11:00.000-08:00

I'm not exactly reading a book a week, but it is close. This morning, I finished the Pro-LINQ C#2008 book by Joseph Rattz. A lot of it is a reference manaul which I will be frequently breaking open while coding LINQ, but I definitely feel more comfortable in using LINQ now than I was a couple of weeks ago. I haven't gotten to the point of ThinqLinq (I just coined that term, I should copyright it.) *Note: I just found a website that already uses the term ThinqLinq. Guess I won't be getting rich on that one.

I'll define ThinqLinq as being able to code database queries directly in LINQ without first thinking in SQL. I think it actually works to my advantage that I am relatively new to SQL Server, with most of my database experience being in Informix and Oracle, so the transition to SQL Server is being done at the same time as I am learning LINQ.

One of the dangers of learning a new language (and that's what LINQ is to me), is that you can become proficient at the language, but it may take a while to learn how to architect an application properly using it. LINQ removes months of development effort for the data access layer, and that speed may encourage bad design. Not because you want to make a bad design, but because you aren't in the code long enough during the development cycle to know it is bad design.

To me, bad design has two definable results:
1. Poor performance. In some cases this is obvious right away,in some cases it isn't until much further down the road when you see your database load go up unexpectedly as your app reaches critical mass

2. High code maintenance costs. The idea behind a good design should be that future changes should take much less time than the original effort. But if your original effort on an application was less than a day, is there really a long term payback of spending three weeks doing a huge design effort to extract ten lines of code into another class? Purists will say yes, always. Realists, working with real deadlines and real customers will say it depends.

I think what it comes to is that only experience with a new language will tell you what is and what isn't a good design. Start simple. Don't try to out guess the code or the user. Prioritize optimization based on the critical nature of the code and the size of the project. As you learn a better technique, keep a list of places where you may want to refactor existing code using that technique, and check your list frequently to see if any of those tips apply to what you are doing.

Here are my current best practices for LINQ
1. Don't try to write a best practice until you tried something at least twice

2. Never alter the autogenerated code created by SQL-Metal. Use the partial classes instead

3. Always implement your data relationships on your database. If it doesn't have any, you will save time by going inand adding them as you need them in your LINQ applications. Undoubtedly you will need them later, and the foreign key relation ships defined on the database make it easier for new developers to navigate through a large database.

4. Don't try to do everything in one query. If you need to break things out into more than one query for readability or speed, do it. Even if it seems that multiple queries will result in a lot of extra database traffic, give it a try. You may be suprised at how much better the split queries acually perform, especially if you can cache the results of one of the queries.

5. NUnit is your friend. Write lots of test cases. Write them before you write your LINQ code. You'll need every case you can get your hands on.

My next LINQ goal is to understand how it fits in with tools like SubSonic and the Entity Framework, but for now, I'm just going to focus on mastering LINQ, and learning to ThinqLinq

The next book on my reading list is Programming SQL Server 2005. I need to brush up on the SQL Server basics, and fill in some of my knowledge gaps. I don't think there will be anything earth shattering in it, just a lot of 'Oh, that's cool' things that I could never have done in Informix.

Log4Net in VS2005 Web Application

2008-03-03T09:21:00.001-08:00

Here's a link to a blog post on setting up log4net in a Visual Studio 2005 web application.

The real trick to this is to make sure that there is a global.asax file in the applciation and to add the following line to the Application_Start method


log4net.Config.XmlConfigurator.Configure();

The rest of the configuration is pretty straight forward.

.NET Extensions Anyone?

2008-02-28T06:37:00.000-08:00

If you haven't seen .NET extension methods in action, they're pretty interesting. What are they, you ask? Let's say you have an existing .NET class provided by an external vendor. Let's say that vendor is Microsoft. You want to add a new function to, I don't know, lets say the string class. There's not a hope in hell that you'll get Microsoft to add it for you.

Of course, you could build your own string class, override one of the existing functions, or add a new one, but that seems like a lot of work. Here's an easy way to add a new function to the class, without having to use inheritance at all. And the best part is that within seconds, this class will show up in your Intellisense.

This function must be in a static class, and part of your own project / namespace or compiled into a DLL while you include in your project.

I wrote this function as I have been trying to find an efficient way to build dynamic Lambda queries for LINQTOSQL, but unfortunately, this won't work as 'FindWickedString' is not a function which can be interpreted by SQL Server, and the lambda function I am building executes on SQL Server. So I'll keep digging on the dynamic lambdas, but this is fun as an exercise. Wait. Did I say coding was fun. Egads. I meant work.


    public enum WildcardMethod { Contains, StartsWith, EndsWith, Exact }

    static class Extensions
    {
        public static bool FindWickedString(this string value, string checkValue, WildcardMethod method)
        {
            switch (method)
                {
                    case WildcardMethod.Contains:
                        {
                            if (value.Contains(checkValue))
                                return true;
                            break;
                        }
                    case WildcardMethod.StartsWith:
                        {
                            if (value.StartsWith(checkValue))
                                return true;
                            break;
                        }
                    case WildcardMethod.EndsWith:
                        {
                            if (value.EndsWith(checkValue))
                                return true;
                            break;
                        }
                    case WildcardMethod.Exact:
                        {
                            if (value == checkValue)
                                return true;
                            break;
                        }

                    default:
                        break;
                }

            return false;
        }

PredicateBuilder

2008-02-27T08:55:00.000-08:00

One of the really cool LINQ tools out there is PredicateBuilder by Joseph Albahari. http://www.albahari.com/nutshell/predicatebuilder.html

His book is next on my reading list, but I am already using PredicateBuilder as part of my current project with is a dynamic query engine for a billing systm.

The only difficulty I am having is passing in column names dynamically. The consensus is that this can't be done, but that doesn't stop me from trying (or at least whining about it)

Fun with LINQ

2008-02-27T08:02:00.001-08:00

I've really been getting into LINQ these days. I'm currently reading Pro LINQ by Joseph Rattz. The writing style is not a good as the Pro ASP.NET 3.5 book I've previously raved about, but there is a chance that this book is just covering a muchmore difficult topic.

If you haven't ready about LINQ yet, do so. It is coming to a Visual Studio near you. Even if you don't use SQL Server, you can still use it for XML, DataSets and anything that inherits from IEnumerable.

But I do fear that the downside of LINQ is that Microsoft is about to lose a lot of developers because of it. As easy as it is, it is also very, very difficult. 75% of the developers will look at the syntax, the ridiculous numbers of < and >, and run back to hand coding SQL statements and returning plain old data readers. The problem lies in the fact that LINQ Expressions are extremely difficult to read. They're powerful, yes, but the numbers of function delegates and advanced concepts of the .NET Framework that LINQ requires you to know in order to go beyond the most simple queries is a little frustrating.

I'm sure that with time, we will grow use to reading Lambda expressions just like we read regular code, but I think a large percentage of developers will be scared off from the syntax and will never try. They will stay with their tried and true methods of data access, and count the days to retirement. I don't blame them. A new concept like LINQ or NHibernate or The Entity Framework comes along every year. I skipped a whole generate of these tools, and here I am, now working in LINQ.

Visual Studio Tip - TODO

2008-02-27T07:57:00.000-08:00

Here's a tip that seems pretty obvious, but I've never used it before, and it's really useful, especially if you are going to hand code off to someone else to finish

Add a comment line to your code as follows

// TODO - Add a task to complete here

Then, go to the main menu bar, and select View - Task list. In the task list Window, there si a drop down list that says either Comments or User Tasks. Switch to comments. TADA! TODO!

Quick, easy, and professional! No more sticky notes or long emails about what is left to do. And it gets tracked with your source control so you can see who made the change and when. You are use isource control, right?

Recent Reading

2008-02-20T09:39:00.001-08:00

I recently finished my first pass of ASP.NET 3.5 in C#2008 by MacDonald and Szpuszta. What an amazing book. I learned something new on just about every page. It's a pain in the but to lug this monster around every day (it's 1500 pages), but I learned so much that I consider it required reading for developers trying to get caught back up with technology if you've been stuck in a rut.

I've also almost completed reading Head First HTML with CSS and XHTML. The first half of this book wasn't anythingnew to me, but the second half really helped get me up to speed with CSS and since that is exactly what I am working in this week, it is really helping. It's a very quick read. I'm getting through about 200 pages a day (there are a lot of graphics). The Head First series isn't for everyone, and I thought I'd give it a try. It's great for doing catch up on technology, but I wouldn't use it to try to learn some huge new concept.

I'm debating what will be my next work topic to read about. It may be Code Complete 2 or perhaps Programming SQL Server 2005, or maybe a book specializing on LINQ.

I can't believe how much reading I am able to get done while riding the Sounder back and forth to work. It would have taken me a year to work through ASP.NET 3.5 at home. I'm definitely in the learning groove, and on track to get caught back up on the technology I need to do my job.

And the writing bug is hitting again. YAY!

CSS Path Lesson Learned

2008-02-20T09:36:00.000-08:00

Situation:

A graphic I was trying to display in the main page header on a website was not showing up. The header was build via a CSS page. All other graphics on the page were working.

Solution: CSS background:image links must be specified with the path from the css file, not from the page using it. (DUH)

Recent Reading

2008-01-14T21:35:00.000-08:00

I just finished reading Microsoft SQL Server 2005 Reporting Services 2005 by Brian Larson. It's a pretty good introductory book, and after reading the first 11 chanpters, and skimming the last couple, I think I've got a pretty good idea on how to get started with SSRS2005. Unfortunately, by the time I actually get to use any of this, we'll probably be on SSRS2008, and I'll have to get the next version, but hopefully there won't be a lot of changes.

I'm currently digging into SQL Server Free Text searching and other search engines to be used for searching relational databases. The SQL Free Text search has a few major downsides:
1. It can only index one database
2. You need to actively update the database indexes on a schedule, or the search will not get accurate information
3. You need to specify the columns to include in your searches through your indexing.

This may still work to do what I need, but there will be a lot more effort than originally planned.

I am also researching and comparing LINQ, CSLA, NHibernate and the Microsoft Entity Frameworks for use in my data layers. No winners yet, as they all offer benefits. The biggest loser in using these tools is WCF, since using WCF removes a great deal of the capabilities built into each of these tools for CRUD operations.

Finally, I've been cracking open Visual Studio 2008, mainly to look at LINQ and new ASP.NET functionality.

More to learn, always more to learn.