@ Head

Visual Studio toolbar

bill — Wed, 07 Mar 2012 06:46:41 GMT

The beta of Visual Studio 11 is causing a lot of feedback around the grey shade icons. The use of colour or not has also brought to the forefront the UI for colour-blind people. So I thought I’d post a picture of my toolbar, along with some links to see the page as seen by those with colour-blindness...

My toolbar:

Colour-blind filter web site: http://colorfilter.wickline.org/

This post on the above site:
http://colorfilter.wickline.org/?a=1;r=;l=0;j=1;u=msmvps.com/blogs/bill/archive/2012/03/07/visual-studio-toolbar.aspx;t=p

windows 8 likes and dislikes

bill — Sat, 03 Mar 2012 02:40:40 GMT

There’s a lot to like in windows 8 preview: it’s easy to see how windows 8 will be a hit on tablet devices; there’s massive synergy with windows phone; the built in windows live experience combined with your settings in the cloud, make it smooth to go from one device to another. But there’s other bits I’m not so fond of ...

The Start Menu

Obviously the biggest change people first see is the start menu is now a start page. I like the concept but dislike the fine details on how it is implemented. At present to get to the start menu you have to move your cursor to the lower left of the screen; to see “running” apps you have to move it to the upper left then swipe down; to see all applications you need to right click to see the “toolbar” along the bottom of the screen and select all apps. It’s those details I don’t like. They aren’t intuitive, they aren’t obvious. People have to go through an initial period of disorientation: that’s a negative first taste for existing customers. What I’d much prefer to see is :

Put the windows start button back: not the start menu, just the button. Call it branding if you like, but having the windows button visible always would make the experience a lot more intuitive
Make the start screen a start portal, not just a start menu replacement. That is, get rid of the silly running application list on the left and instead have the start screen have three or four title style buttons along the top (similar to windows pivot app style) that would give you the choice of Favourites, Running and All. Perhaps even a Most Recent as well. The running app list at the side just doesn’t work well for me. They look too much alike, there’s no captions, and the space is limited. It’d make a lot more sense to use the whole screen for running apps, just like it makes sense to use the entire screen for the start “menu”. Currently there is a disconnect of design.
When in desktop mode the start button would be there (see 1 above). Clicking on it would show you the start screen BUT not in full screen mode. Instead have the start screen appear floating: eg a 20 pixel margin all around and a drop shadow. It would make the experience feel more connected rather than the current disconnect.
Allow metro apps to run in “windows”. That is you should be able to preference any metro app to run inside a window on the desktop. This should be a right click preference from the start screen, and likewise from the running app screen to move apps to and from the desktop windows experience. I think this is important for a lot of existing customers who will find themselves still on the desktop and currently experience a disconnect from the metro start screen.
Better panel docking. It seems a step backwards when you can only dock as a thin pane to the side without being able to resize. This totally failed for me when I tried to have my mail on the left pane and my calendar as the main screen (try it: I couldn’t actually read the email). Panels should be able to be sized, apps need to be able to respond to that better than what’s in the preview, and most importantly you should be able to work with desktop applications (4, above would help solve this for metro and desktop apps working side by side)

Overall I kind of like windows 8: I’d like to like it a lot more but it just doesn't feel as if it is there yet. I think the above list of changes would go a long way to bring in the new experience in a much less discordant way.

VB Quark #7 : Optional Parameters and Dates

bill — Wed, 09 Nov 2011 04:14:54 GMT

Hopefully you already know VB has full support for Optional parameters, both declaring them and calling them, but did you know you can use Dates as Optional parameters ?

   Public Sub AddNewCustomer(customer As Customer,
                             Optional dateAdded As Date = Nothing)
      If dateAdded = Nothing Then dateAdded = Now

VB has had this support for Optional parameters in place for the last decade or so in .NET and for years before that back in the COM versions of VB.

