Granville Barnett : C++

Shared Source CLI Google group launched

gbarnett — Tue, 06 Jan 2009 04:53:03 GMT

I’ve just created a Google group based on the SSCLI which you can view and join by going here - http://groups.google.com/group/microsoft-shared-source-cli

It supersedes now defunct SSCLI newsgroups from the Microsoft and Yahoo servers which have had all but no activity in the last 2 or so years. If you have any interest whatsoever in the SSCLI then I encourage you to join.

http://groups.google.com/group/microsoft-shared-source-cli

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

Shared Source CLI (aka Rotor) on Vista

gbarnett — Mon, 08 Dec 2008 05:00:15 GMT

I thought I would share my experiences with Rotor on Vista (x86 and x64). First off Rotor is an open source version of a big chunk of what's in the full commercial .NET that you use on your machine today BUT certain things in Rotor are no where near the quality of that in the commercial .NET – keep that in mind.

I hacked around with Rotor on several setups not including the supported setup (XP with SP2 and VC++ 8.0). My mileage with each is briefly summarized below.

Vista x64 with VC++ 9.0

I tried to get Rotor working with Vista x64 and VC++ 9.0 but was unsuccessful. Couldn’t even get it to build. This was as I expected though.

Vista x86 with VC++ 9.0

Made the same changes I did with the x64 version pretty much and got it to build. After the initial hope of it all building and the tests that Rotor comes with all passing I was somewhat annoyed that some programs including the C# compiler were not behaving correctly e.g., the C# compiler would give random parser errors for programs. I’m sure that other components were affected as well but seens as though I needed the C# compiler to work this was pretty much the final straw for me.

Vista x86 with VC++ 8.0

Builds without any hacking required. Every now and then though a buffer overrun would occur during the build, particularly when building some of the BCL C# stuff. Haven’t had this error again since I rebuilt my machine but the obvious fix would be to just make the buffer that is overran larger. This occurred during a call to MakeMacroString and it seems as though someone else has come across this as well.

My personal view is that the SSCLI project is doomed to spend the rest of its time only officially supporting that which it did when it was first released. If anyone knows any different then let me know. I couldn’t find any information on the web hinting that it would be updated if only to support Vista.

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

Results: Using a dark theme in VS for a week

gbarnett — Fri, 26 Sep 2008 17:20:35 GMT

As I mentioned several days ago I’ve been seeing if a dark theme in VS would help my eyes a little. The short of it is – no, no it didn’t. The major sore point is that if you use a dark theme in VS then you find yourself constantly swapping between dark (VS) and light (web content, content in general). The latter of course doesn’t sound like its particularly good for you and I’d definitely concur with that.

I actually found that my background was slightly off-white in my VS settings and since changing it to pure white around 3 or so days ago I’ve found that my eye strain has just disappeared. Funny thing is I can never remember changing the background colour.

I’ve no doubt that the colour schemes used in VS are very subjective so I won’t announce that light themes are the best, but it seems to work well for me.

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

Experiment: Using a dark theme in VS for a week

gbarnett — Sat, 20 Sep 2008 14:03:28 GMT

I've been highly critical of using dark themes in Visual Studio particularly because the UI of VS is light in its very nature. The combination of the two proving to be an interesting proposition when using VS for large durations of time.

I digress. Recently I have suffered a few eye issues and I'm pretty much willing to try and use a dark theme now for more than an hour and then dismissing it in the hope that it may help me out a little. I have tried a few other minor solutions prior to this experiment, the most of which revolve around making the background colour of VS a slightly off-white colour. If anything that approach made things worse.

I'll be using the theme for all my coding which spans from C++ to C# and see how it goes. The theme I will use is Vibrant Ink by Rob Conery.

Hopefully this may help my eyes a little? ...

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

DSA book on 'This Week on C9'

gbarnett — Sat, 30 Aug 2008 05:42:18 GMT

First off thank you to all who have downloaded the first draft of Data Structures and Algorithms: Annotated Reference with Examples. At the time of writing this post there have been more than 3200 downloads within around 3 days of it being put up on DotNetSlackers which is great!

Thanks to all those who have helped spread the word by linking to the posts I made and to the actual project page. I'd also like to thank Dan Fernandez who gave the book a mention on This Week on C9 (a weekly review program on the popular Channel9 site). You can view the episode here.

If you haven't checked it out already then go give the first draft of Data Structures and Algorithms: Annotated Reference with Examples a look.

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

Data Structures and Algorithms book (free) first preview available!

gbarnett — Wed, 27 Aug 2008 07:55:27 GMT

This is a little project that myself and Luca have been working on in our spare (spare) time in the last month or so. The book is no where near complete but we wanted to get it out there now and progress with it in view of the public eye rather than just sit on it and wait months until it was a lot more thorough.

As this is just a preview don't expect it to be all finely polished, we know what we are lacking in terms of explanations. No chapter in the preview is the final version of that respective chapter. It's also worth mentioning that this is not the final list of chapters.

Our intended target audience are those who know how to use their respective language of choice, other than that you should be OK to follow the book. We have intentionally tried to keep the book compact and to the point.

The book is language independent. We use a form of pseudocode for all algorithms as such these algorithms can be easily ported to most imperative languages like C++, C#, and Java.

Why is it free? Because we want it to be. At this present moment in time all suggestions etc have come from a small number of reviewers, for which we are incredibly grateful. But we felt the time was right to throw it out to the larger audience so we can get more feedback on what we have thus far.

The book is hosted for us on DotNetSlackers, you can view the page dedicated to the book here.

Go check out the first preview of Data Structures and Algorithms: Annotated Reference with Examples now!!!

EDIT: if you could help spread the word we would be incredibly grateful ;-)

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

My Visual Studio vNext wish list

gbarnett — Mon, 04 Aug 2008 04:20:57 GMT

My wish list for Visual Studio vNext isn't that long. The things I would like to see in Visual Studio vNext (I'm not that hopeful) are the following:

A filtering intellisense members list box
Some intelligent suggestions
More refactoring options

Unfortunately I am going to do the unmentionable and compare VS to Eclipse.

A filtering intellisense members list box

As the number of classes in the BCL grows, and with newer technologies arriving all the time I don't think there has ever been a better time to implement this feature. Eclipse does a good job of it and is incredibly handy:

There are some products out there that you can actually install to do this, they include:

Resharper (Using the native Resharper intellisense stuff)
Visual Assist X

Some intelligent suggestions

This is a lame example, but its a pretty common one. Today in VS suggestions for the most part are non-existent. I know that in VS 2008 SP1 background compilation for C# is here (warnings, errors) but it still doesn't give you what Eclipse does with respect to suggestions.

I know that there are probably a tonne of people reading this now shouting "You can remove unused using directives now!" True, but its never emphasised to you by the IDE. Again I find myself uttering the word Resharper for this stuff, but should we really have to buy into a 3rd party product for something like this? We could also extend this to something like variables that are never referenced.

More refactoring options

Eclipse offers an absolute tonne of refactoring options which are integrated really great into the IDE.

While I don't have any major gripes about what is offered in VS 2008 with respect to refactoring, I do think it lacks somewhat. Some of the refactoring options in VS could do with a more streamlined approach as well. A great example of this is the rename option. Invoking rename will open a big goofy dialogue box which would be appropriate if you were renaming a field or something - in place renaming would be much more appropriate for local renaming's though.

Final thoughts

I really like VS and all that it gives you but I can't help feel that we are losing out on some of this stuff. I'm sure that the VS team are incredibly busy building new designers, but if anyone on the VS team happen's to stumble across this post then please give these features consideration.

Purposely I have not mentioned C++, they have enough trouble getting intellisense working as it is. If you are interested in this though then check out Intellisense History, Part 1 and Intellisense, Part 2 (The Future). Both blog posts are from the VC++ blog. Visual Assist X is a nice tool though if you want a more rounded experience in VC++ land right now.

Originally posted at http://msmvps.com/blogs/gbarnett. Please post all comments there. Thanks, Granville.

C++ portability guide

gbarnett — Sun, 20 Apr 2008 18:16:17 GMT

I was looking for this document a while ago and couldn't seem to find it but I stumbled across it moments ago almost by chance. It's the the Mozilla guidance for C++ portability - give it a read here if you are interested in that stuff it is full of subtle pointers that make sense (and some that are not that obvious).

If you have a spare few minutes give it a read, it is fairly comprehensive but at the same time I would take some of it with a pinch of salt.

Something I let pass me by - VC++ TR1 released

gbarnett — Fri, 11 Apr 2008 22:30:33 GMT

If you have been using the Boost libraries then you will probably not see anything major that's not already in the Boost TR1 library BUT officially VC++ now has a TR1 implementation which is always a good thing.

Information about TR1 (and the MFC update - which is itself is a major improvement!), and the download link.

Also of note Herb Sutter has moved blogs again! This guy changes blog every year it seems but he's worth tracking!

Herb stop it!

Enjoy this, its a nice update to VC++.

Visual C++ in Visual Studio 10 will use SQL Server Compact instead of ncb's

gbarnett — Sat, 01 Mar 2008 17:32:13 GMT

For many this will no doubt induce a sigh of relief, we've all been there in moderately sized projects and then happened to see that the ncb file size seems to have grown exponentially - I don't think I've ever met someone who hasn't deleted the ncb file numerous times to try and coerce the IDE to give some intellisense support.

I'm sure they will have to jump through some hoops, but it makes perfect sense to go with something that the database guys have put an immense amount of work in, as a result I'm sure we will see vastly reduced file sizes and superior response times in terms of intellisense, hopefully the implementation will be "good" enough to implement other features like refactoring support, probably not as comprehensive as C# or other managed languages but anything is an improvement.

This is great news though, Jim Springfield the VC++ architect has more on this here, if you want to skip to the more interesting stuff then read the last paragraph which talks about scaling the source code information (SQL Server instance) and some potential features.

Interesting stuff.

A few slide decks that may be of interest (C++ TR1)

gbarnett — Mon, 25 Feb 2008 14:17:30 GMT

I missed this but last Friday the VC blog guys put up some slide decks on the "new" stuff in TR1, I enclose new in quotations because if you've used Boost before then its not new, rather its just the native support for those features - which is a good thing.

http://blogs.msdn.com/vcblog/archive/2008/02/22/tr1-slide-decks.aspx

These are great additions to the language, but if you don't want to use the Beta for fear of breaking something then just download the Boost source and go from there.

Here is the link for the VC++ 2008 Feature Pack Beta (TR1 and MFC).

VS 2008 C++ refactoring...

gbarnett — Sun, 17 Feb 2008 20:43:27 GMT

...well there still is none.

I seem to be pressing commands in VS 2008 Win32 projects which would invoke pretty basic refactoring tools in C# and VB.NET but yet C++ has nothing! Now I know the VC guys are working on a parser that will help with the intellisense in VS C++ projects (yep lonnnng time off yet) - if like me you don't even waste time with intellisense in C++ projects as its just a disappointment when you are there hitting ctrl + space waiting for something (yep, ctrl + space because intellisense never comes up on its own in C++ projects does it?!) that never quite arrives, the result is that you just wasted 5 seconds - you could of typed it by then.

For about 18 months I used to have C# intellisense turned off by default, yes I know you are thinking why and that I'm an absolute plonker, but honestly I just enjoyed having the freedom of typing whatever the heck I wanted and then sorting it out seconds later rather than battling with intellisense trying to tell me what I meant to do was this. Ctrl + space is your friend, needless to say I do have it turned back on in C# now.

Anyway I digress, what I would really, really love to see is primitive help with mundane boring tasks like extracting methods, renaming with a snazzy live preview of everything that I am affecting, who knows maybe even reorder some parameters?

I know VS 2008 launch parties haven't kicked off yet, but I have to say roll on VS vNext.

Cross-Platform Development in C++ (Book)

gbarnett — Fri, 25 Jan 2008 20:26:52 GMT

I have been sent a few books from Addison-Wesley and I think this one is the best of them all, but generally all have been excellent. The book covers in great detail the various aspects to consider when creating portable C++ code, from GUI's to the actual process used to create the software.

One of the interesting things about the book is a decent overview of XUL which is a cross platform GUI toolkit that uses XML (like WPF) to describe the visual components - this technology can be used on various OS's. I found this particularly interesting as I had not really read much about XUL for a few years since I first came across it and it was really nice to see that it has developed into a fairly robust framework.

The book is written by Syd Logan who worked on the Netscape team, the book is riddled with short stories of times he had personally and his team had encountered cross-platform issues and the solutions that they used, as well as possible alternatives.

This book was an awesome read, and one that provided great insight into the particular area - if you are interested in this then Syd's book will give you a general overview of everything to consider as well as a few technologies to use (or that he in his experience found incredibly useful) from Bugzilla, to make files, management, NSPR, Installers etc.

Highly recommended.

Copy-in, Copy-out and reference semantics

gbarnett — Wed, 14 Nov 2007 12:21:10 GMT

I see this question pop-up every now and then on various forums and generally within conversations.

By default in languages like C# and C++ (and tonnes of others) copy-in semantics are used when dealing with the objects of formal method parameters.

Each can be viewed as read (copy-in), write (copy-out) and read-write (reference).

Although I have not checked my assumption is that modern, sophisticated compilers will in fact embrace the most efficient semantics in any particular scenario, e.g. say I have a method that takes a single argument by default I am using copy-in semantics and in the method I am not writing to that parameter only reading thus the compiler under the hood could just pass by reference which is more optimal.

Copy-in can be expensive if the formal parameter's are large in nature, e.g. large data structures etc, copy-out semantics are also expensive as they copy-in and then "push" the data back out again writing, references do neither but are more error prone.

using System;

namespace CopySemantics
{
    class Program
    {
        static void Main()
        {
            Person p = new Person("Granville", "Barnett");
            CopyIn(p);
            Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
            CopyOut(out p);
            Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
            Reference(ref p);
            Console.WriteLine("{0} {1}", p.FirstName, p.LastName);
        }

        public static void CopyIn(Person person)
        {
            /* copy-in semantics, this method uses a local copy of 
             * the formal parameter if value type otherwise person 
             * pointer value */
            person.FirstName = "Alan";
            person.LastName = "Shearer";
        }

        public static void CopyOut(out Person person)
        {
            /* Same as copy-in semantics but value is written to 
             * formal parameter object/value type. */
            person = new Person("John", "Edwards");
        }

        public static void Reference(ref Person person)
        {
            /* no copy-in or copy-out semantics used here, we are 
             * always dealing with the object passed in the formal 
             * parameter */
            person.FirstName = "Bill";
            person.LastName = "Gates";
        }

    }

    class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public Person(string firstName, string lastName)
        {
            FirstName = firstName;
            LastName = lastName;
        }

    }
}

Hopefully that clears some stuff up - but I would expect the C# or C++ compiler being used to go ahead and do some checks and then use the most efficient semantics anyway.

Apologies if the example is poor, I just did this off the top of my head this minute :-(

Note: copy out semantics are not in C++, you must use reference (read-write) semantics (&).

Note: these semantics don't just apply to modern C++ compilers or the C# compiler, rather this is what most commercial grade compilers will do in some optimisation phase.

C++0x looks like it's going to be awesome!

gbarnett — Fri, 02 Nov 2007 18:58:14 GMT

I'm loving what I'm reading on Herb Sutter's blog after his trip to the ISO C++ standards meeting in October.

Among the things Herb raises, my favorites include:

nullptr - finally a nice literal from C++/CLI is approved and we can all stop using 0 which although is not that confusing is also not that clear, and also the horrible macro NULL - I don't know why, but I hate using NULL...I think it's just because it's in caps and requires a little more effort when typing.
threading library - about time, enough said.

I am absolutely loving what I'm reading about C++0x!