Dan Maharry

TypeScript v0.8.3 Released + Additional Notes

danm@hmobius.com — Thu, 28 Feb 2013 22:00:00 +0100

Jonathan Turner of the TypeScript team has announced the release of v0.8.3 of the TypeScript compiler and Visual Studio extension. You can download it here. This will be the last interim release before the v0.9 releases. Some compiler tweaks have been made in this release as well as two improvements in Visual Studio:

There was previously a restriction that you could only debug through your TypeScript files if they were part of the project being debugged. This restriction has since been dropped so you can now attach the VS debugger to an instance of Internet Explorer running the project and debug them remotely (even though the instance of IE knows only about the JavaScript files previously generated from the TypeScript).
The type information displayed when you hover your cursor over TypeScript variables has been embellished further with the variable name and whether the variable is locally declared or not.

Full details of these improvements are recorded here.

Additionally, I’d like to add the following notes for v0.8.3.

v0.8.3 seems to install over the top of v0.8.2 rather than needing it uninstalled first as in previous versions. However, it does require a complete system restart, so save your stuff before upgrading.
v0.8.3 (and v0.8.2) install in the main c:\Program Files (x86)\Microsoft SDKs\TypeScript folder rather than in a subfolder with the version number, so if for some reason you need different versions of the compiler on your machine, you’ll need to create your own subfolders.
There’s no sign of the TypeScriptLanguageService.vsix file in the install directory for v0.8.3 that was previously present so there’s no fall-back other then trying to reinstall it if it appears that the extension and TypeScript templates have not been installed in your instance of Visual Studio. To make this assertion trickier, the TypeScript extension no longer appears in VIsual Studio’s Tools>Extensions and Updates dialog and the ‘HTML Application with TypeScript’ project template is no longer found under Visual C# > Web. You can now find it under Other Languages > TypeScript.
v0.8.3 seems to work fine with the latest version v2.5.1 of the Web Essentials 2012 extension.

Happy coding!

Geek Dad : Installing The Future

danm@hmobius.com — Thu, 28 Feb 2013 20:00:00 +0100

I am writing this to you from the future. Or at least from a future. The one that British Telecom has created here in Deddington as a template for all the telephone exchanges in the UK. London hopes that it will one day be like us. Probably.

The complete Deddington exchange from Aynho Wharf to the Barfords will be totally enabled with the completion of phase three – the old half of Deddington – some time in March. Then we have two years to switch our phones and internet connections over to fibre optic before they remove all the copper wiring in the area. There is no coming back from the future here you know.

