Geekswithblogs.net

Accessing QuickBooks Data for Use in LightSwitch

GGBlogger — Sat, 04 Feb 2012 23:05:38 GMT

Intuit Partner Platform and Data Access

I’m going to make some assumptions that will cover a lot of folks developing applications to work with QuickBooks.

1. You are running a copy of QuickBooks on your development machine.

2. You are running Visual Studio 2010 as your development environment of choice.

3. You have some flavor of Microsoft LightSwitch installed.

4. You want to access QuickBooks data on your machine to USE LightSwitch.

Well now you have an option. Head on over to http://www.rssbus.com and pick up a copy of their QuickBooks Data Provider for ADO.NET. A one developer license with royalty-free distribution will cost you $599 at the present time and in the next few minutes I’m going to help you get started using this package.

Although this software comes with a number of samples getting started was not all that intuitive for me. After a number of false starts I did a GoToMeeting with a gentleman named Casey and he showed me how to get started. The problem is that this package can serve in a number of capacities accessing QuickBooks data whether the data is local or remote so to get you started I am going to show you how to set things up locally to allow you to run QuickBooks Data Provider to use the samples supplied and to use LightSwitch to access the data. If you have a need for other setups you will need to consult their help files.

Let’s start with the QuickBooks Remote Connector provided as part of the package. You won’t find it in your menu choices in the start menu but if you cruise on down to c:\program files (x86)\RSSBus\RSSBus QuickBooks Data Provider\RemoteConnector you will find RemoteConnector.exe. I chose to pin it to my taskbar but you could also make it a desktop icon. This connector is a mini http listener and it’s easy to get multiple instances running and we don’t want that. I’ll have more on that in a bit.

When you start it you will get this:

The most important thing to note is that we’re using port 2080. Now click the Users tab:

Fill in a user name and password. This is strictly for the use of the data connector and has no other purpose. To find the company file you want to use click the browse button and you will get:

(Word of warning – clicking the Red X button at the upper right of the screen DOES NOT close the connector. To CLOSE the connector use the Exit button on the menu strip!!!!!)

Choose the file you want to access and click the start button. This starts the connector in listening mode. EVERY time you run this it will generate a new connection. You can see these in the hidden files section.

You only want ONE of these running at any given time. With one connector started and running you’re ready to move on to using the connection to access QB data.

So let’s access some data

My suggestion is to start the sample account application provided by RSS. The demos are installed as links when you install the Data Connector but you can also find them in Program Files (x86) under RSSBus. The form for the account application looks like this.

Fill in the details using http://localhost:2080 and your user name and password that you used in the connector dialog:

Before you go further open QuickBooks with the data you selected to use with the connector. With QuickBooks running click the Refresh button. QuickBooks should present you with the following screen:

You have a number of options here but I chose Yes, always and allowed it o access personal data for my testing purposes. Click Continue… to get:

First warning – select Yes unless you want to change it then a final warning:

Click done and you can close QuickBooks if you like. Now click the refresh button on the account application and you should get this:

You’re now accessing QuickBooks data from an application external to QuickBooks. I know it seems like a lot of work but if you follow the instructions above things should go smoothly. I ended up with about a dozen Remote Connectors running on some of my first attempts. It took Casey and a GoToMeeting session to get me sorted out. Now I love it LOL. I’ll do more with LightSwitch in another blog.

Bud Aaron – the Geriatric Geek

http://www.dotnetchecks.com

Dice.com IT jobs search results Feb. 2012

TomStickel — Sat, 04 Feb 2012 23:03:10 GMT

Nationwide search on dice.com

Feb. 4, 2012

C# - 8,518

ASP.NET 4,957

.NET MVC 1,101

Biztalk 409

Microsoft Dynamics CRM 461

Sharepoint 4,022

SQL Server 14,390

Java 16,854

groovy 292

Oracle 18,118

Monster.com IT job search results from March 2010

TomStickel — Sat, 04 Feb 2012 22:53:25 GMT

Monster.com

Nationwide search

Job Title: Empty ; Skills/keyword: mvc location: empty

Results: 523 jobs nationwide (mostly java )

Change to Skills/keyword ASP.NET MVC

Results: 80 jobs nationwide

.net mvc = 129

groovy = 66 jobs

grails = 44 jobs

C# 3,481

VB.NET 855

.NET >5,000

ASP.NET 2,245

Java > 5,000

Delphi = 93

VB = 2,559

Visual Basic 2,604

ORM - 150

Hibernate - 851

NHibernate - 53

Linq = 162

Entity Framework = 97

fxcop = 5 jobs

Oracle = >5,000

SQL Server = 4,148

mysql = 1,431

db2 = 699

Nunit = 120

JUnit = 422

Selenium = 142

Coldfusion = 304

Perl = 2,371

PHP = 1,540

Python = 1,029

Ruby on Rails = 221

Automation Engineer = 297

Spring = 1,710

Subverion = 559

VSS = 83

Visual Source Safe = 120

CVS = 824

StarTeam = 14

vmware = 1,326

Virtualbox = 3

C++ = 4,266

Coming Back in action!!!

Srijith Sarman — Sat, 04 Feb 2012 22:08:09 GMT

It's been exactly over three years and two months since I last logged in to this blog. The last post which I made on Dec 2008, was itself after a one year gap :). Well, now let me try if I can continue this activity. Lot of learning, lot of new cool stuffs. Technology itself has been changed quite dramatically over this period with the addition of new cool stuffs and I believe my English as well improved a little bit :). Microsoft developers finally started realizing the drawbacks of ASP.NET architecture and started drifting towards more web world friendly architecture like ASP.NET MVC. Thanks to the huge fan base of Ruby On Rails.

In this context to start off this new beginning I will quote some interesting remark I found from the Mr.Asp.Net Scott Guthrie. Who is better than him to quote when I want to discuss about MVC?

"Some guidance I occasionally give people on my team when working and communicating with others:

1.You will rarely win a debate with someone by telling them that they are stupid - no matter how well intention ed or eloquent your explanation of their IQ problems might be.

2.There will always be someone somewhere in the world who is smarter than you - don’t always assume that they aren’t in the room with you.

3. People you interact with too often forget the praise you give them, and too often remember a past insult - so be judicious in handing them out as they come back to haunt you later.

4. People can and do change their minds - be open to being persuaded in a debate, and neither gloat nor hold it against someone else if they also change their minds. "

Great points!!! Very true as well.

LINQ Query and Lambda Expressions

TomStickel — Sat, 04 Feb 2012 21:11:22 GMT

Lambda expressions are a powerful tool to writing quick, concise code. They can be used in numerous situations, most notably in conjuction with LINQ statements.

A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types.

All lambda expressions use the lambda operator =>, which is read as “goes to”. The left side of the lambda operator specifies the input parameters (if any) and the right side holds the expression or statement block. The lambda expression x => y * z is read “x goes to y times z.”

Here’s how a typical LINQ query looks like without using lambda expressions:

var query = from m in db.PersonalMessages

where m.ConversationID_FK == ConversationID

select m;

Okay, not bad. It looks like a SQL query in reverse (i.e. you start off with “from” and end with “select”). This is so that intellisense can help you out—if you started with select, it would have on idea where you were going with the query.
we are selecting PersonalMessages where the ConversationID is equal to some value passed into the method. The query itself is kinda verbose, and I like to keep my code short and sweet, so how do I re-write this using lambda expressions? Here is the code, and then we’ll break it down:

var query = db.PersonalMessages
.Where(m => m.ConversationID_FK == ConversationID);

We got rid of “select’”, “from” and “in”, etc. Cleaned it up quite a bit. What all is happening though? Basically it’s written out like:

My Query = Get Personal Messages from my data context Where the ConversationID is equal to this #.

In other words, it reads exactly like it does in the first written out query, but it’s done faster. The where statement is like a mini-method. You’re defining some variable M (you can use any letter, I always use m for the sake of convention in my code) and then in this case you’re giving m some condition to work with.
You’re basically saying, define m real quick (m=>) as a stand-in for PersonalMessage. Then only return PersonalMessages where m’s ConversationID is equal to some value.

This is why I shouldn’t blog before a cup of coffee….

George Clingerman — Sat, 04 Feb 2012 16:19:11 GMT

Wake up in the morning feeling all C Sharpy
Grab my laptop by my bed, I'm going to code this pretty
Brush my teeth and my hair much later I'm sure
Cause when I'm coding an idea I ain't looking to score

I'm talking curly braces have to close, close
Writing comments all in prose, prose.
Errors blowing up my codes, codes

Music popping, coding my favorite ideas
Pulling up, reading the tweets
Starting to get a little bit Lispy

No slop, make it top
Coding, blow that keyboard up
Today I'm going write
Till I see no sunlight
Fric, frack, errors back
But the coding just won’t stop no

Coad-oh oh oh
Coad-oh oh oh

Patches issued for PCAnywhere

TATWORTH — Sat, 04 Feb 2012 15:30:26 GMT

Patches have been issued for PC Anywhere. Please see:

Former Apple iPhone engineer Bob Borchers

Kit Ong — Sat, 04 Feb 2012 10:14:25 GMT

Bob Borchers revealed that the reason a lot of iPhone adverts show the time as 9:42 am on the iPhone was because the iPhone was originally launched at that time.

For one of the commercial for the original iPhone, Borchers said the phone number used to demo the Google Map function was genuine and is the actual number number of the Pacific Catch Restaurant in San Franscisco and the last time he was there they still had the iPhone special, which is calamari.

http://www.macnn.com/articles/12/02/02/talk.to.students.emphasizes.innovation/

Organization & Architecture UNISA Studies – Chap 2

MarkPearl — Sat, 04 Feb 2012 09:59:47 GMT

Designing for Performance

The basic building blocks for todays computers are virtually the same as those of the early IAS computers. The focus has been on optimizing and increasing speeds while keeping the same architecture.

Processors

Increasing speed with processors uses several techniques including…

Branch prediction – a processor looks ahead in the instruction code fetched from memory and predicts which branches or groups of instructions are likely to be processed next.
Data flow analysis – the processor analyses which instructions are dependent on each others results or data to create an optimized schedule of instructions preventing unnecessary delay
Speculative execution – Using branch prediction and data flow analysis some processors speculatively execute instructions ahead of their actual appearance in the program execution saving the results in a temporary location

Performance Balance

While processor power has increased over the years, other critical components have not kept up. The result is a need to look for ways of balancing the performance. One of the main bottlenecks has been the interface between processor and main memory.

There are a number of ways that a system architect can address this problem including the following…

Increase the number of bits that are retrieved at one time by making DRAMs wider rather than deeper and using wide bus data paths
Change the DRAM interface to make it more efficient by including a cache or other buffering scheme on the DRAM chip
Reduce the frequency of memory access by incorporating increasingly complex and efficient cache structures between the processor and main memory including the incorporation of one or more caches on the processor as well as on an off chip cache close to the processor chip
Increase the interconnect bandwidth between processors and memory by using higher speed buses and by using a hierarchy of buses to buffer and structure data flow.

Another are of design focus is the handling of I/O devices. The main challenge is getting the data from these devices moved between processor and peripheral. Strategies include buffering and cache techniques. The use of multiple processor configurations can aid in satisfying I/O demands as well.

There are generally two constantly evolving factors

The rate at which performance is changing in the various technology areas differs greatly from one type of element to another
New applications and new peripheral devices constantly change the nature of the demand on the system in terms of typical instruction profile and the data access patterns

Improvements in Chip Organization and Architecture

There are 3 approaches to achieving increased processor speed…

Increase the hardware speed of the processor (i.e. shrinking the size of the logic gates on the processor chip which would increase the individual operations executed on the chip)
Increase the size and speed of caches that are interposed between the processor and main memory.
Make changes to the processor organization and architecture that increase the effective speed od instruction execution (normally via parallelism)

As clock speeds and logic density increase, a number of obstacles become more significant including…

Power – the power density increases with an increase in logic density and clock speed. One challenge of this is the difficulty of dissipating the heat generated on high-density, high-speed chips
RC delay – The speed at which electrons can flow on a chip between transistors is limited by the resistance and capacitance of the metal wires connecting them. delay increases as the RC product increases. As components on the chip decrease in size, the wires are closer together, increasing capacitance
Memory latency – Memory speeds lag processor speeds as previously discussed

With these challenges becoming harder to reduce, designers of chips are now resorting to placing multiple processors on the same chip, with a large shared cache. Multicore processors provide the potential to increase performance without increasing the clock rate. Thus the current strategy is to rather use two simpler processors instead of one more complicated processor.

The Evolutions of the Intel x86 Architecture

There are two main architectures that we will examine – Intel x86 and ARM processors

CISC Design - The Intel x86 is an excellent example of CISC design (Complex Instruction Set Computers).
RISK Design - The ARM architecture is used in a wide variety of devices and embedded systems and is a good example of RISC design (Reduced instruction set).

Some of the main differences between the Pentium, Pentium Pro, Pentium II, Pentium III, Pentium 4, the Core (Duo) and the Core 2

Pentium – introduced the use of superscalar techniques, which allow multiple instructions to execute in parallel
Pentium Pro – Made aggressive use of register renaming, branch prediction, data flow analysis and speculative execution
Pentium II – Used Intel MMX technology which is designed to specifically process video, audio, and graphics data efficiently
Pentium III – Incorporates additional floating-point instructions to support 3D graphics software
Pentium 4 – Includes additional floating point and other enhancements for multimedia
Core – First microprocessor with a dual core, i.e. two processors on a single chip
Core 2 – Extends the architecture to 64 bits

Invitation to the IASA SE Florida Chapter Meeting on 02/21/2012

Rainer Habermann — Sat, 04 Feb 2012 03:28:26 GMT

IASA SE Florida Chapter

Software Design Patterns
Nina Grantcharova
Software Architect at LL Global
02/21/2012 6:00PM Meet 6:30PM Presentation

Posted:
Rainer Habermann
President IASA SE Florida Chapter

South Florida Code Camp 02/18/2012 at Nova University

Rainer Habermann — Sat, 04 Feb 2012 03:16:27 GMT

South Florida Code Camp on 02/18/2012 - a free event: 66 Speakers - 14 Tracks - 81 Sessions

Rainer Habermann
SFCC Speaker Coordinator

Migrating Custom Lists with Attachments from OLSB to Office 365

Michael Stephenson — Fri, 03 Feb 2012 23:05:20 GMT

Before I get into this I am not an Office Live Small Business or Office 365 expert but I have used Office Live Small Business for number of years as a light weight way of managing some parts of my business. I now need to migrate to Office 365 and one of the areas which concerned me was around custom lists which had attachments. I had a number of these with lots of rows and I had been waiting for some information on how these would be migrated and hoped they would just be migrated for me automatically.

When the migration guidance came out this was unfortunately not the case so I thought this post may help some others who have the same task to perform over the coming months before the final closure of OLSB.

Step 1: Replicate the list structure

In your Office Live Small Business account open up the custom list and go to its settings so you can see the structure of the list.

In your Office 365 account create the new custom list to replicate the structure from Office Live Small Business.

A couple of recommendations here:

You may want to consider leaving the constraints on columns such as choices etc for later and initially create the columns with simple types then fix them later
Ensure the columns are in the same order to make things simpler

Step 2: Open Your existing list in Microsoft Access

In your Office Live Small Business custom list use the Actions menu and select Open with Access.

This will open the list in Microsoft Access so you will obviously need it installed.

When the list opens in access choose the option to export a copy of the data and an appropriate location to save it.

Step 3: Open your new list in Microsoft Access

In your Office 365 account open your list and select the Open with Access option highlighted below.

When the list opens choose to have data linked to the sharepoint site like in the below pic.

Step 4: Copy the core data

Unfortunately you cannot copy everything all in one go because the rows must be created before an item can be attached. From here the next thing to do is to select the column headers in the access instance from the Office Live Small Business list. Select all headers except the one for the attachments column. Like in the below picture.

Next go to the Access instance which is linked to the Sharepoint List in the Office 365 site. Paste the lines into this Access instance. The paste action will slowly insert the new rows into the Office 365 SharePoint List.

Step 5: Copy Attachments

You should now have two Microsoft Access databases with the same rows in. One a copy from Office Live Small Business and one with a linked table to the Office 365 SharePoint list. The rows will all be in the same order.

The next step is to copy the attachments.

In the Office Live Small Business Access instance select the column header for the attachments. The one with the paper clip symbol as its header. Then copy the entire column.

In the Office 365 Access instance select the attachments column header and paste the entire column.

This paste action will probably take a while if you have a lot of attachments.

Conclusion

As I mentioned at the start the biggest concern I had with the Office Live Small Business to Office 365 migration was around what to do with all of my custom lists and attachments. Unfortunately the self migration guide wasn't very useful for this bit because It just said to export your data but didn't cover importing it or anything about attachments.

As you can see this only took a short time to do so generally I am quite pleased that this is complete and I can now get on with enjoying the many new features of Office 365 and let my OLSB account disappear into the past.

Make sure computer names are 15 characters or less for MSMQ messages to get delivered

John Breakwell — Fri, 03 Feb 2012 22:01:11 GMT

Thanks to Seif Attar for highlighting this problem.

It seems MSMQ doesn’t like sending to computers with names longer than 15 characters (which some may remember is the NetBIOS limitation).

To try it out, I created a queue on a Windows XP machine with a computer name of VeryLongMSMQServer and sent off some test messages to

DIRECT=os:verylongmsmqserver\private$\txqueue

I requested acknowledgements so I could see any errors and wasn’t disappointed:

As soon as I renamed the machine to ShortMSMQServer, restarted and sent new messages to

DIRECT=os:shortmsmqserver\private$\txqueue

the problem disappeared:

The messages are delivered to the destination’s queue manager in both cases but are rejected when the machine name is too long.

My suspicion is that this is a NetBIOS limitation. When I initially changed the machines computer name to one that was too long, Windows XP complained “The NetBIOS name of the computer is limited to 15 bytes. The NetBIOS name will be shortened to “VERYLONGMSMQSER”.:

I did try enabling the IgnoreOSNameValidation registry value in case that would help but no luck.

Organizing Your Work With OneNote Page Templates

Tim Murphy — Fri, 03 Feb 2012 21:15:39 GMT

If you have seen the Windows Phone commercial where the father is in the grocery store with the shopping list in OneNote you have gotten you first taste of the flexibility that can be had with OneNote. I like most consultants have a lot of fires going and once and I am finding that the templates in OneNote are helping me to get a handle on the different projects and tasks I need to track.

I started using OneNote to do simply what its name suggests: take and organize notes. Lately though I am finding ways that it can help to centralize things that I had been using multiple applications to accomplish. Having them all in one place, as with most things makes it easier to not miss something.

You may find using the tasks feature of Outlook works well for you, but I found that I was in and out of my email so fast that I ignored the tasks. As simple To Do List template in OneNote seems to be the solution for me since I spend so much time documenting projects. As an alternative you can use the Prioritized To Do List shown below or the Project To Do List which gives you a list per project.

When starting a project at a new client Project Overview is a great way to organize your thought and make sure that you cover all the essentials. While I am just starting to use it this template is quickly proving its worth.

Of course if you don’t find a template that fits your needs you can create your own templates. Start with one of the standards and edit it. Then click Save Current Page As A Template. This is great especially for customizing templates like the project overview to suit you needs.

There are many other features to this tool for you to explore. Add to everything above that it is a write once, maintain anywhere product and I can easily access my notes from any browser or even my Windows Phone. Life is getting just a little better.

del.icio.us Tags: OneNote,ToDo,Task Management,Windows Phone,Office

Implementing Team Foundation Server 2010 In A Mixed Development Environment

Tim Murphy — Fri, 03 Feb 2012 18:58:05 GMT

Most of us spend our time in Visual Studio writing .NET code within a Visual Studio solution. Given this situation we find it very easy to integrate with Team Foundation Server for our source control and have a well known work pattern. But what happens when you want to use TFS as source control for non-Microsoft development?

The most important thing to remember is that source control should be as transparent as possible to the developer. If the particular language or product does not have an Integrated Development Environment then having plug-ins to maintain this transparency is not possible and your next concern is making the way the developers interact with TFS as simple as possible.

Let’s assume that you are facing the latter situation. The first thing to do is sit down with the team and find out what their normal process is for developing. You need to find out how the code that becomes their executables are organized. The key is striking a balance between logical separation and making extra work by creating too many projects. If they users are accustomed to managing their code in a single folder then you may want to maintain that same structure for your TFS projects.

Once you get past the structure issues you then need to address the subject of branching and labeling. I recently ran into a situation where the non-Microsoft development was customization of a packaged software. This presented additional considerations. They get a copy of the off the shelf code with each release from the vendor. There may be features that are actually removed from one release to the next. This made it easier to start a new project for each release than using labels or branching. The last thing they wanted was code files creeping back in if they got latest and only new files had been overwritten but the obsolete files were still there.

In the end it boils down to understanding the needs of your development teams and molding your usage models to those needs. Maintain as much transparency for your developers as possible by limiting the touch points for TFS and as often as possible allowing them to continue developing the way the always have.

del.icio.us Tags: Team Foundation Server 2010,Visual Studio

A nice feature of Style 4.7.7.0

TATWORTH — Fri, 03 Feb 2012 16:25:22 GMT

I have just installed the latest stylecop 4.7.7.0 and the latest nightly build of Resharper (build 42) and they work well. Stylecop now has a feature whereby you can override the maximum number of issues reported.

I used an an as-downloaded copy of PowerCollections and increased the limit to 100,000 issues and did a ReScan all with Stylecop. Here are the last 3 lines of the report:

------ StyleCop completed ------

========== Violation Count: 15080 ==========

What will you be if computers weren't in existence?

Vincent Maverick Durano — Fri, 03 Feb 2012 15:11:59 GMT

Yeah it's a tough question especially since most of us across the globe, both young and old heavily rely on computers and the internet . Today, life would be virtually impossible without it. When I was in elementary school I always dreamed of becoming an artist. I loved to paint and draw because I can express my thoughts and emotions through art. But things changed after I graduated in high school because my family couldn't afford to send me to university. I earned my BS degree because I got a scholarship from STI to study computer science. So now I work as a web developer. But to answer the question, if computers didn't exist then I would be a carpenter and a farmer then I would create a machine from wood that will compile codes made out of paper that will produce kernels of corn ~ just kidding on that part =D. Seriously I would definitely be an architect or an artist because being an artist is having the freedom to express your personality through art. The picture below is one of my drawing which I’ve drawn a long long time ago. Not pretty cool but it rocks! :D

How about you? What do you think will you be doing now if computers weren't in existence?

Technorati Tags: Computers,General

APress Deal of the Day - 3/Feb/2012 - Pro SharePoint Designer 2010

TATWORTH — Fri, 03 Feb 2012 11:49:36 GMT

Today's $10 Deal of the day from APress at http://www.apress.com/9781430236177 is Pro SharePoint Designer 2010

"SharePoint Designer 2010 is the key to customizing and improving the functionality and appearance of SharePoint sites, and Pro SharePoint Designer 2010 is your one-stop shop to getting the most from this powerful application."

Android Development with Eclipse

TomStickel — Fri, 03 Feb 2012 07:24:43 GMT

Install Eclipse

Then install the android plugin

http://developer.android.com/sdk/eclipse-adt.html#installing

Basic Hello World

http://developer.android.com/resources/tutorials/hello-world.html

KSoap2 for WCF

Structure and MVC3 and DI (Dependency Injection) Links to save

TomStickel — Fri, 03 Feb 2012 07:23:04 GMT

http://hellspawndev.blogspot.com/2011/10/structuremap-mvc3-generic-repository.html

http://forums.asp.net/t/1729740.aspx/1

http://www.thecodinghumanist.com/blog/archives/2011/1/20/structuremap-and-asp-net-mvc-3-getting-started

http://www.devtrends.co.uk/blog/how-not-to-do-dependency-injection-the-static-or-singleton-container

http://www.mikesdotnetting.com/Article/117/Dependency-Injection-and-Inversion-of-Control-with-ASP.NET-MVC

Why I cancelled my Spotify Premium subscription - the tale of an atypical music consumer

Liam Westley — Fri, 03 Feb 2012 00:21:59 GMT

Disclaimer

Firstly, I must come clean, I work for a digital music company which is involved in digital music streaming and downloads. In no way are the views expressed are the views of the company for which I work. They are merely the subjective views of an atypical music consumer.

I say atypical because despite being over 40, I seek out new bands on the radio, using listen again on 6Music and BBC Introducing programmes, such as Christian Carlisle’s excellent BBC Sheffield programme. I make an effort to go to at least one gig every month, including such gigs as the NME New Radar tour. Also, if I like a band, I will always try to buy their CDs, especially singles, my favourite format.

My mobile use

In addition, my mobile phone use is also unusual, in that I have a very old fashioned candy bar Windows Mobile 6.1 smartphone, a Benq E72. This provides my voice and text service, and also contains a 32Gb microSD card holding the 8000+ tracks that is my music collection. I listen to this using a Sony MW600 Bluetooth headset, the combination of which is incredibly reliable. The E72 is a 2G + WiFi phone with no data plan, just calls and unlimited text messages for £10 per month.

I also own what is now termed a ‘smartphone’, an Orange San Francisco badged ZTE Blade flashed with a custom Android 2.2 ROM. This contains a mobile broadband SIM from Three, providing a monthly allowance of 5Gb of 3G data for £7.50, which can be used directly or via tethering.

Spotify

Getting hooked

I first began using a the Spotify client at work; the free service including advertising, and enjoyed the ability to tap into a music catalogue that included many tracks which I did not own myself. I liked the shared playlists, which were sometimes used to create office playlists to which everyone could contribute.

The only downside, apart from the appalling quality of the advertising segments, was the lack of some of my favourite music. I’m a big fan of Spacemen 3, nothing there. Spiritualized, later releases, but not all. Sugar, no there. B-sides of older singles, not there.

It did grate that I had these tracks on my phone’s tiny 32Gb microSD card, and on my laptop, but this was a free service, so I don't think it is really fair to complain.

Becoming a premium subscriber

Eventually I decided to take the plunge and become a premium subscriber. Partly because of where I work and wanting to see a rival music delivery system, but also due to a desire to remove the annoying advertisements and allow me to access the mobile client on my Android phone and download offline content that I didn’t own.

For the first 3 or 4 months, it all seemed fine, I learnt the quirks of the mobile client and accepted that there were a few faults, but it was new, so that was to be expected. The lack of content could be partly solved by loading some of my own music collection onto a microSD card in the ZTE Blade smartphone.

Immediacy

There was a high point of being a premium Spotify subscriber. On the top of a 27 bus heading to Koko to an NME New Radar gig last October I spotted a tweet from the Joy Formidable that their new single, The Big More, had been released. I fired up Spotify and started downloading the tracks to listen to for the remainder of the journey. This even included a live version of Whirring, which was recorded at Koko in March, where I had been part of the audience swept along by the beauty of the introduction played on a harp.

This immediacy was quite intoxicating. I heard that one of my favourite new bands had released a new single, and downloaded it within minutes. However, having an offline copy didn’t prevent me buying the original, which as a CD only sold at gigs I couldn't attend, meant paying a premium for a copy sold on eBay.

This is one of my key reasons for using Spotify; listening to a new release, especially albums, and deciding whether it was worth buying the CD. I will always prefer to own the CD, as it provides a high quality archive copy, with decent artwork. If I consider there are only a few tracks worth having, I relent and buy digital downloads, but always burn them to a CD for archive.

Disillusion

So this all sounds like it worked quite well. I had music downloaded offline, which I would have otherwise had to pay for, and I could access much more music than was available from my own music collection, on my 32Gb microSD.

However, it never did become my sole music player, and I learnt that the offline files couldn’t replace the permanent access I had enjoyed without the subscription. The reasons are a complex mix of poor application design, restrictive access and lack of breadth of content outside mainstream music.

Poor user experience

I think the Android application is one of the more nasty pieces of user interface design I have seen for some time. I realise this is subjective but some really poor design choices and I can only believe lack of any serious rival has prevented these being addressed. With no real competition Spotify has no incentive to fix these issues. There are some very obtuse menu options and idiocy such as the redundant ‘Are you sure you want to exit’ dialogs after you click on the Exit menu. An important tenet of interface design should be Don't make the user feel stupid, which the Android client fails spectacularly;

If you update the Spotify application via the Marketplace, despite claiming that all user data will be preserved, you’ll be shocked when you realise that all your offline content will have been removed. Used up valuable 3G data allowance downloading offline content? Let’s hope not as you’ll need to re-download it all again. It can be over emphasised that there is absolutely no warning that this is about to happen.
On the Android client you cannot alter the order of items within the playlist. I believe this is possble on the iOS application, and I had hoped this would be fixed within a few months, but apparently not. Clearly I must be meant to edit my playlists using my Windows client, obviously when I’m out and about I couldn’t possibly want to do this. The only visible update I’ve seen in the Android app was the inclusion of a Facebook login option. Clearly Facebook login is a higher priority than a functioning playlist. Spotify have processes to update the functionality of their Android client, but only for items they consider worthy of the effort.
If you do add items to a playlist, they are added as the next item to be played. That makes creating a decent playlist virtually impossible as you have to build it from the end to the beginning, so no linking similar songs together in the order you think of them, and building it while the first tracks are playing. This is really basic stuff. I know it is, because it was in my media player on Windows CE (and Windows Phone) TEN years ago. It’s also something I do a lot, while listening to one song, it jars my emotional memory, and triggers a string of new tracks to add to the playlist.
And don’t get me started on Bluetooth support. This may be the ZTE Blade to blame, but it is massively not reliable, it stutters through songs, especially tracks not already offline, and don’t alternate between using the Bluetooth and the screen UI controls to change tracks. It all gets massively out of sync, with incorrect song titles and album art, so you really have no idea what you are playing. And that poor Bluetooth support also means that if you pause the music, and the device enters standby, you have to unlock the phone to restart the music. On my Benq E72 the keypad may be locked but the pause, prev and next buttons on the Bluetooth headset are still fully functional.

Even the Windows application has real issues. The auto update functionality means every now and then I start Spotify, see the playlist appear, only for it to vanish without warning, or any message, to reappear a minute or so later, updated, and with no explanation of what might have changed or if content requires to be downloaded again.

Music – here today and gone tomorrow, or never there at all

To some extent I can cope with the lack of some obscure music being on Spotify, and I don’t resent artists such as Adele (and her label, XL Recordings) for refusing to allow her latest album onto the system. If Adele doesn't want to cannibalise CD and digital downloads and doesn't need the exposure Spotify provides to smaller bands, then good on her.

More of an issue is seeing albums you have downloaded offline vanish without warning, as happened with The Burns Unit, ‘Side Show’. Having got used to listening to this as part of my subscription, with no advance warning, a message appeared one day saying it was being removed as it was no longer available.

As far as I am aware, no CD I have every bought has informed me that the music was no longer available so that I opened the case to find the silver disc strangely absent.

Value for money

The final nail in the coffin is the value for money. For me it became obvious that it represented poor value for money. In the six months I have had a subscription I have never really had more than 10 offline files that I do not own on a physical CD or digital download.

I could have happily downloaded every track for the price of one month’s subscription, and even worse, I could happily buy every album containing those tracks for the price of the six months of subscribing to the premium service.

It is sobering to consider that I pay just under £40 per month for a satellite television subscription with BskyB and £10 of that is for unlimited broadband. So in terms of content, Sky provide 100’s of television channels, repeatedly update the EPG and Sky+ system and put a huge amount of effort into usability of both of these applications.

In comparison, Spotify, for a third of this amount provides a poor user experience, especially on mobile, with much less valuable additional content to my own music collection

Should Spotify be worried?

Here is the reality – I don’t think Spotify should be worried. I know a much larger number of people who are very satisfied with their subscription. For them, the issues I have raised don’t really affect them, and Spotify provides a very useful means to instantly access a massive amount of music with the added benefit of social interaction with friends.

Even so I think Spotify shouldn't be complacent. They need to realise that selling subscriptions does mean that they will have to care more about treating their customers better. That means all customers, even if they have the temerity to use an Android handset.

They will also have to deal with artists better, and pay them properly, or more will decide to remove access to their content.

And finally, I think they may need to reconsider removing the reliance on Facebook logins for all new users. I was an early user so I still have my original Spotify login. I know that if I needed to use Facebook just to access Spotify I would never have used it in the first place.

But then, as I've mentioned, I’m an atypical music consumer.

Archive Links of Things to Read / Research / look it...

TomStickel — Thu, 02 Feb 2012 21:34:21 GMT

http://www.hanselman.com/blog/ThreeThingsILearnedAboutSoftwareWHILENOTInCollege.aspx

http://www.hanselman.com/blog/ScottHanselmans2011UltimateDeveloperAndPowerUsersToolListForWindows.aspx

http://www.soapui.org/SOAP-and-WSDL/adding-headers-and-attachments.html

http://developer.android.com/guide/developing/index.html

http://www.matthewbussa.com/2011/05/installing-and-configuring-cruise.html

http://www.blog.ingenuitynow.net/How+To+Unit+Test+Code+That+Uses+AppSettings+From+WebConfig.aspx

Testing WCF Web Services

TomStickel — Thu, 02 Feb 2012 21:25:38 GMT

Recently someone was showing me WCFStorm for testing WCF services, which is very simple to use.

However, SOAPUI certainly has a lot of power.

I needed to add an image to send to a service and noticed that references

http://www.soapui.org/SOAP-and-WSDL/adding-headers-and-attachments.html

My XML ended up looking like this:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ubox="UBoxMobileService.Interfaces" xmlns:ubox1="UBoxMobile.Data.Classes">

<soapenv:Header/>

<soapenv:Body>

<ubox:UploadCustomerSignature>

<ubox:request>

<ubox:UserIdMakingRequest>320628</ubox:UserIdMakingRequest>

<ubox:Entity>990019</ubox:Entity>

<ubox:TimeStamp>2010-09-23T10:00:00.0000</ubox:TimeStamp>

<ubox:ServiceCredentials>

<ubox:Username>User</ubox:Username>

<ubox:Password>mypassword</ubox:Password>

</ubox:ServiceCredentials>

<ubox:CurrentLocation>

<ubox1:Name>t</ubox1:Name>

<ubox1:Type>Customer</ubox1:Type>

<ubox1:LatLong>

<ubox1:Latitude>34</ubox1:Latitude>

<ubox1:Longitude>34</ubox1:Longitude>

</ubox1:LatLong>

<ubox1:Address>

<ubox1:Line1>d</ubox1:Line1>

<ubox1:Line2>d</ubox1:Line2>

<ubox1:Line3>d</ubox1:Line3>

<ubox1:City>d</ubox1:City>

<ubox1:State>az</ubox1:State>

<ubox1:PostalCode>85295</ubox1:PostalCode>

</ubox1:Address>

<ubox1:CenterNumber>0</ubox1:CenterNumber>

</ubox:CurrentLocation>

<ubox:ContractId>9559206</ubox:ContractId>

<ubox:DetailsId>8254262</ubox:DetailsId>

<ubox:ImageData>cid:Frs.jpg</ubox:ImageData>

<ubox:IsSignature>true</ubox:IsSignature>

</ubox:request>

</ubox:UploadCustomerSignature>

</soapenv:Body>

</soapenv:Envelope>

Stamp to honour flyby of Pluto by the New Horizons Spacecraft

TATWORTH — Thu, 02 Feb 2012 20:21:31 GMT

The New Horizons team are asking that the flyby of Pluto by the New Horizons spacescraft be honoured by the issue of a stamp. Please sign up at http://www.change.org/petitions/usps-honor-new-horizons-and-the-exploration-of-pluto-with-a-usps-stamp

My favorites visual studio extensions

Emanuele Bartolesi — Thu, 02 Feb 2012 20:18:52 GMT

Visual Studio 2010 offers a collection of extensions that help the developer's life.
In this list I try to share some that I hope will help you as they have helped me.

Visual Studio Achievement Extension

This extension is less useful than the whole list, but one of my favorites.

NuGet Package Manager

This is a package management system for the platform. NET that simplifies the inclusion of third-party libraries in your projects. The included libraries are automatically updated.

Productivity Power Tools

The first extension that I installed on my dev machine.

PowerCommands for Visual Studio 2010

This extension adds many features to the IDE.

VSCommands 2010

Navigation and generation code improvements.

Code Compare

With this extension you can compare code (in file and folder) very easily.

GhostDOC

I use this extension since many years and I can’t live without it.
It creates XML documentation from comments.

If you found other interesting extensions, do not hesitate to contact me!

Just slowing down a bit...

James Michael Hare — Thu, 02 Feb 2012 20:11:29 GMT

Given recent changes in my personal life with my son's diagnosis I will probably be blogging more on a bi-weekly basis instead of weekly for a while. I'm hoping this will be a temporary change until we get things all in order.

Also, I may be sprinkling in a few C++ posts as well to keep things fresh. I've been working on a C++ project as of late and though it is no longer my primary language, I still feel it has a lot of power and is worth knowing well.

Thanks for your understanding!

SQL Server NOLOCK

TomStickel — Thu, 02 Feb 2012 18:45:52 GMT

Pros and Cons of NOLOCK

I have seen some developers use WITH (NOLOCK) when querying in SQL Server and wonder why they use. Now i explored it and found that its useful to improve the performance in executing the query. However there is a disadvantage in using it. The disadvantage is that one may not be sure that they are getting the data which is currently being updated in the Table ie Without lock protection, you cannot be guaranteed that the data isn’t changing during the time that the query is running.

With these "Hints" you can quickly see where problems can occur:

SQL Server NOLOCK Hint & other poor ideas.

http://blogs.msdn.com/b/davidlean/archive/2009/04/06/sql-server-nolock-hint-other-poor-ideas.aspx

NOLOCK

This table hint, also known as READUNCOMMITTED, is applicable to SELECT statements only. NOLOCK indicates that no shared locks are issued against the table that would prohibit other transactions from modifying the data in the table.

The benefit of the statement is that it allows you to keep the database engine from issuing locks against the tables in your queries; this increases concurrency and performance because the database engine does not have to maintain the shared locks involved. The downside is that, because the statement does not issue any locks against the tables being read, some "dirty," uncommitted data could potentially be read. A "dirty" read is one in which the data being read is involved in a transaction from another connection. If that transaction rolls back its work, the data read from the connection using NOLOCK will have read uncommitted data. This type of read makes processing inconsistent and can lead to problems. The trick is being able to know when you should use NOLOCK.

As a side note, NOLOCK queries also run the risk of reading "phantom" data, or data rows that are available in one database transaction read but can be rolled back in another.

The following example shows how NOLOCK works and how dirty reads can occur. In the script below, I begin a transaction and insert a record in the SalesHistory table.

BEGIN TRANSACTION
      INSERT INTO SalesHistory
      (Product, SaleDate, SalePrice)          
      VALUES            
      ('PoolTable', GETDATE(), 500)

The transaction is still open, which means that the record that was inserted into the table still has locks issued against it. In a new query window, run the following script, which uses the NOLOCK table hint in returning the number of records in the SalesHistory table.

SELECT COUNT(*) FROM SalesHistory WITH(NOLOCK)

The number of records returned is 301. Since the transaction that entered the record into the SalesHistory table has not been committed, I can undo it. I'll roll back the transaction by issuing the following statement:

ROLLBACK TRANSACTION

This statement removes the record from the SalesHistory table that I previously inserted. Now I run the same SELECT statement that I ran earlier:

SELECT COUNT(*) FROM SalesHistory WITH(NOLOCK)

This time the record count returned is 300. My first query read a record that was not yet committed -- this is a dirty read.

Quick Review of Backup tools for SQL Azure

Herve Roggero — Thu, 02 Feb 2012 14:40:19 GMT

The landscape of SQL Azure backups is changing rapidly. A few tools are becoming available at no charge and Microsoft is adding capabilities over time. Here a quick update.

Microsoft Tools

Microsoft offers two primary backup mechanisms so far:

Export/Import feature available on the Azure Management portal
The COPY operation as part of its T-SQL CREATE DATABASE statement

These mechanisms do not offer a scheduling component and do not work together. To obtain a transactionally consistent backup, you first need to perform the COPY operation manually, then run the Export function.

Free Tools

You have other tools on the market that are a bit more comprehensive at no charge. Here are a few:

Enzo Backup for SQL Azure (Standard Edition)
Red Gate's SQL Azure Backup (backup only; no restore; no cloud backup)

These are the only two third-party products available at no charge I am aware of right now. Note that Red Gate's product provides a simple copy operation to a local SQL Server database, not really a backup/restore solution. However it does the job well if you want to get a local copy of your data. Enzo Backup is more comprehensive and offers many more functions, such as a built-in scheduler, cloud backup devices (in Blobs) and a restore capability.

Paid-For Tools

Enzo Backup for SQL Azure (Advanced Edition)
SQLAzureBackup (basic command-line BCP wrapper, no cloud backup)

Regarding the tools you can purchase, SQLAzureBackup is a product you can purchase, although it seems somewhat limited in its capabilities. You can nonetheless use it to export your data locally and restore the database back into SQL Azure. Enzo Backup Advanced Edition is a more powerful flavor of the free version that leverages multithreading for faster operations.

Here is a link to an MSDN article that offers additional information on how to backup SQL Azure: http://blogs.msdn.com/b/davidmcg/archive/2011/09/29/data-backup-strategies-for-windows-and-sql-azure.aspx

For the time being Enzo Backup appears to have significantly more capabilities than the other products, and it can be used at no charge by visiting Blue Syntax's website (http://www.bluesyntax.net).

[Disclaimer: I am the author of Enzo Backup for SQL Azure; this blog intends to provide a quick overview of the current tools available on the market; please investigate the tools referenced here and visit the MSDN link provided to make an educated decision]

New Direction

tom — Thu, 02 Feb 2012 20:19:00 GMT

Because I have moved to a new company, new position, and I am using new technologies this seems as good a time as any to change the focus of this blog. I have received some commentary to broaden my perspective and I will take this change to change and broaden the scope of my blog.

More than just code

I plan to include all sorts of things I come across in my job like:

General coding practices and SOLID coding principals
Interviewing and career advice
For other things I am passionate about like my Christian faith, exercise and diet, frugal living, landscaping, my wife and son, etc I may start another blog. I'll link to it if / when I get around to it.

Thinking outside the blog

In response to one reader's comment I should be thinking about the bigger picture. I assure you that I do but I haven't shared those thoughts on this blog. But that left my blog entries with very limited relevance. I still want to provide tips to things I can't find on the web and not just add more stuff to the online pile of opinions. My blog will still primarily be a place to share recurring issues I encounter in my career and I will I still include code examples if they are novel enough to be of interest.

With this entry included :) hold me responsible for providing enough context for my examples to make sense and clearly articulate their relevance.

Community

I haven't engaged with other bloggers and the web like I should in this blog. I occasionally contribute to other blogs and contact other bloggers. Sometimes I post to forums, sometimes I email authors, bloggers, and others. I will link to those where possible and where approval is given. For instance, Damon Overboe is a friend of mine with great blog on similar topics that I plan to cover and I get my images from http://usasearch.gov/images?locale=en&m=false so I can use images without fear of breaking copyright laws.

Regularity

I will start posting on a regular basis. This is in part due to the fact that I have been studying for a master’s degree which I now proudly hold. That should free up some time for a blog entry once a month or once every two weeks, I'll keep you posted. I'll try not to say much unless I have something relevant to say (present blog entry not included).

That's it

It's a new year, I have a new job, a new baby boy, and a new blog. I hope you like the blog.

-T

C# to C++ – A Somewhat Short Guide

Michael B. McLaughlin — Thu, 02 Feb 2012 13:45:11 GMT

Last updated: 2012-02-02

This is a big post – over 12200 words – and so I’ve decided to make it available as a PDF download, which you can get here:

http://www.bobtacoindustries.com/Content/Devs/CsToCpp-ASomewhatShortGuide.pdf

It has bookmarks for easier navigation along with a Table of Contents and page numbers.

I expect that I will revise this from time to time and welcome any suggestions, feedback, and (especially) corrections. If so I will update the Last updated field at the top and will create a revised PDF as well. I hope this proves useful.

For those interested, the sessions from the GoingNative 2012 conference will be streaming live today (Feb 2) and tomorrow on Channel 9: http://channel9.msdn.com/posts/Announcing-the-GoingNative-2012-Full-Schedule . Sessions will also be available for download shortly after the show ends (I’d guess within 24-48 hours, but that’s just a guess). It looks fascinating so definitely check it out! (I know I will be watching it.)

Introduction

This is a somewhat short guide to the important things to know if you are a C# programmer and find yourself needing or wanting to work in C++, for example to create Metro style games for Windows 8 using C++ and DirectX. In fact, this guide is written with that goal in mind so it's not necessarily a universal guide for all platforms and purposes.

This guide is also going to be fairly utilitarian and pithy, with code standing in place of elaborate commentary. I'm expecting that you know how to program already and have a good understanding of C# (or of some sort of imperative, object-oriented language at any rate).

I'm also assuming you are fairly handy with navigating the MSDN library. Its Bing search box is really awesome; if you haven't used it before, do give it a try. I like how the search is tailored to not just MSDN but also other great programmer sites like the Stack Exchange sites, CodeProject, CodePlex, etc.

I'm sprinkling a fair bit of code throughout as I said above. This is both to show you a (pseudo) real example of something and also to help illustrate words with code so that each will hopefully help to clarify the other.

Simple test programs

I highly encourage you to create a simple scratch program that you can mess around with. I do this all the time with various languages and frameworks in Visual Studio. I normally append "Sandbox" to the name so that I know it's something I am just playing around in. I tend to comment code out when done with it rather than delete it since I may want to look at it again in the future (perhaps to see a specific syntax that I puzzled out but haven't used in a while or maybe for some technique I was trying that I now want to use in a real project). If the code in question might be a bit confusing later on, I try to add some comments that will help me understand it. It's helpful to use a descriptive naming scheme for variables, classes, and functions (though I admit that I'm not too good about this in my sandbox apps). If a project gets too full or busy then I might use regions to hide a section of code or I might create another project or even another solution that will serve as a clean slate.

While developing this guide I've mostly been working in a project called CppSandbox developed in VS 2010 Ultimate and checked in VC++ 2010 Express. It's just a C++ Win32 Console Application (without ATL or MFC but with a precompiled header). This has let me test things like thread local storage duration. The C++/CX stuff can only be tested on using the VS11 preview on Windows Developer Preview (and, presumably, the next preview release of Windows 8, which is due towards the end of this month (Feb 2012)). For everything else you can use either VS 2010 Professional or greater or VC++ 2010 Express (available free here: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express ).

The major feature not present in VC++ 2010 is the ability to compile 64-bit applications. I'm not going to be touching on that here and I don't know whether that will be possible with the free versions of VS11 when they are released. I did do some tests with it in VS 2010 Ultimate just so I could examine the ASM it generates (out of curiosity). The main reason I developed in VS 2010 Ultimate is that it lets me work on multi-language projects at the same time such that I could write out a bit of test code in C# in a Console project and then duplicate it in C++. That wound up not being a big factor since I changed tactics but I already had the sandbox project so I just kept working with it.

That's enough chit-chat, I think. Let's get down to business!

Fundamental types

The C++ standard only requires that the integral types and floating point types each be at least as large as their next smallest counterpart. So when is a long not a long? When one long is a C# long (8 bytes) and the other is a Visual C++ long (4 bytes – same as an int). A Visual C++ 'long long' is 8 bytes. Microsoft has a table of fundamental sizes here:

http://msdn.microsoft.com/en-us/library/cc953fe1.aspx

Note that there are Microsoft-specific integral types that specify sizes exactly, such as __int32 (a 32-bit integer, same as a C# int), __int64 (a 64-bit integer, same as a C# long), etc.

The float and double types are the same sizes as in C# (32-bit and 64-bit, respectively). There's a type called 'long double' but in Visual C++ it is the same as a double so I don't recommend using it to avoid confusion.

Objects – class vs. struct vs. union

The difference between a class and a struct is simply that a struct's members default to public whereas a class's members default to private. That's it. They are otherwise the same.

That said, typically you will see programmers use classes for elaborate types (combinations of data and functions) and structs for simple data-only types. Normally this is a stylistic choice that represents the non-object-oriented origins of struct in C and that makes it easy to quickly differentiate between a simple data container versus a full-blown object by looking to see if it's a struct or a class. I recommend following this style.

In WinRT programming, a struct that is public can only have data members (no properties or functions) and those data members can only be made up of fundamental data types and other public structs (which, of course, have the same data-only, fundamental & public structs only restrictions).

As a terminology note, you'll commonly see structs that only have data members referred to as plain old data ("POD") structs.

You will sometimes see the friend keyword used within a class definition. It is followed by either a class name or a function declaration. What this does is give the class/function specified access to the non-public member data and functions of the class. It's probably not a great thing to use very often (if ever), but if you decide you need it for some reason and that refactoring your code would be impractical, it's there.

Multiple inheritance

C++ classes can inherit from multiple base classes. This is called multiple inheritance. I strongly recommend that you only use multiple inheritance as a workaround for the fact that C++ has no separate "interface" type. Design classes in the same way that you would in C# (i.e. with either no (explicit) base class or else with just one base class). When you want an interface, create an abstract class and inherit from that as well. To avoid trouble, have your interface classes only define pure virtual member functions. The syntax for such is to follow its parameter list with '= 0'. For example:

class IToString

{

public:

// Require inheriting classes to define a ToString member function

virtual std::wstring ToString() = 0;

};

class SomeBaseClass

: virtual public IToString

{

public:

SomeBaseClass()

: m_count()

{

}

~SomeBaseClass() { }

std::wstring ToString() { return std::wstring(L"SomeBaseClass"); }

void AddToCount(int val) { m_count += val; };

int GetCount() { return m_count; }

protected:

int m_count;

};

class SomeClass

: public SomeBaseClass

, virtual public IToString

{

public:

SomeClass() { }

~SomeClass() { }

void SubtractFromCount(int val) { m_count -= val; }

std::wstring BaseToString() { return SomeBaseClass::ToString(); }

std::wstring ToString() override { return std::wstring(L"SomeClass"); }

};

You'll notice that we marked the inheritance from the "interface" class with the virtual keyword when inheriting from it. This prevents a bizarre, battle of the inheritances from playing out. It'll compile without it (maybe) and if so likely even work right without it. However if you had data members in the class that is inherited from twice, it would wind up creating two copies of those data members (thereby making the class take up more room in memory).

Also, without marking the inheritance virtual, you must implement ToString in SomeClass rather than just inheriting it from SomeBaseClass. Otherwise you would get a compile error complaining that SomeClass is an abstract class wherever you tried to instantiate it and errors about being unable to pick between SomeBaseClass::ToString and IToString::ToString whenever you tried to call SomeClass's ToString member function. So the compiler issues warnings to you if you don't have those virtual markers because it's not sure that you really wanted two implementations of IToString.

Note that if you left off the override keyword from the definition of ToString in SomeClass, you would get a compiler warning about how SomeBaseClass already provides you with an implementation of IToString::ToString. By telling it we want to override any other definitions we make it clear that we want to override it and didn't just accidentally add it.

SomeClass's BaseToString member function shows the syntax you use when you want to call a member function of a class you've inherited from. It's the same syntax you'd use if you were calling a static member function, but the compiler knows that it's not a static and makes sure to translate things correctly so that it'll call SomeBaseClass's ToString when you use that syntax inside a derived class like that.

Union

A union is a data type that can't inherit from other classes or be a base class for other classes to inherit from. (In the last sentence, class refers to 'class', 'struct', and 'union' which are considered to be mandatory class-keys that specify the particular behavior of a class type). A union is made up of data members and (optionally) functions. Only one of its non-static data members can be active. This lets it fill several different roles at different times. It can also open the door to potential micro-optimizations.

There's a lot more that could be said about unions, but I have no intention of explaining them here. Unions are complicated to explain and I don't personally find them helpful. I see them as being part archaic and part advanced. You can get by just fine without them and if you really need to know more you can read up about them elsewhere. If there's sufficient desire, I'll reconsider my decision and perhaps either add more about them here or else write about them elsewhere or at least link to someone who has.

C++ constructors

C++ has four types of constructors: default, parameterized, copy, and move.

A default constructor is a constructor that can be called without an argument. Note that this includes a constructor that has parameters, provided that all the parameters have been assigned default values. There can only be one of these.

A parameterized constructor is a constructor which has at least one parameter without a default value.

A copy constructor is a special type of constructor which creates a copy of an existing class instance. There are two potential types of these (one const, one non-const) but normally you only write a const version. The compiler will typically implicitly create one for you if you don't (there are specific rules governing this). I always find it better to be explicit rather than rely on rules I would have to look up and read carefully.

A move constructor is a special type of constructor which creates a new class instance that moves the data contents of another class into itself (thereby taking over the data). They have various uses, but an easy to understand example is where you have a std::vector<SomeClass> (the C# equivalent is List<SomeClass>). If you do an insert operation and there is no move constructor (think a List<T> where T is a value type) then every object that has to be moved must be copied. That churns a lot of memory and wastes a lot of time. If there is a move constructor then everything goes much faster since the data can just be moved without copying. There are some instances where the compiler will implicitly create a move constructor for you. You should be explicit about this since you could easily wind up accidentally triggering a circumstance that causes one to suddenly be created/not created whereas previously it was not created/created (i.e. it flips behavior). You could in theory have both a const and a non-const move constructor, but a const one makes no sense at all.

With both copy and move constructors, if you provide one you should also provide the equivalent assignment operator overload.

We'll examine a class with all types of constructors now.

The following is the header file of a class named SomeClass. It includes the definition as well, though normally you would put any non-inline member function definitions in a separate CPP file. The class doesn't do anything of value but it does demonstrate a variety of things, such as all constructor types, a destructor, the use of checked iterators to safely copy data, and the use of some helpful Standard Library functions such as swap, fill_n, and copy. It also demonstrates both a static member function and an instance member function (one that is marked const (see Const-Correctness below)).

#pragma once

#include <string>

#include <algorithm>

#include <iterator>

using namespace std;

using namespace stdext;

class SomeClass

{

public:

// Default constructor with default value parameter.

SomeClass(const wchar_t* someStr = L"Hello");

// Copy constructor.

SomeClass(const SomeClass&);

// Copy assignment operator.

SomeClass& operator=(const SomeClass&);

// Move constructor.

SomeClass(SomeClass&&);

// Move assignment operator.

SomeClass& operator=(SomeClass&&);

// Constructor with parameter.

SomeClass(int, const wchar_t* someStr = L"Hello");

// Destructor.

~SomeClass(void);

// Declaration of a static member function.

static void PrintInt(int);

// Declaration of an instance member function with const.

void PrintSomeStr(void) const;

// Declaration of a public member variable. Not per se a

// good idea.

std::wstring m_someStr;

private:

int m_count;

int m_place;

// This is going to be a dynamically allocated array

// so we stick it inside a unique_ptr to ensure that

// the memory allocated for it is freed.

std::unique_ptr< long long[] > m_data;

};

// Default constructor definition. Note that we do not

// restate the assignment of a default value to someStr here in the

// definition. It knows about it from the declaration above and will

// use it if no value is provided for someStr when calling this

// constructor.

inline SomeClass::SomeClass(const wchar_t* someStr)

: m_someStr(someStr)

, m_count(10)

, m_place(0)

, m_data(new long long[m_count])

{

std::wcout << L"Constructing..." << endl;

std::fill_n(checked_array_iterator<long long*>(this->m_data.get(), m_count), m_count, 0);

}

// Copy constructor definition.

inline SomeClass::SomeClass(const SomeClass& other)

: m_someStr(other.m_someStr)

, m_count(other.m_count)

, m_place(other.m_place)

, m_data(new long long[other.m_count])

{

std::wcout << L"Copy Constructing..." << endl;

std::copy(other.m_data.get(), other.m_data.get() + other.m_count, checked_array_iterator<long long*>(this->m_data.get(), this->m_count));

}

// Copy assignment operator definition.

inline SomeClass& SomeClass::operator=(const SomeClass& other)

{

std::wcout << L"Copy assignment..." << endl;

this->m_someStr = other.m_someStr;

this->m_count = other.m_count;

this->m_place = other.m_place;

if (this->m_data != nullptr)

{

this->m_data = nullptr;

}

this->m_data = std::unique_ptr<long long[]>(new long long[other.m_count]);

std::copy(other.m_data.get(), other.m_data.get() + other.m_count, checked_array_iterator<long long*>(this->m_data.get(), this->m_count));

return *this;

}

// Move constructor definition.

inline SomeClass::SomeClass(SomeClass&& other)

: m_someStr(other.m_someStr)

, m_count(other.m_count)

, m_place(other.m_place)

, m_data(other.m_data.release())

{

std::wcout << L"Move Constructing..." << endl;

}

// Move assignment operator definition.

inline SomeClass& SomeClass::operator=(SomeClass&& other)

{

std::wcout << L"Move assignment..." << endl;

std::swap(this->m_someStr, other.m_someStr);

std::swap(this->m_count, other.m_count);

std::swap(this->m_place, other.m_place);

std::swap(this->m_data, other.m_data);

return *this;

}

// Parameterized constructor definition. Note that we do not

// restate the assignment of a default value here in the definition.

// It knows about it from the declaration above and will use it if

// no value is provided for someStr when calling this constructor.

inline SomeClass::SomeClass(int count, const wchar_t* someStr)

: m_someStr(someStr)

, m_count(count)

, m_place()

, m_data(new long long[m_count])

{

std::wcout << L"Constructing with parameter..." << endl;

for (int i = 0; i < m_count; i++)

{

m_data[i] = (1 * i) + 5;

}

inline SomeClass::~SomeClass(void)

{

std::wcout << L"Destroying..." << endl;

//// This isn't necessary since when the object is destroyed

//// the unique_ptr will go out of scope and thus it will be

//// destroyed too, thereby freeing any dynamic memory that was

//// allocated to the array (if any).

//if (this->m_data != nullptr)

//{

// this->m_data = nullptr;

//}

}

// Note that we don't have the static qualifier here.

void SomeClass::PrintInt(int x)

{

std::wcout << L"Printing out the specified integer: " << x << endl;

}

// But we do need to specify const again here.

void SomeClass::PrintSomeStr(void) const

{

wcout << L"Printing out m_someStr: " << m_someStr << endl;

// If we tried to change any of the member data in this method

// we would get a compile-time error (and an IntelliSense

// warning) since this member function is marked const.

}

Hopefully the above was enlightening. Terms like move constructor and copy constructor are thrown around a lot in C++ so having an example to look at should prove helpful. My goal was not to produce a class that is useful, but one where you could see the declaration patterns of these constructor types and see some ways to implement them (along with the required assignment operator overloads) by using Standard Library functions.

Storage duration

There are four possible storage durations: static, thread, automatic, and dynamic.

Automatic duration

Within a block (one or more lines of code within curly braces), a variable declared

a) either with no duration keyword or with the 'register' keyword; AND

b) without using the 'new' operator

has automatic scope. This means that the variable is created at the point at which it is declared is destroyed when the program exits the block. Note that each time the declaration statement is executed, the variable will be initialized. In the following:

for (int i = 0; i < 10; ++i)

{

SomeClass someClass;

someClass.DoSomething(L"With Some String");

}

you'll run the SomeClass constructor and destructor ten times (in the order constructor - destructor - constructor - destructor - ... since the current SomeClass instance will go out of scope each time before the condition (i < 10) is evaluated).

(Note that the 'auto' keyword used to be a way of explicitly selecting automatic storage duration. It's been repurposed to function the same as the 'var' keyword in C# as of C++11 (this new meaning of auto is the default in VS2010 and later). If you try to compile something using the old meaning of auto you'll get a compiler error since auto as a type specifier must be the only type specifier. If you've got a lot of legacy code you can disable the new behavior (look it up on MSDN); otherwise stick with the new meaning of auto.)

Dynamic duration

Dynamic duration is what you get when you use either the new operator or the new [ ] operator. While it is fine and even necessary to use dynamic duration objects, you should never allocate them outside of either a shared_ptr or a unique_ptr (depending on which suits your needs). By putting dynamic duration objects inside of one of these, you guarantee that when the unique_ptr or the last shared_ptr that contains the memory goes out of scope, the memory will be properly freed with the correct version of delete (delete or delete [ ]) such that it won't leak. If you go around playing with naked dynamic duration, you're just asking for a memory leak. For more about this see the next topic.

Thread duration

It is also possible to declare certain types of variables as having thread duration. This is similar to static duration except that instead of lasting the life of the program (as we'll see shortly), these variables are local to each thread and the thread's copy exists for the duration of the thread. Note that the thread's copy is initialized when the thread is started and does not inherit its value from the thread that started it.

C++11 has added a new keyword to declare this ('thread_local') however this keyword is not yet recognized such that you need to use the Microsoft __declspec(thread) syntax to obtain this behavior. For more information, see: http://msdn.microsoft.com/en-us/library/9w1sdazb.aspx . See below for a general overview of initialization.

Since this is a bit weird, I created a small sample to make sure I knew what was going on. It's a Win32 Console App tested in VC++ 2010 Express.

Static duration

We finish up with static duration. Primarily because static duration is what you get when none of the other durations apply. You can ask for it explicitly with the static keyword.

Initialization of thread and static duration objects

The details of exactly what happens during initialization of static and thread duration objects are complicated. Everything will be initialized before you need it and will exist until the end of the program/thread. If you need to rely on something more complex than this, you’re probably doing something wrong. At any rate, you'll need to sit down and read the C++ standard along with the compiler's documentation to figure out what's going on when exactly. Some of the initialization behavior is mandatory, but a lot of it is "implementation defined", meaning you need to read the compiler's documentation (i.e. the relevant MSDN pages).

Unwrapped 'new' keywords are dangerous; shared_ptr, unique_ptr, and weak_ptr

If you've worked in a .NET (or other garbage collected) language for a while, you're likely very used to using the 'new' keyword (or its equivalent in your language of choice). Well, in C++ the 'new' keyword is an easy way to create a memory leak. Thankfully, modern C++ makes it really easy to avoid this.

First, if you have a class with a default constructor, then when you declare it, it automatically constructs itself and when it goes out of scope it is automatically destroyed then and there. We discussed this earlier in automatic storage duration.

Next, the language provides two constructs that make it easy to allocate memory and ensure that it is properly freed: shared_ptr and unique_ptr. A shared_ptr is an automatically reference counted container that holds a pointer type (including dynamic arrays such as "new float[50]"). One or more shared_ptrs can exist for the same underlying pointer, hence the name.

Another object is the unique_ptr. You should use this in place of raw pointers except when you need multiple pointers to the same dynamic data (in which case use shared_ptr). Using a unique_ptr ensures that the memory owned by it will be freed when the unique_ptr itself is destroyed (e.g. by going out of scope, via a destructor, or via stack unwinding during an exception).

The last object to consider here is weak_ptr. The weak_ptr exists solely to solve the problem of circular references. If two objects hold shared_ptr references to each other (or if such a thing happens in the course of, say, a doubly-linked list) then shared_ptr's internal reference count can never drop to zero and so the objects will never be destroyed. For such a situation, make one of the references a weak_ptr instead. Weak_ptr is essentially a shared_ptr that doesn't increase the reference count. If you need to use the weak_ptr to access the resource, call its lock function to get a shared_ptr of the resource and then use that. If the object was destroyed before you could get it with lock, you will get back an empty shared_ptr.

The above types are all in the C++ Standard Library's memory header file, which you include as so:

#include <memory>

Notice that there is no ".h" at the end there. That's the way all of the standard library's headers are. If you're curious as to why, see: http://stackoverflow.com/questions/441568/when-can-you-omit-the-file-extension-in-an-include-directive/441683#441683 .

RAII - Resource Acquisition Is Initialization

RAII is a design pattern that, when done properly, enables C++ code to successfully use exceptions without resource leaks. Since C++ doesn't have a GC the way C# does, you need to be careful to ensure that allocated resources are freed. You also need to be sure that critical sections (the equivalent of a lock statement in .NET) and other multi-threaded synchronization mechanisms are properly released after being acquired.

RAII works because of this: when an exception occurs, the stack is unwound and the destructors of any fully constructed objects on the stack are run. The key part is "fully constructed"; if you get an exception in the midst of a constructor (e.g. an allocation failure or a bad cast) then since the object isn't fully constructed, its destructor will not run. This is why you always put dynamic allocations inside of unique_ptr or shared_ptr. Those each become fully constructed objects (assuming the allocation succeeds) such that even if the constructor for the object you are creating fails further in, those resources will still be freed by the shared_ptr/unique_ptr destructor. Indeed that's exactly where the name comes from. Resource acquisition (e.g. a successful allocation of a new array of integers) is initialization (the allocation happens within the confines of a shared_ptr or unique_ptr constructor and is the only thing that could fail such that the object will be initialized assuming the allocation succeeds (and if it doesn't then the memory was never acquired and thus cannot be leaked)).

RAII isn't only about shared_ptr and unique_ptr, of course. It also applies to classes that represent, e.g., file I/O where the acquisition is the opening of the file and the destructor ensures that the file is properly closed. Indeed this is a particularly good example since you only need to worry about getting that code right just the once (when you write the class) rather than again and again (which is what you would need to do if you couldn't use this and instead had to write the close logic every place that you needed to do file I/O).

So remember RAII and use it whenever dealing with a resource that, when acquired, must be freed. (A critical section is another good candidate; successfully getting the enter into the critical section is the acquisition and the destructor would then make sure to issue the leave).

Const-correctness

Const-correctness refers to using the const keyword to decorate both parameters and functions so that the presence or absence of the const keyword properly conveys any potential side effects. The const keyword has several uses in C++. For the first three uses, imagine we have the following variable:

int someInt = 0;

int someOtherInt = 0;

Const pointer

int* const someConstPointer = &someInt;

//someConstPointer = &someInt; // illegal

*someConstPointer = 1; // legal

A const pointer is a pointer that cannot be pointed at something else. You can change the value of the data at the location the const pointer points to. So above, attempting to change the target (even to the same target) is illegal and thus won’t compile but changing the value of someInt by dereferencing someConstPointer is perfectly legal and someInt will now have the value 1.

Pointer to const

const int* somePointerToConst = &someInt;

somePointerToConst = &someOtherInt; // legal

//*somePointerToConst = 1; // illegal

A pointer to const is a pointer to a value that you cannot change via the pointer. You can make the pointer point to something else, though. So above, you can change the target of somePointerToConst. But you cannot change the value of whatever it is pointing to. At least, not via the pointer; you can still set someInt and someOtherInt to have other values either directly or via a pointer that is not a pointer to const. In other words, the const keyword only affects the pointer, not the underlying data.

Const pointer to const

const int* const someConstPointerToConst = &someInt;

//someConstPointerToConst = &someInt; // illegal

//*someConstPointerToConst = 1; // illegal

A const pointer to const is, as you might guess, a pointer to a value that you cannot change via the pointer and that cannot be pointed at something else. It’s an amalgamation of the previous two uses of const.

Constant values

You can also use const to specify that a value in general is constant. It need not be a pointer. For instance you could have

const int someConstInt = 10;

which would create an int that was constant (i.e. unchangeable).

If someInt up above was made a const then the declaration of someConstPointer would be illegal since you would be trying to create a pointer to an int, not a pointer to a const int. You would, in effect, be trying to create a pointer that could modify the value of a const int, which by definition has a constant, un-modifiable value.

Constant member functions

Sometimes you will see a function that is declared and defined with the const keyword after the parentheses in which its parameters (if any) go. For example:

void PrintCount(void) const

{

wcout << L"m_count = " << m_count << endl;

}

What this usage of const means is that the function itself will not modify any non-static data members of the class and that it will not call any member function of the class unless they are also marked const.

Mutable data members

In certain instances you may wish to be able to change a particular data member even within constant member functions. If you mark the data member with the mutable keyword, e.g.

mutable int m_place;

then that data member can be changed even within member functions marked as const.

Summary and const_cast

When you use const to appropriately decorate function parameters, mark class member functions const where appropriate, and mark member data that needs to be changed within member functions that are otherwise marked const, you make it easier to understand the side-effects of your code and make it easier for the compiler to tell you when you are doing something that you told yourself you would not do.

The point of const-correctness is to prevent bugs and to make it easier to diagnose a bug. If you have some instance data member that is getting a completely wrong value somehow, you can instantly eliminate any functions that are marked const from your search since they should never be changing the instance data (unless it’s marked mutable, in which case you know to look at those const functions too).

Unfortunately there’s this thing called const_cast<T> which can ruin the party. The const_cast operator can, in many circumstances, eliminate the "const"-ness of something. It also eliminates any volatile and __unaligned qualifiers. You should really, really try to avoid using const_cast if at all possible. But const_cast does have some legitimate uses (otherwise why include it). If you’re interfacing with old code and/or a C language library that doesn’t follow const-correctness and you know that the function you are calling does not modify a variable that it takes as a non-const parameter, then you can mark the parameter to your function that you want to pass as const and then use const_cast to strip the const-ness from it so you can pass it to that function.

Strings

If you did any C or C++ programming at some point in the past you might remember these char* things that were used for strings. DO NOT USE THEM. ASCII strings and characters (char* and char) have no place in a modern program. The 80s are over, and it's a new, Unicode world.

Generally you’ll work with std::wstring and/or wchar_t* strings. These are the two types that Windows uses for Unicode strings. If you're getting data from the internet, you may well be getting it as UTF-8. This is not the same as wchar_t* or std::wstring. If you need to deal with UTF-8 data for some reason, look around on the web for suggestions.

Sometimes in Windows you’ll see the _TCHAR macro used. If you’re ever writing code that needs to run on Win 9x, use the _TCHAR system. Since I’m presuming that you’re learning C++ to use current (D3D11) DirectX technologies, most (if not all) of which don’t even exist pre-Vista, I prefer to work directly with wchar_t and std::wstring since that way macros don’t obscure function parameters in IntelliSense.

C++ recognizes several prefixes for string literals. For wide character strings (the two types above), the prefix L is used. So

const wchar_t* g_helloString = L"Hello World!";

creates a new wide character string. The wchar_t type is used for Unicode strings (specifically UTF-16).

The standard library’s std::wstring is a container for a wchar_t* string. It provides functions for mutating the string and still lets you access it as a wchar_t* when needed. To create one you would do something like this:

std::wstring someHelloStr(L"Hello World!");

If you are using std::wstring (which you should for any mutable strings you create) when you need to get the pointer from it to pass to a function that requires a const wchar_t* then use std::wstring’s data function. (If it needs a non-const wchar_t* then ask yourself whether or not you can accomplish what it is proposing with wstring's functionality instead. If not then you need to create a copy of the data using something like the wcscpy_s function (in wchar.h). Beware of memory leaks.)

Prefix increment vs. postfix increment

If you're coming from C#, you're likely used to seeing the postfix increment operator (i++) most everywhere.

In C++ you'll normally see the prefix increment operator (++i) everywhere.

In both languages the two operators mean the same thing. Postfix means "increment the variable and return the variable's original value (i.e. its value prior to incrementing it)". Prefix means "increment the variable and return the variable's resulting value (i.e. its value after incrementing it)".

To do a postfix increment, the compiler needs to allocate a local variable, store the original value in it, perform the increment, and then return the local variable. (Sometimes it can optimize the local variable away, but not always.)

To do a prefix increment, the compiler can simply increment the variable and return the result without creating an additional local variable.

In truth, the compiler is likely going to be able to optimize away your i++ extra temp allocation if you choose to use the postfix increment (VS 2010 SP1, for example, produces identical assembly code for both (no temp) with a typical ‘for (int i =0; i < 10; i++) { … }’ loop even in Debug configuration where it isn’t going hyperactive with optimizations). Cases where it likely can’t are primarily with custom types that actually implement the increment and decrement operators (see http://msdn.microsoft.com/en-us/library/f6s9k9ta.aspx ) and in cases outside of a ‘for’ loop where you are actually using the value returned by the increment (or decrement) calculation (in which case it definitely can’t since you clearly want either the one value or the other).

In general, using the prefix increment mostly seems to serve as notice that you have spent at least some time learning something about C++ programming.

Collection types

When coming from C# and .NET, you're undoubtedly familiar with the generic containers in C#. C++ also has these sorts of things but the names and methods may not be familiar (they also work a bit differently). Here are some of the more common mappings for collection types typically used in C# game development.

List<T> equivalent is std::vector

The header file include is #include <vector>

A typical way to create one is like this:

std::vector<SomeType> vec;

To add an item to the end of the vector, use the push_back member function. To delete the element at the end use pop_back. For example:

vec.push_back(someItem); // someItem added to the end.

vec.pop_back(); // someItem has now been removed from the end.

To insert an item somewhere other than at the back, use the insert function, e.g.:

vec.insert(begin(vec) + 1, someItem); // someItem added to index 1

// To add to the beginning, you'd just use begin(vec) without the + 1

To remove an item use the erase function, e.g.:

vec.erase(begin(vec) + 2); // The item at index 2 will be removed.

Note that unless you are storing a shared_ptr, any external references to the object will become bad since the destructor will run upon erasing it.

To iterate a vector's items, use code that looks something like this:

for (auto item = begin(vec); item != end(vec); ++item)

{

// Do stuff with item.

}

If the class you are storing in a vector supports move semantics (i.e. move constructor and move assignment operator) then vector will take advantage of that if you ever need to do an insert or an erase. This can provide a vast speed increase over the copy semantics it would otherwise need to use.

Dictionary<TKey,TValue> equivalent is std::unordered_map

The header file include is #include <unordered_map>

A typical way to create one is like this:

std::unordered_map<int, std::wstring> someMap;

The syntax for adding an item is a little funny (which is why I used real types above rather than made up ones; the key doesn't need to be an int and the value doesn't need to be a wstring). Here's an example of adding an item:

someMap.insert(std::unordered_map<int, std::wstring>::value_type(1, std::wstring(L"Hello")));

Yeah, you need to recapitulate std::unordered_map<TKey,TValue> in order to access its static member value_type (which is an alias for the appropriate constructor of the std::pair type for your map), which you use to insert the key and value. You may want to typedef it so you can shorten it, e.g.

typedef std::unordered_map<int, std::wstring> IntWstrMap;

...

someMap.insert(IntWstrMap::value_type(1, std::wstring(L"Hello");

If you try to use insert with a key that already exists, the insert fails. The insert function returns a std::pair with the iterator as the first item and a bool indicating success/failure as the second, so you can do something like:

if (!someMap.insert(

std::unordered_map<int, std::wstring>::value_type(

1, std::wstring(L"Hey"))).second)

{

wcout << L"Insert failed!" << endl;

}

You can also insert items by array notation syntax, e.g.:

someMap[0] = std::wstring(L" World");

If an item exists at that key it will be replaced (unlike with insert). If not, the key will be added and the item inserted there. Note that this is different than in .NET where you would get an exception if you tried to use a key that didn't exist.

To determine if a key exists, use something like this:

if (someMap.find(2) == end(someMap))

{

wcout << L"Key 2 not found. Expected." << endl;

}

where '2' is the key you are looking for. You could also store the result of the find, check it against end(someMap), and if it's not that, then you know that you have the item.

Indeed, if you want to retrieve an item only if it exists, this is the correct way to do it:

auto itemPair = someMap.find(1);

if (itemPair != end(someMap))

{

wcout << itemPair->second << endl;

}

If you tried using array notation, e.g.

auto item1Wstr = someMap[1];

you would wind up inserting an item at key '1' if no such item existed, with item1Wstr being the empty wstring that was inserted when you tried to get a key that didn't exist (but does now).

You can also use the at function to get an element at a specific key. If that key doesn't exist, it will throw an exception of type std::out_of_range. For example:

std::wstring result;

try

{

result = someMap.at(1);

}

catch (std::out_of_range e)

{

// Do some error handling

wcout << e.what() << endl;

}

To remove an item, the easiest way is to just call the erase member function with the key you wish to remove.

someMap.erase(1);

You can also use iterators to remove specific items or even a range of items, but in practice these may not be worth the bother. The same caution about references going bad applies here as well as it did in vector. Calling erase will trigger the destructor of any object, whether key or value.

SortedDictionary<TKey,TValue> equivalent is std::map

This is a binary tree rather than a hash map, (which is what unordered_map is). It's used in pretty much the exact same way as unordered_map so read above for usage info.

Others

There are too many collection types to go through them all in such detail. Here are several others you may be interested in:

· std::list – LinkedList<T>

· std::stack – Stack<T>

· std::queue – Queue<T>

On lvalues and rvalues (and xvalues and prvalues)

You may here mention of lvalues and rvalues from time to time. C++ has divided up rvalues into two subtypes: xvalues and prvalues. Which also generated something called glvalues. But we'll get confused if we go any further without clarifying this lvalue and rvalue business. The L and R stand for left and right. An lvalue was a value that could be on the left side of an assignment operator (in other words to the left of an = sign) while an rvalue was a value that could appear to the right of an assignment operator. So given

int x = 5 + 4;

the x would be an lvalue, while 5, 4, and (5 + 4) would all be rvalues.

C++11 has added the concept of rvalue references (which we will discuss shortly). This has created the concept of an expiring value (an xvalue), and in turn the concept of pure rvalues (prvalues).

Prvalues are things like literals as well as the result of a function, provided that that result is not a reference.

An xvalue is an object that's nearing the end of its life; for the most part this means the result of a function that returns an rvalue reference.

An rvalue is either an xvalue or a prvalue.

An lvalue is an object or a function. This also includes the result of a function where the result is an lvalue reference.

A glvalue (a generalized lvalue) is either an lvalue or an xvalue.

If you want to know more (or if the above doesn't make any sense), see:

http://msdn.microsoft.com/en-us/library/f90831hc.aspx and

http://en.wikipedia.org/wiki/Value_(computer_science)

Pointers

A pointer stores a memory address. You can have a pointer to a function, a pointer to a class instance, a pointer to a struct, to an int, a float, a double, … you get the idea. You can declare a pointer in either of the two following ways:

int* pSomePtr;

int *pSomeOtherPtr;

Which you use is purely a style thing; the compiler doesn't care. I use the int* syntax, personally.

Note the naming convention of beginning the name of a pointer with a lowercase p. This helps you instantly recognize that the variable you are working with is (or should be) a pointer. Using this naming style helps prevent bugs and helps make bugs easier to spot when they do crop up.

DO NOT DO THIS:

int* pSomePtr, pNotAPointer;

The pNotAPointer variable is not a pointer to an integer. It is just an integer. The same as if you had said:

int pNotAPointer;

The * must be applied to each variable in a comma separated declaration, which is what makes that declaration evil for pointers. When you use a declaration like the above, it's hard for you (and others who look at your code) to know if you meant for pNotAPointer to be a pointer or just an integer (this is one place where the p naming convention helps). It's also easy to repeatedly overlook the missing * and waste a lot of time trying to find the source of the bug.

Because bugs like that are hard to track down, you should never declare multiple pointers on the same line. Put them on separate lines like this:

int* pSomePtr; // Definitely a pointer.

int* pSomeOtherPtr; // Definitely a pointer.

int notAPointer; // Definitely NOT a pointer.

The compiler doesn't care and you will avoid a bad style.

Using pointers

I think the best way to describe using pointers is with documented code. So here's some documented code. Note that some of this code is bad style. I point this out in the comments.

int x; // Creates an integer named x. Its value is

// undefined (i.e. gibberish).

x = 0; // x is now equal to zero rather than gibberish.

int* pX; // Creates a pointer to an integer. Its value

// is undefined (i.e gibberish). If you tried to

// dereference it you would hopefully crash your

// program.

pX = &x; // pX now points to x. The & here means return

// the memory address of x. So pX now holds the

// memory address of x. This & is called the

// address-of operator. There's also an & that

// means an lvalue reference and one that means

// a bitwise AND. You'll learn which is which.

*pX = 1; // Sets x to one. The * here "dereferences" the

// pointer (i.e. lets you operate on the value it

// points to rather than on the pointer itself).

// This * is called the indirection operator.

pX = 1; // Bad – this makes the pointer point to memory

// address 0x01, which (if you are lucky) will

// cause your program to crash. If not you'll be

// randomly changing data the next time you use

// the pointer properly. Worse would be ptrToX++

// since that is more likely to give you a real

// memory address. More on that below.

SomeClass sc; // Create a SomeClass instance using

// its default constructor.

SomeClass* pSc; // Create a pointer to a SomeClass

// instance.

pSc = &sc; // Make pSc point to sc.

pSc->PrintSomeStr(); // This and the next statement are

// identical. The -> operator means

// dereference the pointer then get

// the member named PrintSomeStr. This

// syntax also works for data members.

(*pSc).PrintSomeStr(); // Here we are first dereferencing the

// pointer explicitly (*pSc) and then

// we're using the . operator to get the

// PrintSomeStr member. -> is just clearer

// looking.

pX = &x; // Set pX pointing to x again after the mishap above.

(*pX)++; // This increments the value of x by one. It is

// bad style because of what happens if you forget

// the parentheses.

*pX++; // This DOES NOT increment the value of x by one.

// Instead this increments pX by one. It is the

// exact same result as if you had just written

// pX++; without having the * in front of it. In

// other words this changes the memory address

// pointed to by the pointer, not the value that

// is stored at the memory address. The * is ignored.

*pX = *pX + 1; // This produces the exact same assembly code as

// (*pX)++; and doesn't have the same bug risk of

// accidentally forgetting the parentheses. So

// don't get cute with ++ and --. Just use this

// instead.

int ax[4]; // Declares an array of four integers. The

// values are all undefined. But this is

// not a dynamic array so you don't

// need to wrap it in a unique_ptr or

// anything.

int* pAx = &ax[0]; // Creates a pointer to the first

// element of ax.

*pAx = 0; // Sets the value of the first element of

// ax to 0.

pAx++; // Sets the pointer to point to the second

// element of ax. Arrays are linear in memory

// and the ++ increments the pointer by the

// size of one element (in this case the size

// of one integer).

*pAx = 20; // Sets the value of the second element of

// ax to 20. It effects the same result as

// writing ax[1] = 20; would.

The above code should give you everything you need to know about how to work with pointers. Whether it's a pointer to int or a pointer to SomeClass doesn't matter. When working with an array, incrementing a pointer to the array's first element with ++ can be a lightning fast way to initialize the array. But if you mess up and run past the end of the array then you'll be corrupting memory (and hopefully will crash your program).

Pointers to class member functions and the 'this' pointer; WinRT event handlers

One common pattern you'll see in WinRT for delegates and event handlers is this:

_someToken = SomeEvent += ref new SomeEventHandler(

this,

&SomeClass::MemberFunctionHandlerForSomeEvent

);

In C++, class member functions only exist once in memory no matter how many instances of the class you have. This makes sense since the function itself doesn't change for each instance; only the data that it operates on changes. So all the function needs to know is which data to operate one. As we'll see shortly, the C++ compiler takes care of that for us.

(The same is true in C# actually. Or usually true, anyway. The lone difference is that in C# if you've never run or referenced a method then the method probably won't be in memory since it likely hasn't been jitted yet. Once the program needs the method to be in memory it will be jitted and then it will exist once in memory, just like in C++.)

What the event handler constructor code is doing is constructing a delegate that says "hey you event, when you fire I want you to call me, this instance (ergo you pass the "this" pointer to specify that it should use this instance's data) with the class member function that is located at this memory address (which is what using the address-of operator with a class member function does gives you). It's the combination of instance data and the member function's address in memory that lets the event call the right member function with the right data whenever the event fires. (The bit about the token is just a peculiarity with how you unsubscribe from an event in WinRT when using C++.)

Note that we use the scope-resolution operator, "::", when taking the address of the member function. We use this (rather than . or ->) since what we are after is the address in memory of the member function itself, which as we already said is common to all instances of the class. It will make more sense if we briefly examine what happens when a C++ class member function is compiled.

Behind the scenes, when the C++ compiler compiles a member function it automatically adds a "this" pointer as a parameter to all of the instance member functions of our classes. The "this" pointer is a pointer to a particular instance of the class that the member function is a member of. When you call an instance member function the compiler takes that call and uses that instance's location in memory as the value of the "this" parameter that it added. The member function is wired up to use that "this" pointer to access and operate on the correct instance data.

Knowing all of this should help you understand what the purpose of that syntax for the event handler is. When the event is triggered, in order for the event to call the member function we specified it needs the address of the class instance to pass to the member function as the compiler-added "this" parameter. The only way it can know that is if we tell it what the address is. We do that by passing in "this" as a parameter to the delegate constructor. If you wanted some other class instance, then instead of passing in "this" you would pass in &theOtherInstance as the first parameter (using the address-of operator to get its memory address).

References

References are an attempt to prevent you from shooting your foot off with pointers without removing the ability to pass parameters by reference. They largely succeed but have some inherent limits and are different than .NET references (which really act more like pointers in some ways.

Lvalue references

Lvalue references are a way to create a reference to a value. They are useful for passing a parameter by reference rather than copying by value. Like with pointers, some examples will help explain them.

int x = 0; // Create an int named x and set it equal to zero.

int& rX = x; // Creates an integer reference named rX and sets

// it to refer to x. From now on rX acts like x.

x++; // x is now equal to one.

rX++; // x is now equal to two. Note how we didn't need

// to dereference anything. Once rX is assigned a

// value it becomes that value for all intents and

// purposes. You cannot make rX refer to anything

// else.

int &rY; // This is illegal. A reference must be assigned a value

// when it is created. The only exception is in a

// function definition since the value is assigned when

// the function is called or in a class data member

// definition (though I don't see much utility in having

// a data member that is a reference, personally).

// For the following function, by using a reference, we won't

// invoke the copy constructor when calling this function

// since rSc is a reference to an instance of SomeClass,

// not a separate instance of SomeClass. And we'll only be

// passing the size of a reference (4 bytes in a 32-bit

// program) versus the size of the object (44 bytes using the

// definition of SomeClass from the C++ constructors section).

// So references are your friend. In this case, since we won't

// be changing anything in the SomeClass instance, we mark the

// rSc parameter const.

void DoSomething(const SomeClass& rSc)

{

rSc.PrintSomeStr(); // Notice that we use the . operator and

// not the -> operator.

}

Passing parameters by reference (as in the DoSomething function above) prevents memory churning, prevents a constructor from running, and gives us the same behavior as we would expect if we passed a class as a parameter in .NET (i.e. a reference to the same object, not a separate copy of the object).

If you want to pass a copy of the object to a function for some reason then you can. Just leave off the reference marker on the parameter declaration and it will make a copy of the object and pass that copy in when you call the function. If you want to pass a copy to a function that takes a parameter by reference then you need to construct a copy first and then pass the copy in as the parameter when you call the function (since the function definition will only take a reference such that it won't trigger the copy constructor on its own).

Rvalue references

We've already seen rvalue references in the C++ constructors. The move constructor and move assignment operator both dealt in them. They use a syntax that looks like this:

SomeClass&& rValRef;

They are only particularly useful for move semantics and as we've already covered that in the constructors section, there's not much more to say about them here. They are new in C++11 but VC++ 2010 supports them.

Templates

Templates are sort of like .NET generics except that they aren't. They work to accomplish the same goal (generic programming) but do so in a different way. If you are curious to learn more about how .NET generics work, I recommend reading this interview with Anders Hejlsberg: http://www.artima.com/intv/generics.html . I'm going to focus strictly on C++ templates.

Templates are an integral part of the C++ Standard Library. Indeed, the Standard Library is an outgrowth of an earlier project called the Standard Template Library and it's common to see the Standard Library referred to as the STL.

C++ templates allow you to write classes and stand-alone functions which take in type parameters and perform operations on them. Here is an example:

#include <iostream>

#include <ostream>

template< class T >

void PrintTemplate(T& a)

{

std::wcout << a << endl;

}

What C++ does with this is interesting. The compiler will generate a version of PrintTemplate for each type that you call it with and will then use that version for all invocations of PrintTemplate with that data type. So, for example, if you wrote:

int x = 40;

PrintTemplate<int>(x);

the compiler would create a special int version of PrintTemplate, verify that this version of PrintTemplate can in fact work with an int (in this case making sure that int has a << operator defined for it), and if so create everything. Since everything is generated at compile-time it is very fast at execution time. A downside is that you can get some bizarre error stuff in the output window if you tried to pass in a type that doesn't have a << operator defined (e.g. our SomeClass type). And the build will fail, of course.

Indeed, overloaded operators tend to play a big part in template programming. If you take in two types and try to add them, you need to make sure that there's a + operator defined that adds those two types, otherwise it'll be carnage in your output window.

As far as the syntax goes, you just prefix the function or class with template< … > and you are set to go. You can pass as many or as few types as you want. The "class" keyword in there includes classes, structs, and built-in types like int (it likely includes unions too, though I have not tested that). The letter T is just a style convention, the same as in .NET; you can use anything as an identifier.

You can also use concrete types if you like, but then you need to pass a constant value in as the type parameter when invoking the template function/class.

Separate multiple types with a comma.

It's very easy to mess up template syntax and figuring out what you did wrong is a process of looking at the error message, looking up the compiler error number on MSDN, and trying to fix it based on what the error means. If you get stuck, try reading through the MSDN reference documentation on templates: http://msdn.microsoft.com/en-us/library/y097fkab.aspx .

MACROS

Don't create macros. You'll shoot your eye out. See, e.g.: http://msdn.microsoft.com/en-us/library/dy3d35h8.aspx (halfway through the Remarks section). If you're thinking about something that you think might make a good macro, use an inline function instead.

(Mind you, don't intentionally avoid macros that exist within headers that come with the Windows SDK or other SDKs and toolkits you decide to use. Just be aware of the fact that there can be unintentional side effects with macros like in the MSDN example above so avoid code with the potentiality for side effects when using a macro (. Keep it simple.)

Do, however, use other preprocessor features. For example, you should always put

#pragma once

at the top of all header files you write to make sure they are only processed once no matter how many files #include them. That notation is a Microsoft-specific thing, btw. You could also use the ISO-compliant

#ifndef __SOMECLASS_H_

#define __SOMECLASS_H_

// Your header file code here.

#endif

style. It’s up to you; I use the #pragma syntax since I don’t need to worry about name collision that way. If you use the ISO-compliant syntax and somehow ended up with two files with the same name and forgot, you’ll need to patch up the resulting error from the one file not being included due to the symbol already being defined by the previously included other file. One way to avoid that problem would be to bake in any namespaces or directory paths into the symbol names, e.g. __SOMENAMESPACE_SOMECLASS_H_. You also need to make sure all the header file code is inside the region between the #define … and the #endif if you use ISO-compliant syntax.

C++/CX (aka C++ Component Extensions)

Go watch Herb Sutter's excellent //build/ conference presentation, "Using the Windows Runtime from C++": http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-532T . It's a little over an hour long and will give you good insight not just into C++/CX but also into WinRT and Metro style app development in general.

C++ Component Extensions are a set of language extensions that make it possible to interface with the Windows Runtime and to write components that can be used from languages like C#, VB, and even JavaScript.

The two most common things you will see are the hat symbol '^' which is basically a WinRT pointer and the ref keyword (used in defining a WinRT class and instantiating a new instance of them). WinRT classes are automatically reference counted so you do not need to worry about putting them inside a unique_ptr. Instead you instantiate them like this:

auto someRTClass = ref new SomeRTClass();

The use of 'ref new' is necessary to create a WinRT class instance.

You only need to write a WinRT class if you are writing a WinRT component that's meant to be used as a library in some other application. You don't need to do this for classes that are directly in your game/application (though you can if you want; there's some overhead due to the automatic reference counting but it shouldn't be all that bad).

The following is an example of a WinRT class:

#pragma once

#include <unordered_map>

#include <collection.h>

using namespace Windows::Foundation;

using namespace Windows::Foundation::Collections;

namespace SomeComponent

{

public ref class SomeRTClass sealed

{

public:

SomeRTClass()

: someStr_(L"")

, someInts_(ref new Platform::Vector<int>())

{

// Do nothing

}

~SomeRTClass() { }

property Platform::String^ SomeStr

{

Platform::String^ get() { return someStr_;}

void set(Platform::String^ value) { someStr_ = value; }

}

int GetKeyedNamesCount(void) { return m_keyedNames.size(); }

Platform::String^ GetKeyedName(int key)

{

try

{

return ref new Platform::String(m_keyedNames.at(key).data());

}

catch(...)

{

throw ref new Platform::FailureException();

}

void SetKeyedName(int key, Platform::String^ value)

{

m_keyedNames[key] = std::wstring(value->Data());

}

property IVector<int>^ SomeInts

{

IVector<int>^ get() { return someInts_; }

}

private:

Platform::String^ someStr_;

Platform::Vector<int>^ someInts_;

std::unordered_map<int,std::wstring> m_keyedNames;

};

}

Anything in your component's public interface needs to deal in WinRT types (including fundamental types such as int; see: http://msdn.microsoft.com/en-us/library/windows/apps/br212455(v=vs.110).aspx ).

Public collection types must be WinRT interfaces to collection types (i.e. IVector<T> instead of Vector<T>).

Private code can use non-WinRT types such as std::unordered_map.

Also, the sealed keyword is only necessary to use the WinRT component in JavaScript.

If you ever did any managed C++ coding, you will likely notice that C++/CX syntax is pretty much the exact same syntax as managed C++. Microsoft elected to reuse the syntax since it had already been approved as a language extension by the ECMA standards organization. But C++/CX is entirely native; .NET is not involved and there is no GC running in the background (WinRT classes are automatically reference counted, remember).

For more on C++/CX and WinRT (including all of the rules governing WinRT components), I recommend checking out http://dev.windows.com/ (especially the Visual C++ reference for Windows Runtime page - http://msdn.microsoft.com/en-us/library/windows/apps/br229567.aspx ).

Visual Studio and C++

Initial configuration

If you're using VC++ 2010 Express for the first time, there are a few settings changes I recommend making (especially if you are coming from C#).

First, in the "Tools" menu under "Settings" switch to "Expert Settings". I recommend this for all Express SKUs of Visual Studio.

Next, in "Tools"->"Options…" under "Environment"->"Keyboard" switch the drop down menu from "(Default)" to "Visual C# 2005". This will prevent you from going crazy when F6 doesn't compile. If you are more comfortable with a different key mapping, use that one instead. The point is to switch to keys that you are familiar with.

While in "Options…" change any other settings you like. One thing I like to do is under "Text Editor"->"C/C++", in "General" I like to turn line numbers on and in "Tabs" I've taken to setting "Insert spaces" rather than "Keep tabs".

IntelliSense

If you’re using almost any of the Visual Studio keyboard mappings, typing Ctrl+J will bring up IntelliSense. In VS11 IntelliSense should appear automatically in C++. In VS 2010 and earlier, you need to manually invoke it.

Code snippets

I’ve never made too much use of code snippets, though I find myself using them more and more since I learned that the magic secret to accepting the parameters and starting to code is just to hit Enter.

Code snippets are a new feature for C++ in VS11; they don’t exist in earlier versions. If you’ve never used them (in any language), in a C# project start typing ‘for’ to begin a for loop but once IntelliSense has chosen the for snippet, press the Tab key twice and watch as a for loop appears complete with automatic fields that you can edit (use the Tab key to switch between fields). When you’re done editing the fields, press Enter and the cursor will be transported within the loop body with the field edits you made (if any) accepted and appearing now as normal text.

Including libraries

In C++, it's usually not enough to just include a header file. Normally you need to tell the linker to link against a library that implements the code that is declared in the header file. To do this, you need to edit the project's properties, accessible as "ProjectName Properties…" in the "Project" menu. In the properties, under "Configuration Properties" -> "Linker" -> "Input", one of the fields is "Additional Dependencies". This is a semi-colon separated list of the .LIB files you need to link against. It should end with

%(AdditionalDependencies)

so that any additional libraries that are linked via MSBuild are properly added. For a typical DirectX 11 Metro style game you might see the following:

d2d1.lib; d3d11.lib; dxgi.lib; ole32.lib; windowscodecs.lib; dwrite.lib; xaudio2.lib; xinput.lib; mfcore.lib; mfplat.lib; mfreadwrite.lib; mfuuid.lib; %(AdditionalDependencies)

Precompiled headers

A precompiled header (PCH) is a special type of header file. Like a normal header file, you can stick both include statements and code definitions in it. What it does differently is that it helps to speed up compile times. The PCH will be compiled the first time you build your program. From then on, as long as you don't make any changes to the PCH or to anything that is #included in the PCH, the compiler can reuse its pre-compiled version of the PCH. So don't stick anything in it that is likely to change a lot. But do add things that are unlikely to change. This way your compile times will speed up since a lot of code (e.g. Standard Library headers) will not need to be recompiled every build.

If you use a PCH, you need to #include it at as the first include statement at the top of every CPP file (but not at the top of header files). If you forget to include it or put some other include statement above it then the compiler will generate an error. This is just a result from the way the compiler needs to see PCHs in order to make it work.

Generating assembly code files

If you want to view (a very close approximation of) the assembly code that your code is compiled down into, in your project’s properties, under "Configuration Properties"->"C/C++"->"Output Files" set the "Assembler Output" option to something other than "No Listing".

I’d recommend either "Assembly-Only Listing (/FA)" or "Assembly With Source Code (/FAs)". I normally use the former; it sprinkles enough line number comments that I can cross-reference to see what code I’m dealing with. The latter can be helpful if you want one place to see it all rather than flipping back and forth between whatever you’ve opened the .ASM file in (I use Notepad++) and Visual Studio.

Note that the assembly that is generated uses MASM macros (you can look them up on MSDN). If you don’t know what a particular assembly instruction means (e.g. LEA), you can search the internet for it or try downloading the appropriate programming manual from Intel’s site (assuming x86/Itanium) or AMD’s site (assuming x64) or ARM Holding’s site (assuming ARM). If you’ve never learned any assembly, I definitely recommend it (try just creating a simple Windows Console app). The course I enjoyed most out of all the Comp Sci classes I took in my undergrad minor in CS was where I learned MIPS asm.

Terrifying build errors

Chances are if you come across a build error that looks completely horrible, it’s from the linker. You’ll see messages like this, for instance:

Error 2 error LNK2019: unresolved external symbol "public: __thiscall SomeClass::SomeClass(wchar_t const *)" (??0SomeClass@@QAE@PB_W@Z) referenced in function "void __cdecl DoSomething(void)" (?DoSomething@@YAXXZ) D:\VS2010Proj\CppSandbox\CppSandbox\CppSandbox.obj CppSandbox

All that’s saying is that it cannot find some function you said it should be able to find. In this case, I added the ‘inline’ keyword to a constructor function definition that was in the CPP file without remembering to relocate that definition to the header file. Any inline functions need to be in the header so that the linker won’t hate you.

All those ?? and @@and weird letters are just the way that C++ mangles names when it has compiled code into object files. Name mangling is internally consistent for the compiler in question but the ISO/IEC standard doesn’t mandate any particular schema for name mangling such that different compilers can (and often will) mangle things differently.

Anyway, normally if you see some sort of horrifying build error message, chances are good that it’s from the linker and that it’s an unresolved symbol error. If so, if it’s saying it can’t find something that you wrote (in the above case my SomeClass::SomeClass(wchar_t const *) constructor function (I always write ‘const type’ not ‘type const’ so even that bit is reconstructed)) then check to make sure that your declaration (in the header file) matches the definition (usually in the code file but maybe you put it in the header or maybe you forgot to write it or maybe you declared it inline but still have it in the code file). If it’s someone else’s function (or other symbol), then chances are that you didn’t tell the linker about the .lib file that contains it.

In .NET you just add a reference to an assembly and you get both the declaration bits and the actual definition stuff all in one. In C++, the declaration is the header file while the definition stuff (excluding inline stuff, which needs to be in the header file too) is in a separate library. See above about including libraries. Search the MSDN library for the symbol that it’s telling you it is missing and see if you can find the name of the library file you need to add.

C++ build errors can look pretty scary. Especially when you get a build error involving a template… those can make you want to quit. But don’t. Never let the horrible error messages win.

First figure out if it’s coming from the compiler (it’ll have a C#### error number format) or the linker (LNK#### error number format).

The compiler usually means some sort of syntax error. Check to see things like whether you forgot the #pragma once at the top of your header file. Another problem could be where you are using something from the standard library (e.g. ‘endl’) but forgot to have either a #using namespace std; or else to prefix it with std:: (i.e. ‘std::endl’). You can do either (or both) but must do at least one. And some things might be in a different namespace (in VS 2010, some functionality is in the stdext namespace, for example). The same goes for any namespaces you might be using in your own code.

If you aren’t having any luck on your own, try going on MSDN and typing in the first part of the error message. Chances are good that you’ll get some helpful links to discussions on the MSDN forums, on StackOverflow, perhaps an MSDN article or an MSDN blog post, … maybe even just the error code’s page itself will have the hint you need. If all else fails, post a question on a forums site (MSDN, the appropriate StackExchange site, the App Hub).

A linker error is typically an unresolved symbol, which usually means you either have a mismatch in declaration and definition, have an inline outside of its header, or else don’t have the right library added to the project’s extra dependencies in the project’s linker options. If it’s something else, try the strategies from the previous paragraph; they apply just as well to linker errors as to compiler errors.

Free Classroom training in Singapore

Aman Garg — Thu, 02 Feb 2012 11:40:03 GMT

Inviting all the people who wish to expand their knowledge in the field of Microsoft Technologies. I will be conducting FREE classes on various streams in Microsoft Technologies like:

SharePoint - Administration and Development
Visual Studio - 2010
C# and .NET 4
LINQ
Team Foundation Server 2010
SSIS
ASP .NET
Programming Office Apps & Open XML
Basic SQL Server and Queries
Windows Azure
One Note

All the courses will be taught using Microsoft Official Curriculum. Soft copies of Lab material, Virtual Labs and other course material will be provided. Classes will be conducted only on weekends.

About Me: Having more than 10 years of IT Experience worked in some of the biggest companies in Financial and Consulting Domain. Proficient speaker at various events like CTU Singapore and local UG. Certified Trainer from Microsoft (MCT), ex-MVP, MCITP, MOS (SharePoint, One Note), Early Achiever in MCSD .NET, MCSD (VB 6.0)

Again, all courses are totally FREE of cost with no strings attached and no hidden costs. Only requirement is your dedication and interest.

Mail me: amandeepgarg[at]hotmail.com if you wish to attend any of the courses. Spread the word amongst your friends who might be interested as well. Courses are only available in SINGAPORE.v

New version of Firefox (10!)

TATWORTH — Thu, 02 Feb 2012 09:09:42 GMT

A new version of Firefox is now out - version 10!

In Firefox, go to Help, About FireFox, wait for the download to run and apply!

Friend with a great Hair Loss Site call HairLossTalk.com

TomStickel — Thu, 02 Feb 2012 07:33:41 GMT

A friend of my runs a site called Hairlosstalk.com I am very happy for him as he worked very hard on the site authoring articles after countless hours and years of research and blogging and writing and chatting and on and on. So certainly for anyone male or female wanting to get good advise on preventing Hair Loss and growing back some lost hair, his website gets a ton of traffic and for good reason.

My ANT File for SchemaSpy

TomStickel — Thu, 02 Feb 2012 07:29:22 GMT

<?xml version="1.0"?>

</target>

</target>

<echo>starting to generate metadata schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate kb schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate program schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate project schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate account schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate enterprise schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate transactions schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate notification schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate reconciliation schema</echo>

</java>

<echo>done with schema</echo>

</target>

<echo>starting to generate people schema</echo>

</java>

<echo>done with schema</echo>

</target>

</project>

Companies that I worked for, I found so many email addresses....

TomStickel — Thu, 02 Feb 2012 07:28:53 GMT

Over the years of being a FTE and a contractor I see in my gmail account the list of company email addresses that I have had over the years. Certainly I wouldn't be able to recall all the email addresses prior to using gmail. Like me VarsityGold.com and Dataquick.com email, and Phoenix New Times email addresses along with Today.com etc...

tom.stickel@grsgroup.com

Thomas.Stickel@sperry.ngc.com

tomstickel@pqa.com

thomas.stickel.ctr@navy.mil

Tom.Stickel@suntrust.com

tom.stickel@nih.gov

tom.stickel@scc.virginia.gov

tom.j.stickel@schwab.com

tom.stickel@azdhs.gov

Tom.Stickel@trizetto.com