Steve Strong's Blog

A relatively quiet week:

• Contracts in .Net 4.0
• 
  
• A whole pile of stuff about Silverlight 2.0, most of which you probably know already, plus some sniipets of info about Silverlight 3.0
• 
  
• Another great post from Mark Russinovich, this time on virtual memory
• 
  
• Rico Mariani on VS2010. And he should know what he's talking about, being the Chief Architect. One of Rico's passions is performance, so let's hope he brings a good deal of that to Visual Studio :)
• 
  
• REPL loops in C#. You've really got to be interested in this sort of thing to bother following the link, but for those twisted folk out there, here it is.
• 
  
• A glimpse of the plans for N-Tier Entity Framework
• 
  
• Finally. A good, clear explanation of Oslo. The first half is, imho, spectacularly good.

It's been quite a week, certainly as far as things that interest me go:

• A much under-rated app - here's the low-down on the new Calculator in Windows 7. Now, don't mock, it's actually rather good!
  

• A load of posts on Azure (no surprise there!):
  • ASP.NET MVC on Azure. It's all good stuff - I'm current using the AspProviders that this article talks about, but in conjunction with WCF REST rather than ASP.NET MVC. They work real well, except for one little detail around getting HTTP 401 errors returned back to the client. More on that in a later post...
  • Links to useful sites in the Azure community.
  • How to retrieve the logs from your Azure services. This will be essential if you're doing anything more than trivial stuff! I'm guessing (hoping!) that at some point features like log viewing will be available through the developer portal.
  • A good intro to the Table Services part of Azure

• From TechEd EMEA, a good post from Jason Zander on the new bits in VS2010.

• And on the same topic, here's more stuff from Somasegar.

• M has been getting a whole pile of traffic this week. Here are the good bits:
  • A neat M grammar for modeling user stories. Even if you're not interested in M, it's worth reading since there is great value in this approach to gathering requirements.
  • Generating code using M and T4. This is really in depth - I think it's fair to say that the language that he generates code from is of limited us, but the approach would be applicable to any DSL that you care to put together.
  • Writing WPF using M. Of course, it's only a toy language, but it sure is cool.
  • Consuming MGrammar output from C#. Suspect this is how most of us will use it for some time.
  • The complexity in language design, and how M doesn't really change that. This link is the response - be sure to click the Frans Bourma link to see the original point (although be prepared to have your Compiler Design course from college come back and haunt you!)
  • MrEPL. Lots of stuff is starting to do the old REPL thing again, brings back happy memories of BBC BASIC :)

• More stuff from Somasegar, this time on new features in .Net 4.0

• First view of Exoplanets. How cool is that? Now we've just got to work out how to go there :)

This should have been sent last Friday, but other stuff got the better of me. Anyhow, here's last weeks "interesting stuff":

• The reason why we have iterations: Early Pain
• 
  
• An example of a simple TODO language implemented in Mg. For those use to parsers, BNFs etc, this will be an easy read. For those that haven't come across such things, it's a nice introduction.
• 
  
• How SanDisk's ExtremeFFS works. Bets on how long it is before Joe gets one :)
• 
  
• A nice summary of PDC. Thanks, John - saves me writing it!
• 
  
• Access to the ETW APIs from .Net using NTrace. Not used it yet, but suspect this is worth keeping an eye on.
• 
  
• A new TFS Power Tools release. Surprised that Obama got quite so much press coverage considering that this came out the same week.
• 
  
• Code Contracts in C# (well, any .Net language in fact). It's due out with .Net 4.0, but it also looks like it works with VS2008. Getting into the habit of declaring the intent of your code in this way can only be a good thing - it helps out with documentation, static analysis, runtime checks and gives Pex something to get its teeth into.
• 
  
• A good reality check on some of the hype going on about Oslo right now.
• 
  
• Hadi is twittering. Hell has also frozen over.
• 
  
• For those of you with a media center and an iPhone / iPod touch, this is cool. I've been running it for a week or so (before this review came out), and although at $6 it's one of the most expensive iPhone apps I've bought, it's a load cheaper than the wireless mouse / keyboard that I would have bought otherwise.
• 
  
• Should we put comments in our code? Neal Ford has shares his views here - not sure I entirely agree with him, but I do respect his opinion and it's hard to refute his reasoning. Some of the comments are pretty decent, so it's worth reading the whole page.

This one is about 2 weeks late due to my trip to PDC.  Some of the "interesting" things from the week prior to PDC have been superseded by announcements made since then, so this is probably shorter than normal...

• Updated Sync Services Framework available
  
• Freeing up disk space under Vista
  
• Good post on languages just being tools for solving problems, and how one language is not necessarily the best tool for every job.
  
• A developers view on the processes involved in building Windows 7
  
• Factoring of assemblies in Silverlight applications
  
• Getting into the "flow" when coding, why cubes can be disruptive and maybe a reason why pair programming can be more effective
  
• Automated concurrency testing with CHESS - just Win32 at the mo, but with .Net support on the way
  
  • And on a related topic, the unit testing tool Pex is also now available