The first step is to choose your phone and internet provider and package. The obvious choice is the omnipresent BT Infinity but there are a good dozen companies (listed at http://www.thinkbroadband.com/guide/fibre-broadband.html) which you can talk to instead, with rates varying from £18 to £150 a month based on internet speed and download limits. Some will include free installation of the last bit of cable from pole to phone point, others not.

Our installation was pretty painless. There were two visits, seven days apart. The first replaced the copper cable from the telegraph pole to the house and then ran the new cable down to a junction box nearer where we wanted our phone and broadband connection to be. The second included drilling through the outside wall, installing the actual new hardware and enabling the new connections. (For those with a fear of dentistry, look away; metre-long drill bits are not for you.)

The only real input the engineers need is to know where you want your new boxes installed. You’ll need to have a space about the size of an A4 sheet of paper free somewhere near a plug socket for the new phone lines and battery pack to be fixed. If you have computers or an office in the house, consider having the boxes there for a wired connection to your main machine and using wireless phones rather than the other way around. As long as the distance between the junction box and the new location is less than 25 metres around the outside wall, there’s no problem.

If you’re curious about the battery pack, one downside to fibre optic cables is that unlike copper wires, they don’t carry an electric charge. The battery pack is mandatory in case a power cut happens and you need to use the phone. The pack is good for 12 hours which hopefully should be enough.

Once everything was installed, the engineer rang the BT service centre and asked them to switch the cable on. Funnily enough, our guy had a good half a dozen phone numbers for the centre and none of them answered for about half an hour. When he did get through, he was told their systems were down so he’d have to call back later. Nice to know it’s not just the consumer that gets the run-around by BT.

With respect to phones, the old ones continue to work as normal even with the new cable installed. More next month on the search for a decent fibre optic phone and figuring out just what we can all do with this new-fangled speedy broadband thing. I can confirm right now however, that the BBC iPlayer and other watch on demand TV channels all work beautifully in glorious high definition. Which is nice.

TypeScript Revealed : v0.8.2 Addenda

danm@hmobius.com — Mon, 18 Feb 2013 10:21:00 +0100

The bugger about writing a book on an open source project is that it keeps developing while you are writing, proofing, copyediting and finally printing. This strategy can and does bite you on the arse, and has done me frequently. Two cases spring to mind:

A book on Microsoft’s .NET My Services, codename Hailstorm back in 2001. FOur of us wrote it in six weeks based on the latest bits in time for PDC, met the deadline and got it published. Then found out as the book went to the show that Microsoft had completely axed the entire project.
A book on the open source wiki software Zope which spent so long trying to catch up with the terrifyingly frequent software releases being made to Zope at the time, that the whole project imploded.

It’s not a surprise that there are already some addenda for ‘TypeScript Revealed’. It’s just disappointing that TypeScript v0.8.2 was released the same day as the book was and includes a couple of main new features which I would have certainly included were they available at the time.

That said, that’s why I have a facebook page for the book so you can check up on links for the latest TypeScript articles and this blog so I can give you the heads up on the new stuff and any new github projects out there I would have included had I known of them at the time.

The main one is that the TypeScript Language Service can now read jsdoc comments in your typescript and roll them into the intellisense pop-ups it presents when you hover over a function parameter, class name etc. This will work in much the same way as any XML comments you write in your .NET code augment the intellisense for function calls. If you do include jsdoc comments, you can preserve them during the compilation into javascript using the -c flag for the compiler. There'll be a separate article up shortly looking at jsdoc as a whole and how it fits into the TypeScript tool chain.
The Visual Studio extension for TypeScript now supports Compile-on-Save in addition to the Compile-as-Build-Step functionality it already supported. This works in much the same way as Compile on Save works if you have Mads Kristensen's Web Essentials 2012 add-in for Visual Studio already installed. You can find the options for CoS by selecting Options>Text Editor>TypeScript>Project from the Tools menu. The compile-on-save functionality has also been improved in the NPM-based compiler when using the -watch flag. (Note I'm not a node.js user so I can't say by how much).
Adding TypeScript as an MSBuild step into existing project has become slightly easier. v0.8.2 now comes with a new MSBuild targets file meaning rather than call the compiler you can express the call as MSBuild XML. The doesn't make calling the compiler less valid; it just tidies up the MSBuild file. You can find Microsoft.TypeScript.targets at C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0\TypeScript. Again, a full article will be forthcoming shortly, but you'll find brief details on the TypeScript wiki here.
The compiler service can now be replaced in the TypeScript for Visual Studio 2012 plugin. This makes it easier to leverage the Visual Studio TypeScript extension with newer compiler builds from CodePlex or from experimental forks. Details of how to do this can be found on the TypeScript blog here.

On the jsodc theme, there's one new github repo that's worth highlighting which adds a new way to create TypeScript definition files for you. Jsdocts outputs a definition file based on the jsdoc within a javascript file. Could be useful, although YMMV.

Denon AH-D600 Headphones Review

danm@hmobius.com — Thu, 31 Jan 2013 16:00:00 +0100

There’s always something that picks at your brain. Quite recently, apropos of nothing, it’s this article from Nate Lanxon of Wired UK. A little bit of legacy later and I have a new pair of headphones around my neck replacing the Sennheiser HD-490s I’d had for some seven or eight years previously. The Denon AH-D600s are, quite literally, a different level, sonically and price-wise. They’re £500 RRP but can be had for substantially less if you search around.

Funnily enough, that white-out box in the bottom right says the headphones are iPhone and iPad compatible. Quite why you’d walk down the street with an iPod wearing high-end headphones is unclear, but under the phones themselves in their satin-lined box are two sturdy wrapped cables, one of which has an iPod\iPad remote built-in. The other one – a straight 2m cord – will get the greater use in all likelihood.

What’s true if you are going to use it with an iPod is that you are not going to get true value for money out of this headgear. The D600s' 25-ohm impedance means phones and MP3 players can easily get a good noise out of them. However, if you haven’t got a full hi-fi to push them, a good USB DAC or Headphone Amp for your laptop, such as the Audioquest Dragonfly or, in my case, the one in my MM-1s are definitely required along with a preferably lossless set of music files for you to hear. This isn’t the place to argue about whether you can really hear the difference between 128kbps MP3s and 96kHz/24-bit FLAC files. The simple answer is yes. Although these cans are probably tweaked slightly in favour of Rock-y music rather than lighter fare, there is no place to hide for shaky recordings or low-rate lossy files. Upgrade to Spotify Premium for the higher-rate streaming etc for better effect. Like hi-fi speakers as well, the 50mm drivers inside the extremely comfy over-ear cups need a little warming up. Plug them in, throw them a day-or-two long playlist and come back on Thursday.

What you’ll hear is stunning. Put on a multi-layered track like Tool’s Vicarious and the extra definition brings a greater sense of space to the music. The individual strands of the intro are no less complex but more understandable. Something I’d miss on my Sennheisers. The ability to deal with different styles of heavy, low-end sounds is also impressive. Strapping Young Lad’s City is presented as a clean, almost clinical, dense barrage of noise, Meshuggah’s Alive seethes and lurches rather than crunches and never loses the audience noise even midway through a song, and Earth’s Omens and Portents is slow, oppressive and arid.

Spinning up the other end of the aural spectrum and the D600s sense of space allows far quieter, more minimal tracks to shine. Seasick Steve’s Treasures is melancholic with the banjo/violin duet more obviously pitched to the far left and right of the centre acoustic guitar while retaining a full character for each instrument. Gorecki’s Totus Tuus requires its choir to sing from forte down to molto pianissimo. That line of diminuendo gets flattened a little by the D600s belying its bassier tendencies but still fares better than my earlier Sennheisers that lose the distinction far quicker in order to keep something audible.

If there’s a tiny cloud in the otherwise blue audio sky, it’s when dealing with electronica creating full spectrum pink noise (cf. William Fowler Collins “Perdition Hill Radio” or drone (Nadja “Now I Am Become Death”) when the mid-range feels neglected for the treble and bass. It’s only a small neglect though – the D600s still do far more good for the music than ill.

£500 is, frankly, a huge investment for a pair of headphones. But, just as a chair is the best investment a desk jockey can make, so too are headphones the best investment a music loving desk jockey can make too. And cheaper than a chair. I’m going to love these headphones and don’t regret buying them for a minute.

TypeScript Revealed Details

danm@hmobius.com — Wed, 16 Jan 2013 12:00:00 +0100

It's only been a few months since TypeScript was released on October 1 last year, but I'm pleased to say that my new book 'TypeScript Revealed' is being published on January 23 by Apress. I think my original title, 'A First Look At TypeScript' is a more accurate description of its contents, but there are series titles to be considered :-) It's a modest 100 pages or so and is available in both paper and e-book formats. It covers up to v0.8.1.1.

The book is aimed directly at .NET programmers who've needed to use JavaScript in the past but haven't really gone any further with it. It won't teach you JavaScript from scratch but it will use the C# and VB.NET syntax you're familiar with to introduce the new syntax features that TypeScript adds to JavaScript. It will also help you integrate TypeScript into your existing web and Windows 8 application projects and point you in the right direction of the key discussions and bugs on Codeplex and the community efforts on github.

Download the code samples for this book (175 KB)

Here's the full table of contents:

What is TypeScript?
Covers the need for TypeScript, what it does and doesn't do, and how to install it in Visual Studio, node.js, and Sublime Text
The New Syntax
Covers the type system, functions (parameter types, overloading and arrow), classes, interfaces, modules and features yet to come. Also notes the refactoring options in Visual Studio.
Working With TypeScript
Covers the compiler, generating \ sourcing declaration files, integrating TypeScript into your own projects, and how it fits into the development lifecycle.

Apress' official page for the book. Please use this link to submit any errata for this book.

I've also started a Facebook page for the book containing any new TypeScript articles and links.

Buy it on Amazon UK, Amazon US, Barnes and Noble, and Book Depository (UK)

Simple.Data.Docs and Sample Into 2013

danm@hmobius.com — Wed, 02 Jan 2013 23:06:00 +0100

On March 27 last year, Mark Rendle put an idle call out into the ether for help with the documentation for his Simple.Data project. At a loose end, I said yes...

It has been a busy nine months in the world of Simple.Data.Docs. Mark has been busy, releasing no fewer than 16 new builds of Simple.Data.Core from v0.16 to v0.18.3 / 1.0.0-rc3 since that time which have been collectively downloaded some 9110 times according to nuget.org. I'd like to hope that the documentation that's being slowly assembled is to your satisfaction. It's gratifying to note that since adding in some counters in early October, we've had some 22600 page views (14500 unique) from 4500 visits (1700 unique) to the doc site and 2 complaints so it can't be all bad.

A few thanks then to

Marcus Hammarberg for his coverage of testing with the InMemoryAdapter
Jeff Schumacher for his Advanced Naming Scenarios commit
Code52 for their metro.css project. The new Metro-style docs have certainly made the site a nicer place to visit and work on.

I'm about 70% finished on the major, basic topics (based on the Simple.Data.SqlServer provider) and, assuming that I don't have to pause efforts for another three months to write a book, the core of the docs should be complete for the first year anniversary. Hurrah!

It's important to note that I've also been updating the Simple.Data.Sample project to map to and expand on those examples I've included in the docs. Although it hasn't been updated on NuGet since I took over, you'll find the code itself completely refreshed with 100+ new query samples to look at in addition to those in Mark's own test suites. Once the core docs are finished and Simple.Data v1 is finally released, hopefully Mark will be kind enough to update the Sample package on NuGet as well. I'd also like to release it as a VB package and as a set of nUnit tests as well once that has happened. Currently it is a C# command line application.

Once the core docs are complete, I'll add in updates and extra pages for helper functions in the API as they are requested or queried about on the group, but there are a couple of areas I'd like to look at

Incorporating the docs for other Simple.Data providers into the site. Vagif Abilov has completed his Simple.OData docs and we'll work together on how best to integrate the two. Hopefully, the same can happen with other provider owners.
Documenting the Simple.Data adapter and provider models and how to write your own.
Real-world scenarios and gotchas.

It's this last area in particular, that I'd like to ask your assistance with. Whether you're querying MongoDB, SQLAnywhere, oData, SQL Server, Azure, or something else, if you've come across and then resolved any sticky issues using Simple.Data which you'd be happy to share with the world, please get in touch or leave a comment below. It would be great to hear from you.

Inferred Hierarchies and Evaluation Strategies in Simple.Data

danm@hmobius.com — Sun, 14 Oct 2012 00:00:00 +0100

This is the second of a number of posts derived from the documentation for Simple.Data that I’m compiling and writing at the moment. The code here is part of the Simple.Data.Sample project on github.

Simple.Data is bloody clever at times but quite easy to get confused by. The most common confusion is between using commands that return multiple results as a SimpleQuery object and those that return a single results as a SimpleRecord object. With the return type hidden under the veil of ‘dynamic’ it’s easy to lose track and try to call a method on one that only works on the other. It’s the main reason for Mark to deprecate the FindBy method for v1.0. The second most common is around the subject of lazy\eager-loaded JOINs and what that means in your code.

Let’s take an example and suppose we have two tables in our database, Artists and Albums.

The simplest way to display an artist’s details and album titles would be this.

// Retrieve artist with PK value of 22
var lazyDynamicArtist = db.Artists.Get(22);
Console.WriteLine("Artist {0} ({1})", lazyDynamicArtist.ArtistId, lazyDynamicArtist.Name);

foreach (var album in lazyDynamicArtist.Albums)
{ 
  Console.WriteLine("\t{0}", album.Title); 
}

Simple.Data adopts a lazy evaluation strategy so lazyDynamicArtist is not evaluated until accessed for the first time in the first call to Console.WriteLine. Then it sends the following SQL to the database.

SELECT TOP 1 
  [dbo].[Artists].[ArtistId], 
  [dbo].[Artists].[Name] 
from 
  [dbo].[Artists] 
where 
  [ArtistId] = @p1
@p1 (Int32) = 22

This explains the existence of the ArtistId and Name properties for lazyDynamicArtist, but where has the Albums property come from? Answer: Simple.Data has inferred the hierarchy of tables / existence of the Albums property from the foreign key relationship between Artists and Albums table. Once again, the Albums collection is evaluated only when accessed for the first time (here, as part of the foreach loop). When that occurs, another query is sent to the database and silently returns another dynamic object to iterate through.

select   
  [dbo].[Albums].[AlbumId],
  [dbo].[Albums].[GenreId],
  [dbo].[Albums].[ArtistId],
  [dbo].[Albums].[Title],
  [dbo].[Albums].[Price],
  [dbo].[Albums].[AlbumArtUrl] 
from 
  [dbo].[Albums] 
WHERE 
  [dbo].[Albums].[ArtistId] = @p1
@p1 (Int32) = 22

Note that despite Simple.Data’s name resolution tricks when parsing table and column names in query functions, accessing artist.Album will throw an exception. Simple.Data does not use any pluralisation rules at this point. You must use the exact table name as a property to access to the inferred hierarchy.

This lazy evaluation strategy does have its drawbacks however. The most obvious is the number of SQL commands you can end up sending to the database. In this example, with only two tables needing to be accessed for a single artist, only two statements are sent. In general, n+1 statements will be sent: one for the list of artists and one per artist (n) for each list of albums to retrieve. Add in more tables, and the number of SQL commands sent to the database is quickly far more than your DBA would prefer you make

Another less immediately obvious down side to this strategy comes via Simple.Data’s ability to cast the results of a query into a statically typed object (POCO) on the fly. Let’s say we have an Artist class defined like this:

public class Artist
{
  public int ArtistId { get; set; }
  public string Name { get; set; }
  public IEnumerable<Album> Albums { get; set; }
}

If we try the following code, we hit a snag:

// Cast result of query to Artist type
Artist lazyPocoArtist = db.Artists.Get(22);  

Console.WriteLine("Artist {0} {1}", lazyPocoArtist.ArtistId, lazyPocoArtist.Name);

foreach (var album in lazyPocoArtist.Albums)
{
  Console.WriteLine("\t{0}", album.Title);
}

The first two lines of code work fine, but lazyPocoArtist.Albums now returns null. The inferred hierarchy is lost as a result of casting the dynamic (SimpleRecord) object to the static Artist type, no evaluation of Albums occurs and a System.NullReferenceException is thrown.

Recap

In brief then,

Access the artist information as a dynamic (SimpleRecord or item in a SimpleQuery) object and the Albums property will be evaluated when it is accessed for the first time. It will become available as another dynamic (SimpleQuery) object to iterate through. Note that even if the artist in question has no albums attached to it in the database, a SimpleQuery object is still created but with nothing in it to enumerate.
Access the artist information as a POCO and the Albums property will return null.

Eager Evaluation

It’s fairly obvious that the lazyPocoArtist variable returns null for its Albums property because Simple.Data didn’t actually retrieve any Album information for the artist before it was cast into the Artist type. It was lazy. Fortunately, we can change the initial query command and turn Simple.Data into a pre-emptive, eager data retrieval machine. All we need to do is add a With statement like so.

var eagerDynamicArtist = db.Artists.FindAllByArtistId(22).WithAlbums().FirstOrDefault();

Console.WriteLine("Artist {0} {1}", eagerDynamicArtist.ArtistId, eagerDynamicArtist.Name);

foreach (var album in eagerDynamicArtist.Albums)
{
  Console.WriteLine("\t{0}", album.Title);
}

Note that I’ve switched from using Get to FindAllBy.FirstOrDefault to return a SimpleRecord object.

There’s currently a bug using Get with a With statement in that it only returns the first row in the JOINed table rather than them all.
Once the bug is fixed, the equivalent statement would be var eagerDynamicArtist = db.Artists.WithAlbums().Get(22); which looks odd, but needs to be this way around or Simple.Data will throw an exception.

As with the lazy loaded sample earlier, eagerDynamicArtist is not evaluated until accessed for the first time in the first call to Console.WriteLine at which point it sends the following SQL to the database.

select 
  [dbo].[Artists].[ArtistId],
  [dbo].[Artists].[Name],
  [dbo].[Albums].[AlbumId] AS [__withn__Albums__AlbumId],
  [dbo].[Albums].[GenreId] AS [__withn__Albums__GenreId],
  [dbo].[Albums].[ArtistId] AS [__withn__Albums__ArtistId],
  [dbo].[Albums].[Title] AS [__withn__Albums__Title],
  [dbo].[Albums].[Price] AS [__withn__Albums__Price],
  [dbo].[Albums].[AlbumArtUrl] AS [__withn__Albums__AlbumArtUrl] 
from [dbo].[Artists] 
  LEFT JOIN [dbo].[Albums] ON ([dbo].[Artists].[ArtistId] = [dbo].[Albums].[ArtistId]) 
WHERE 
  [dbo].[Artists].[ArtistId] = @p1
@p1 (Int32) = 22

The With statement is fluid like FindAllBy, so by adding WithAlbums into the command chain, it knows to include the contents of the Albums table in its query to the database and that it must then collate the results into one row of information about an artist. It does this with a LEFT JOIN statement. The net result is that eagerDynamicArtist is created with an Albums property already populated with all the albums in a SimpleList object - another IEnumerable<dynamic>.

As with lazyDynamicArtist, you can just iterate over a SimpleList to access each item it contains so the rest of the example code here remains the same. The main difference is that there are no additional SQL statements sent to the database on the fly, so your DBAs will like you a lot more, except if there are no items in the Albums table matching the artistId. More on that in a minute.

So how does this look when casting eagerDynamicArtist to a POCO? It works very well.

Artist eagerPocoArtist = db.Artists.FindAllByArtistId(22).WithAlbums().FirstOrDefault();

Console.WriteLine("Artist {0} {1}", eagerPocoArtist.ArtistId, eagerPocoArtist.Name);

foreach (var album in eagerPocoArtist.Albums)
{
  Console.WriteLine("\t{0}", album.Title);
}

eagerPocoArtist.Albums is populated and cast correctly from a SimpleList into an IEnumerable<Album> (or whatever subtype you prefer) for your code to iterate through. Hurrah! But with a proviso....

When there are no matching items in the JOINed table

What happens in an eager-loading scenario if the Artists table contains a row with no matching rows in the Albums table? Answer: the LEFT JOIN generated by WithAlbums returns null for all the Albums table fields.

If the result is accessed as a dynamic object, eagerDynamicArtist will not have an Albums property pre-generated at all. However, because Simple.Data still infers a hierarchy via foreign keys, it evaluates the Albums collection again when accessed for the first time (here, as part of the foreach loop), sending another query to the database which again returns no results as a dynamic (SimpleQuery) object. (But not a null one)
If the result is cast first to a POCO, eagerPocoArtist.Albums will be set to null, so it will have to be tested for null before being iterated over.

In a nutshell then, if the JOINed table has no associated rows, Simple.Data drops back to behaving as if it were lazy-loading data rather than eager-loading it. Coder beware.

Wrapping Up

The examples above are all predicated on the following assumptions:

The code is using the Simple.Data.SqlServer provider to access the database. YMMV if you are using a different Simple.Data.ADO-based provider
The two tables have a foreign key relationship between them and referential integrity is being maintained. Without it, the inferred hierarchy does not exist and the Albums property only exists if you eager-load it using the WithMany method rather than With. The former (and its corresponding WithOne method) allows you to specify the relationship between two tables while the former bases it on existing FK relationships.

You can find more about joining tables in the Simple.Data documentation.

NotMetro: A Theme For dotNetBlogEngine

danm@hmobius.com — Tue, 25 Sep 2012 12:00:00 +0100

I uploaded my first theme for dotNetBlogEngine today. You’ll find it at http://dnbegallery.org/cms/List/Themes/NotMetro. It’s powering the very blog you’re reading now. It’s called NotMetro as it borrows from the official Metro styles document but not too much. And of course, it’s not called Metro any more, is it.

Here are the specs.

HTML5 – Uses the html5shiv to make it IE8- friendly. Not Modernizr as there’s no fancy CSS. Borrows a few ideas from the HTML5 Boilerplate project too.
CSS – Uses normalize.css and styles from Code52’s wonderful metro.css project
Javascript – Aside from the shiv, none more than BlogEngine already uses.

Layout is one wide, 900px column. The widget zone is in the footer at the end of the page. All standard widgets look fine in it.

For the benefit of those reading with a feedreader, here’s a screenshot.

Any and all feedback would be gratefully received

DeveloperFusion Needs A New Editor

danm@hmobius.com — Mon, 17 Sep 2012 22:00:00 +0100

After a very happy eighteen months as editor of DeveloperFusion.com, I’ve decided to move on and write some more of my own copy rather than commission and edit other peoples for a while. Which means that James and Nick are looking for a new editor. If you have some spare time and would like to contribute to the great community of .NET developers, get in touch at hello@developerfusion.co.uk.

Windows 8 First Thoughts And Notes

danm@hmobius.com — Tue, 04 Sep 2012 10:53:00 +0100

I repaved my main machine yesterday from Win7 to Win8. I’d not played with Win8 at all before and only read about the desktop\touch pain and big start menu discomfort.

Here are my thoughts and reactions as I went along and tried a few things:

Installation \ Users

Installation off USB stick. Very slick. Only memory card reader not recognized. Even external USB speakers have built-in drivers.
Hmm. Must create first admin user as one connected to a Live account. Why would I want to do that? No option to create further users either. Why remove that? ‘Twas very handy, that.

Paranoid thought. Isn’t a linked account as admin dangerous? Could someone back hack your computer through an admin account like they did with Mat Honan? (Honan, what is bet in life? Not that, I’m guessing)
Once you’ve found the control panel, it is possible to unlink your admin account btw. Linked accounts allow you to sync ‘settings’ to all your linked devices. What settings they include, it doesn’t say, and if you’ve only one device (like me), there doesn’t seem a point to linking an account.
Now if there was an option to save your registry settings – effectively a Windows save point – to the cloud, so when you next repave, you could restore all the control panel settings you’ve tweaked with a click of the mouse that would be great. Sign me up. But alas, no.

New lock screen is pretty. Press any key to log in. Click-swiping with mouse doesn’t seem to work. Maybe I’m not doing it right.

Touch Apps

Start screen is a bit imposing isn’t it. Sure I’ll never use some of these apps. Games, Finance, Maps – goodbye.

To uninstall a touch app, right click and select uninstall from options that appear at the bottom of the screen. They aren’t listed with desktop apps in the Programs and Features control panel.

Try the Apps Store and see what I can find.

The most obvious thing I CAN’T find is a search box for apps – just a seemingly infinite right-scrolling list of categories with three apps in each.
Don’t know how it works for touch users, but simply typing something brings up the search dialog. Not very obvious.

Oddly enough, what I really want now is the first thing I dismissed in Win7 – the demo video tour guide. All these touch apps are very in your face – full screen, big fonts – without much in the way of visual aids for the newcomer.

Happy to note that Alt+F4 still kills an app and Alt+Tab still cycles through your open tabs.
Finally found the ‘help’ button. Unhelpfully, it’s not F1 any more. It’s in the Settings charm for the app currently onscreen (Swipe to right edge of screen or Win+C). Also unhelpfully the help option seems to be optional and not all that helpful.

The People app is telling me it is already connected to my live account, twitter, and linkedin. Really? When did that happen. Used the settings charm to add Google+, Facebook.

Privacy conscious people can thus disconnect accounts as required.
Search for people in three ways: start typing, scroll right, or click the little minus button in the bottom right of the app to ‘zoom out’ and group all contacts under the letters of their first names. Home, End, Page Up and Page Down also work.
The What’s New view is a great, clean amalgam of Facebook wall and twitter feed.
It’s obvious how to reply to someone’s update on Twitter or Facebook but not how to send a Tweet or update your own Facebook wall. App has an oddly read-only feel to it as a result.

The Mail app is also pretty to look at and useful to set up so your lock screen tells you how many emails you have without needing to check, but I’ll stick to Outlook.
Worth noting the ‘Change PC Settings’ option at the bottom of the Charms window (Win+C). Probably the best part of the touch-half of Win8 I’ve found so far.

It’ll be nice to get a Surface RT. At the moment, from a desktop users perspective, I think I’ll save the touch apps for use as a read-only, non-work view on things. And also figure out what all the sharing options do – especially when facebook keeps changing it’s definition of privacy and resetting our privacy settings. It’s hard enough for one hand to know what the other is doing without there being six hands to keep track of and one speaking in tongues.

Desktop Apps

Huzzah, the desktop. Feeling safer. Win8 has been appealing for several reasons, not the least of which are the apps I don’t need to install any more:

Virtual Clone Drive : ISOs are now supported as folders natively by Win8. Yes!!
Start Killer : Because there’s no start button now anyway.
Slickrun, Teracopy, and Foxit PDF Reader : For now.

And also the new features in Win8 are straight to install as well:

Hyper-V on the client. Huzzah!
IIS8
WebSocket protocol for IIS8. (Under WWW Services \ App Dev Features)

Sadly there’s no native support for eBook formats still, so that’s still the Kindle desktop app to install. Or whatever you use.

Scott Hanselman blogged a great list of keyboard shortcuts to get around the Win8 desktop. These will help your comfort level greatly for a while. Write them down until they are in your subconscious.

Here are some more thoughts on my desktop experience so far.

Desktop apps don’t talk to their touch equivalents. Sadly. I’m not sure if it’s possible to do so, but it would seem beneficial if it was.
Hitting the Windows key to start a new app is a big lurch. I really miss SlickRun \ Launchy right now for the lack of desktop disturbance they caused. I used to use Winkey to bind apps to Win+number before slickrun but again the UX shift of having something pinned to the taskbar which isn’t running so you can start it with Win+1, 2,3, etc is again a bit lurchy.
Installing apps on the desktop is very “quiet”. On Win7 , you installed something and the start menu would shout at you the next time and highlight it so you could find it. Not in Win8. The new start menu tile is buried somewhere to the right in tile view and there’s sadly no ‘just installed’ group in the list view of the start menu either.
Theming seems to have gone awry. You can change window border and taskbar colours to black (my preference in Aero) with no means of changing the font colour from black. In fact, the whole ‘advanced colors’ dialog of earlier windows seems to have disappeared and the ‘automatic color’ option is a bit odd, keying off the main color of the current desktop background.
The Win+X menu is a great addition. Must figure out the registry settings to add\remove entries from there. Hyper-V \ IIS would be useful additions.
Even though I’ve switch the display scaling down from 125% to 100%, all the window title fonts are still the same size taking up way more space than they need to and screwing up other things like Outlook’s nav pane.
Oddly, I was surprised to find that the VS2012 installer does not include an option for SQL 2012 Express as previous editions of VS did. Oddly, it’s not an option in the Web Platform Installer either.
Windows Live Photo Gallery is broken in Win8 at the moment. Sadly.

So there we have it. Currently my head is still adapting to the Win8 way of doing things as well as its look and feel. Intuitively it feels like the way to run Win8 as a desktop machine is either to ignore touch apps completely or to use them as a read-only view of your online profile. Most of them just don’t feel customizable enough to tweak them as I want at the mo. And also, to use local accounts rather than live accounts if you haven’t a compelling reason to do so.