In the last release of .NET (VS 2010), C# finally got support for Optional parameters, so the above in C# would look like:

     public void AddNewCustomer(Customer customer,
                           DateTime dateAdded = default(DateTime))
      {
         if (dateAdded == default(DateTime)) dateAdded = DateTime.Now;

The Nothing in the VB declaration is the same as default(DateTime) in C#, which equates to the theoretical Gregorian date of 1/1/0001.

But what if you want to specify a default date ? Well because VB supports date literals, in VB you can, but in C# you can’t. In VB you can write any date literal for the optional parameter value. For example, you might have some legacy database support, and when the date is unknown you want to use the equivalent of an OLE Date’s zero value:

Public Sub AddNewCustomer(customer As Customer,
Optional dateAdded As Date = #12/30/1899#)

When the VB compiler compiles this, it adds a System.Runtime.CompilerServices.DateTimeConstantAttribute to the parameter information with the default value stored as an Int64 (the number of ticks). C# actually sees the optional value in the above example and will use it. That is both VB and C# can call the code taking advantage of the optional value for the date parameter, but only VB let’s you define that value.

Displaying Dates in VS 2010

bill — Tue, 08 Nov 2011 05:30:00 GMT

From time to time there’s discussion about the way dates are displayed in the Visual Studio IDE for Visual Basic. Typically dates are shown using VB’s date literal syntax of #MM/dd/yyyy# which is the standard US format. For people outside of the USA this can be confusing or ambiguous at times. The good news is Visual Studio allows you to easily add your own display formatter.

Simply create a new class library project, add the following attribute to your AssemblyInfo file:

<Assembly: DebuggerDisplay("Date: {ToString(""s"")} kind={Kind}", Target:=GetType(DateTime))>

And then just copy the assembly to your Visualizers directory, eg:
My Documents\Visual Studio 2010\Visualizers

I added the Kind property to the display so as you can easily see if the Date is a local date, UTC or unspecified.

I've attached a sample project. Enjoy

VB Quark #6: Date operators

bill — Wed, 26 Oct 2011 06:28:19 GMT

The DateTime structure in .NET includes custom operators for Date comparisons such as less than, greater than, equal and not equal; but did you know it also includes addition and subtraction operators ? There’s two subtraction operators and one addition operator defined inside DateTime:

date = date – timespan
timespan = date – date
date = date + timespan

Those three cases should all seem relatively obvious, such as adding or subtracting an hour from a date, or calculating how many minutes between two dates etc...

BUT, did you know VB also defines another case where you can add two dates, eg:

Dim result = Date1 + Date2

Now if you guessed that the type of result is String, then congratulations !! Note: this operator resolution is only valid with Option Strict Off

Obviously adding two dates can’t give a valid date or timespan, so the only real options are to return a string concatenation of the date or throw an error. There are a couple of fringe cases where, depending on your system locale, the resultant string can indeed be parsed back into a date, eg:

      Dim dt1 = #1:00:00 PM#
      Dim dt2 = Now.Date
      Dim dtResult As Date = dt1 + dt2

But that really is a fringe case, and would depend on the system locale formatting.

I think it’s probably fair to say this case is a quirk of a quark, probably introduced as partial legacy. I honestly can’t see any usefulness of the addition operator between two dates that returns a string. If the intent was some legacy support, it might have made sense to return a date if one of the dates was date zero with time information, but the concatenation of the date strings doesn’t seem to reliably serve any purpose.

The good news is you can only do the string = date + date operation with Option Strict Off. Guess that’s just another reason to turn Option Strict On

VB Quark #5: C is for Char

bill — Thu, 29 Sep 2011 05:50:20 GMT

Can you pick the problem with this code ? :

      Dim currentChar As Char

      For i = 0 To largenumber
         currentChar = getChar(i)
         If currentChar = "a" Then
            count += 1
         End If
      Next

The answer of course is the literal “a” is of type string, not of type Char. Hence currentChar gets implicitly widened to a String to make the expression a string comparison expression. This means a new string is created with the contents of currentChar on each iteration, and the comparison is a string comparison which checks for null strings and empty strings and then does a compare ordinal etc. This is incredibly inefficient.

If “a” was typed as Char, then the comparison is a simple low level IL compare of the underlying values (int16’s).

You can use CChar, as in CChar(“a”), but it’s a lot easier just to add the type literal suffix c, eg “a”c

      Dim currentChar As Char

      For i = 0 To largenumber
         currentChar = getChar(i)
         If currentChar = "a"c Then
            count += 1
         End If
      Next

The change in this code is about 20 fold performance improvement (run as release build outside of Visual Studio). That’s a 20 fold increase just by typing one extra letter !!

This example was based on real sample code where a massive file was being parsed char by char. There too, attention to the fine detail showed a massive performance improvement over the original code. It’s often the little things that can make a huge difference.

This VB quark was brought to you by the type literal “c”

VB Quark #4: type literals

bill — Mon, 26 Sep 2011 05:54:00 GMT

Do you know why you can’t write this code in VB:

Dim x = 123456789.0123456789

Answer: The IDE won’t let you

If you try to write that code the IDE will truncate the number, giving :

Dim x = 123456789.01234567

To include all the decimal places you need to be using the Decimal type. To do this you indicate the constant is of type decimal by adding the suffix D on the end, eg:

Dim x = 123456789.0123456789D

The reason for this is VB treats numeric literals as of type Double by default if they have a decimal place. If there is no decimal place in the literal then the value is consider to be an Integer (Int32), or if it is too large for an Integer, it’s considered to be a Long (Int64).

If you want the literal as a type other than Double, Integer or Long you need to either convert using CType, CShort, CSng etc, or add a type literal suffix. The following is the complete list for numeric type literal suffixes in VB:

Suffix	Type
F	Single
R	Double
D	Decimal
S	Int16, Short
I	Int32, Integer
L	Int64, Long
US	UInt16, UShort
UI	UInt32, UInteger
UL	UInt64, ULong

In case you’re wondering, the “F” for Single is short for "Float”, and the “R” for Double is short for “Real Number”.

Here’s another example of where you should use type literal suffixes. Consider this code :

      Dim i1, i2 As Int16
      i1 = &HF0
      i2 = i1 And &HFF

If you have Option Strict On, the last line will cause a compile time error saying that an implicit conversion from Integer to Short is not allowed. So what is happening here, and why doesn’t the middle line cause the same problem ?

Well the line i1 = &HF0 compiles fine because the constant &HF0 can be evaluated at compile time, so there’s no problem there. The last line however cannot be evaluated because the variable i1 is not a constant. Try it for yourself if you like: change the declaration of i1 to a Const, and you’ll see the last line compiles fine with Strict On.

Because VB can’t evaluate the variable expression at compile time, it uses the default type for numeric constants : Integer (aka Int32). And because a short can be implicitly widened to Int32, the expression on the right hand side becomes an Int32: hence the error.

In Visual Studio the error correction wizard will suggest converting the entire expression to an Int16, as such :

i2 = CShort(i1 And &HFF)

But that’s a runtime conversion that isn’t needed if you declare the &HFF constant with the correct type literal suffix S:

i2 = i1 And &HFFS

As you can see, the code correction wizard in Visual Studio doesn’t always provide the best syntax to use, so it really is up to you to know the correct literals to use and apply them.

Oh, you may have also noticed there is no type literal suffix for Byte and SByte. I’ll leave that for yet another quark

VB Quark #3: operator differences in VB/C#

bill — Sun, 25 Sep 2011 10:20:00 GMT

Can you spot the problem with this code:

   <Extension()>
   Public Function ToColor(argb As UInteger) As Color
      Return Color.FromArgb( _
                      CType((argb & &HFF000000) >> &H18, Byte), _
                      CType((argb & &HFF0000) >> &H10, Byte), _
                      CType((argb & &HFF00) >> 8, Byte), _
                      CType(argb & &HFF, Byte))
   End Function

If you said it should be the bitwise And operator not the string concatenation operator give yourself a pat on the back. The problem here is three fold:

The code is a failed attempt at translating from C#, and
The project must have Option Strict Off for this code to even compile.
No testing or unit tests to check if the code works at runtime.

Sadly this is all too common. The above is in fact a very real example taken from the Silverlight Toolkit samples on Codeplex .

So the steps to correct this are first be aware of the language equivalents when translating from C# to VB. See the MSDN documentation on language equivalents for a great starting point. And take note of the operator equivalents. Some of the most common operators where people seem to make mistakes are:

operator	VB	C#
bitwise And	And	&
bitwise Or	Or	\|
bitwise exclusive Or	XOr	^
Short circuited Boolean And	AndAlso	&&
Short circuited Boolean Or	OrElse	\|\|
equality	=	==
assignment	=	=
not equal	<>	!=
exponent	^
modulus	Mod	%
string concatenation	&	+

From the short list above you can see the ^ and & operators have very different meanings in VB compared to C#. Which leads us to items 2 & 3.

If you are unsure of VB, or are translating and hence have a lot of code that *may* be invalid you can improve catching of these kind of developer mistakes by turning Option Strict On. In the original example, the argb & &HFF000000 would have given the result of a string: argb.ToString followed by –16777216. At runtime this string would then try to be converted to a number and then shifted right, most likely failing.

So if you turn Option Strict On, you’d immediately get warnings on trying to convert the string to a long. But even once you’ve got it compiling with Strict On, you should test the code. A lot of code you can quickly query in the immediate window, or write unit tests.

Oh, and the corrected code in this particular case is:

   <Extension()>
   Public Function ToColor(argb As UInteger) As Color
      Return Color.FromArgb( _
                      CType((argb And &HFF000000) >> 24, Byte), _
                      CType((argb And &HFF0000) >> 16, Byte), _
                      CType((argb And &HFF00) >> 8, Byte), _
                      CType(argb And &HFF, Byte))
   End Function

For a complete project that fixes the VB samples for the Silverlight Toolkit, see my blog post from last month

VB Quark #2: compiler directives and constants

bill — Sat, 24 Sep 2011 04:31:00 GMT

Building upon VB Quark #1 , did you know you can use compiler directives alongside expressions in constants ?

#If CONFIG = "Debug" Then
Const path As String = "Z:\mydebug.sdf"
#Else
Const path As String = "|DataDirectory|\Database1.sdf"
#End If

Const connectionString = "Data Source=" & path

The nice thing about this is as you change the config from Debug to Release, Visual Studio will grey out the parts that aren’t in the current compilation. In the above example, when I do a debug build I’m using my database in Z:\mydebug.sdf, but when I do a release build it automatically uses the database Database1.sdf in the application’s DataDirectory.

You can use compiler directives pretty much anywhere in your code to replace any code block with another at compile time based on the directives.

VB Quark #1: constant expressions

bill — Sat, 24 Sep 2011 03:56:00 GMT

This quark is more of a did ya know quark about constant expressions in VB. You probably know you can declare a constant expression such :

Const appName As String = "My Really Cool App"

But did you know you can also do operations in constants ?

Rather than calculate the area of a circle you can write:

Const radius = 4.2
Const area = Math.PI * radius ^ 2

The compiler will calculate the area constant at compile time. This makes it easy to change the area constant by simply changing the radius.

The operations you can do include all the standard mathematical operations : +, –, /, \, * , ^ and Mod as well as bitwise operations such as And and Or as well as bit shifting << and >>.

For example you can declare an enum for bits using shift operations: (note: Enums are constants)

   Public Enum bits
      bit0 = 1
      bit1 = 1 << 1
      bit2 = 1 << 2
      bit3 = bit2 << 1
   End Enum

You can also use the If operator. For example you might want to limit a constant based on another constant, eg if gravity is greater than 20g’s then you might want to limit it to 20g for calculations.

Const workingG = If(g < 20 * 9.8, g, 20 * 9.8)

And you can also do conversions between the intrinsic numeric types, eg CDbl, CSng, CDec, CLng, CInt, CShort, CByte, CULng, CUInt, CUShort, CSByte. And conversions to and from boolean to the numeric types: CBool and the aforementioned conversion operators.

Const roughArea As Int32 = CInt(area)

For dates, there aren’t any operations or conversions you can do: you have to define them using the literal representation in US format, eg today 24/9/2011 is defined as #9/24/2011# . This is still a lot better than certain other languages (not picking on C#) that don’t support constant date literals.

For strings, you can’t do any conversions but can use the concatenation operator &. You can use + instead of &, but I don’t recommend that (more on that in another quark). Strings that are compiled as constants are also typically interned.

Anywhere you use an expression that can be compiled as a constant, it is evaluated at compile time: you don’t have to declare a constant variable to reap the benefits of compile time evaluation.

VB Quark #0 : lambda expressions and statements

bill — Fri, 23 Sep 2011 01:43:00 GMT

This VB Quark is the one that started the conversation some weeks back. It’s number 0, both because these days things are typically 0 based in .NET, and also you could say it is ground zero. It’s about a quirk quark to do with lambda functions versus lambda subs.

Let’s say you have a Customer class that has an Approved property :

Class Customer
Public Property Approved As Boolean
End Class

Now if you were to write the following code on a list of Customer, what would you expect to happen ?

customers.ForEach(Function(cust) cust.Approved = True)

If you said nothing, you’d be pretty close to the answer.

The quirk quark here is two fold. First of, ForEach expects an Action(Of T) to be passed to it. Action(Of T) in this case has the form of:

   Sub DoAction(cust As Customer)
      'code here
   End Sub

But note we passed in a Function. Function’s have return types. In this case the return type is a Boolean implied from the expression cust .Approved =True . That is the = operator is an equality operation in this case, not an assignment operator. The original expression is seen by the compiler as the equivalent of :

      customers.ForEach(Function(cust)
                           Return cust.Approved = True
                        End Function)

If you actually want to set the IsApproved values in the ForEach you can simply use a Sub instead of a Function:

customers.ForEach(Sub(cust) cust.Approved = True)

So the quarks to remember here are the = operator in VB can be either equality test or assignment depending on the context; and not all lambdas are lambda expressions (aka Functions), some can be lambda statements (aka Sub)

I’ve seen this quark trip up a couple of really smart people, usually when they are translating code from C# to VB. Apparently some translation tools also make the same mistake.

VB Quarks …

bill — Fri, 23 Sep 2011 01:40:08 GMT

A few weeks ago I was having a discussion about a particular language feature that was causing a couple of people to trip up in their code. From that discussion we identified some places where the VB compiler and IDE can possibly help in the future; but for today there are some language features that often go unseen but combined do matter (geek pun intended).

So I’ve decided to put together a series of posts I’m calling VB Quarks. The things I’ll be covering are your gotchya’s, the easy to forget things, the little things that combined matter (oh sorry same sad pun again ).

Windows Phone Mango and multiple google calendars

bill — Thu, 22 Sep 2011 01:35:40 GMT

With Windows Phone 7.5 (aka Mango) being released in the next couple of weeks, you may have to work around a google limitation to get multiple google calendars on your device. Both Windows Phone 7.5 and google calendar allow you to have multiple calendars on your phone, but for whatever reason Google doesn’t let you see how to set that unless you trick it to think you’re using an iPad or iPhone. (shame on you google )

To trick google, you just need to change your browser user agent string. The steps are:

setup your google account on your phone as normal and sync with calendar and email. This will give you only the one google calendar for that account.
Next open up IE 9 on your desktop or laptop computer, press F12 to bring up the IE developer tools. Click on the developer tools Tools menu and select Change user agent string –> Custom

Add this user agent string:
Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10
Next browse to http://m.google.com/sync and log in to your google account. You should now see your windows phone device listed. Click on that and choose which of your google calendars to sync

Kudos to Anthony Chu who posted how to do this with Safari.

VB Windows Phone Toolkit Aug 11 sample

bill — Fri, 19 Aug 2011 12:57:20 GMT

The Silverlight Windows Phone Toolkit August 2011 (7.1 SDK) doesn't contain a working VB sample. If you try to load the VB sample that does ship, you’ll get hundreds of errors. So I put together the VB sample that should have shipped.

Download the VB Windows Phone Toolkit samples

Enjoy

Oh, and Thanks to Nick Randolph for confirming the SDK doesn’t contain a working example.

Remember variant ?

bill — Thu, 28 Jul 2011 03:40:39 GMT

Cory is continuing his posts about VB10 differences from VB6. His latest posts is on variants.

Variants were/are basically a structure that contains a variant type enumeration and either the variable’s data value or a pointer to the variable data. In pseudo code it basically looks like:

Structure Variant
Public VT as VariantType
Public Value As Object
End Structure

The Value field would hold the actual data in the case of simple value types, or a pointer to the object such as in the case of arrays. In the .NET world there are actually variant structures but not as part of the .Net framework: you can find one for example in the Microsoft.VisualStudio.Package namespace.

The reason you won’t find it in the framework is because the variant structure is not only limited but also superfluous in .NET due to the type system. Take for example the case of a value as a Double versus an Integer. In VB6 you would use Variant to allow you to pass both values to a method. The Value field would hold the actual data so it was important that the VT field told you the value type. The problem with this approach is the VT field is an enumeration, so doesn’t allow for custom value types to have their actual type discoverable: try passing a UDT into a variant and then determining which type of UDT is is in VB6 to see what I mean

In .NET the object based type system means you can always determine the type of a variable. So the “everything stems from Object” approach in .NET is definitely more versatile.

There was however one thing missing: yep, IsMissing was missing. Variants allow optional parameters to indicate if a value was missing. The first release of .Net didn’t have anything in place to indicate if an optional parameter was missing. It wasn’t until nullable types were added that you could do the equivalent of IsMissing by testing for Is Nothing. The Is Nothing approach is more holistic and uniform (as opposed to IsEmpty versus IsMissing et al) and works across the board for nullable types and As Object variables and parameters.

So, in summary, there was initially some gains and some losses with the move from Variant to an Object based system, but as the .NET framework and language implementations have matured, the Object based system (.NET) offers far more functionality and flexibility.

Oh, as you can probably see, the above explanation/description actually touches on a number of items in the list Cory referred to: in particular but not limited to items 11 and 27. I think it is always important to come up for air and see the big picture: the forest from the trees. The overall benefits of moving to Object based in .NET extend far beyond these one or two items.

a little help for volunteers

bill — Thu, 28 Jul 2011 01:31:39 GMT

Today Microsoft announced an even more generous program designed to help non-profit organisations !!

http://blogs.technet.com/b/microsoftupblog/archive/2011/07/26/expanding-microsoft-software-donations-to-more-nonprofits.aspx

Kudos guys!!!!

Thanks

Great Ocean Walk photos added

bill — Thu, 21 Jul 2011 05:28:40 GMT

Last weekend we strolled around Glen Aire, along the Great Ocean Walk from Castle Cove to Johanna:

More photos at:
https://picasaweb.google.com/Bill.McCarthy.MVP/GreatOceanWalk#

Dell XPS 17 (L702x) review

bill — Sat, 02 Jul 2011 04:37:42 GMT

I recently bought a Dell XPS17 (L702x) and thought I’d post a review for those considering purchasing this notebook. There’s a massive thread about all things good and bad in relation to this notebook over on notebook forums; the following is just my opinion

Weight : good for the size.

Screen: Love it !! I have the anti-glare screen (1920 x 1080) and it’s a lovely screen. I did make minor adjustments to the gamma, toned the blue down a bit and the green just a tad. Photos, especially nature scenes, look fantastic, true to life colours. The antiglare is also really good. Compared side by side with a glossy screen laptop you really appreciate how well it works: no annoying reflections of windows etc. Viewing angle is really wide with little distortion.

Keyboard: It’s growing on me, but i think it could be better. I like the back light. Problem with the keyboard being a full keyboard is it means centre of the keyboard is off centre, which means i tend to have the laptop shifted out to my right. Given how much space there is I think Dell could have done better with keyboard options, such as offer a comfort curve option.

Touchpad: It’s big. Also off to the left a bit so as to almost be centre of the alpha part of the keyboard, but not quite. Centre of the touchpad lines up with key 7 or the space between Y and U. Gestures work pretty well: I particularly like the cover the touchpad to hide all open windows gesture.

RAM is 8 GB which is good enough for me (generally). Unfortunately only 2 slots. Apparently if you order the 3D screen you get 4 slots. That kind-of sucks, but i doubt it will bother me in the next couple of years.

Processor: i7 2630QM. Seems good and fast. Yet to really multi thread stress test it though.

Graphics: most of the time I’m using the Intel one (or so it seems). I’m not a gamer

USB: Awesome !! My external HD which is USB 3, is fast I also really like the charge port for charging my phone.

Battery: I got the 9 cell. i like how it sticks out of the bottom to tilt the notebook when sitting at a table. Battery life seems good. I use the machine for hours and still have half battery left.

Hard drives: There’s two bays and came with two 750 GB @ 7200 RPM. I found them relatively noisy and kind-of slow, so I put in one of my old solid state drives and also added a new OCZ Vertex 3. The Vertex 3 uses the 6 Gbs bus and it rocks !! Lightning fast, and absolutely no noise. There was a problem with the notebook hanging for anywhere up to 30 seconds or so. Looking in the windows log I identified the problem as being the Intel SATA drivers so I uninstalled them, and since then it has been rock solid (and very fast )

Sadly the Dell web site doesn’t really give much choice on this: they don’t tell you what kind of Solid State Drive they offer as far as performance goes, and they only offer pricey options of 256 GB or more. Given this notebook has two internal drive bays, having two @120 GB would seem the best bang for your buck at present. My OCZ HD is getting the maximum windows experience index score of 7.9:

Overall opinion: I like it .

Private Class Variables

bill — Sat, 02 Jul 2011 02:06:32 GMT

Cory Smith has a set of posts on some of the differences between VB6 and VB10.There’s one which I think needs a bit further clarification: Private Class Variables.

In VB7 and later, you can access private class variables from another instance of the class. So let’s say you had a class A with a private field _z, and instances a1 and a2.In this case a2 can read and modify a1._z.

An example of this might be if you have a class that has a private field to track changes; you might expose whether or not the class has changes as a ReadOnly property, but you’d want the backing field as Private so as it can’t be modified from outside the class, e.g:

Class Customer
   Private _hasChanges As Boolean
   Private _FirstName As String
 
   Public ReadOnly Property HasChanges As Boolean
      Get
         Return _hasChanges
      End Get
   End Property
 
 
    Public Property FirstName As String
      Get
         Return _FirstName
      End Get
      Set(value As String)
         If value <> _FirstName Then
            'TODO: Raise PropertyChanging notification
            _hasChanges = True
            _FirstName = value
            'TODO: Raise PropertyChanged notification
         End If
      End Set
   End Property
 
 
   Public Shared Function Clone(source As Customer) As Customer
      Dim cust As New Customer
      cust._FirstName = source._FirstName
      cust._hasChanges = source._hasChanges
      Return cust
   End Function
 
End Class

Note the Clone function, where the code has access to the private variable of a second instance. This makes the language a lot more powerful and flexible. Benefits include:

access to fields in Shared methods
provide deep clone and equality methods
Assists with Factory methods

there’s no real downside to this, as only code written in the same class as the field is defined in can modify the field. Code in derived classes would need the field to be declared as Protected, not Private, so Private remains Private to the code you write.

In terms of VB6 to VB7+, this is a non breaking change. It was an addition to the language that makes a lot of sense as the language moved to be more object orientated. So to claim that this is somehow significant impeding change is really just nonsense: zero impact on existing code, and provides greater flexibility when writing new code.

Windows Phone 7 : 6 months later

bill — Fri, 17 Jun 2011 07:29:55 GMT

I’ve had my HTC Mozart for about 6 months now, so I thought I’d give an update of my thoughts about it and Windows Phone 7.

The first set of WP7 updates were really slow to roll-out here in Australia to Telstra: Telstra was the 2nd last mobile operator to deliver the update in the world. Given that the Spain’s Telefonica apparently still is only scheduling updates, for now Telstra has the honour of actually being last to deliver the updates (to date). Despite those middle party delays, the 7.1 update was awesome ! Performance improvements are huge with some applications, and most importantly we got cut and paste back.

For more feature improvements we still have to wait until later this year when the “Mango” update will be released. Developers can play with the mango bits in Visual Studio and the phone emulator. So far Mango looks really cool and addresses many of my initial/early concerns about Windows Phone. Looking at my “xmas wish list” of 3 items, that list seems at least half way addressed :

Sensors: Yes, in Mango the platform exposes more of the phone’s sensors.
Content Providers: Again it seems like Microsoft has heard and is exposing ways for applications to work with the contacts list etc. At the same time they are also introducing “groups” for contacts which may in itself address many of the reasons I want/need to have the contacts list exposed. hopefully groups too will be exposed to programmatic access (with permissions). There still doesn’t appear to be any shared storage/data access on the phone.
Let me work with my PC : Sadly, I haven’t heard any news on this front; everything I have heard has been focused on a better “cloud” experience. It’s a pity as there are times when there is no internet access, and it would be handy to transfer files & contacts to the phone. Zune really needs to open up to include basic file management; and ideally outlook synchronisation. This is a MUST have given the lack of Zune music in Australia.

So that was my old list. Today some of the things I’d like to see Mango address are (in no particular order):

Capacitive button settings:
Way too often I find I accidentally hit the home, search or back buttons, especially when passing the phone to other people to show them something on the phone. It’s be nice if there was a settings page where you could modify the sensitivity of these buttons. Ideally I’d like to be able to set them to only work on double click/touch. It’s a little thing, but it would drastically change the way I feel about the phone’s physical form factor. It’d make it feel like the phone was truly mine, rather than the phone constantly dictating to me not to touch it there, and not to hold it that way
iCal and/or vCal support:
A month or two ago I got an email from some of the crew at Microsoft to attend a Live Meeting about Windows Phone. “Cool !!” I thought. The problem was I read that email on my phone, and couldn’t save the attached calendar appointment ! Oh the irony !!!!
Must be able to send and receive calendar appointments via email.
vCard support:
There needs to be a way to simply share contact details with people. VCard support in email and especially SMS is a must have.
Better document handling:
The ability to:
+ simply save a document from an email,
+ transfer files directly to/from a PC
+ programmatically generate and save documents (e.g. invoices/quotes etc.) in shared locations. Ditto for data access.
Zune music:
If Microsoft wants people in Australia to take it seriously about its commitment to Windows Phone it needs to invest in actually having Zune Music available here (ditto for other countries). ITunes has no problem with providing music in Australia. Microsoft: either make Zune Music in Australia happen or open the phone up to 3rd party music sites and file organisation (iTunes on the Windows Phone !!) or both. It’s really crappy to lock the phone down and then not provide the service. Even worse when you open Zune and it constantly reminds you there is no service here.

Despite the list of “wants” or “shortcomings”, Windows Phone really is a nice device. The UI is generally enjoyable (as long as you don’t accidentally hit those capacitive buttons <g>). Mango looks even better.

Looking forward to hearing more details. Spaces to watch: