-John Carmack

“Excel has detected that ’somefile.csv’ is a SYLK file, but cannot load it. Either the file has errors or it is not a SYLK file format. Click OK to try to open the file in a different format.”

As it turns out, this error occurs when the first 2 characters of the first column name in a CSV file are “ID” (All upper-case).

The solution: Change “ID” to anything else. One or both characters can even be lower-case and that will solve this error.

I hope this saves some time for someone else out there.

I recently was asked to form an argument for switching my company’s source control from VSS 2005 to Subversion. This is what I came up with…

Subversion is obviously not the only alternative to Visual Source Safe, but it is a very solid one, one which I have personally used over the past several years with ease. Other source control options for us would be to use Perforce or MS TFS, both of which are pricey, especially TFS. However, Subversion is free and largely recommended by a vast number of people, especially when compared to VSS. Subversion is also supported by a large volunteer online community.

I have chosen Subversion over VSS mainly for the following reasons:

True Atomic Commits

A commit containing multiple files is treated as a single transaction, and a new revision all in one. Much like a database transaction, if one file fails to commit, they all fail – which is desirable to assure that project-wide changes being made which depend on each other are all done at once.

Copy-Modify-Merge

VSS’s lock-modify-unlock model makes it difficult to collaborate on rapidly changing files/projects. Subversion uses the copy-modify-merge model (aka optimistic merge), which better allows for multiple developers to work on the same project. More often than not, optimistic merge is a time saver over the lock-modify-unlock model. It is possible to lock a file from being committed by others in Subversion as well.

Easy Branching/Merging

Subversion allows for easy branching and merging of projects. This allows for easier development of new features or new versions of the product.

True Client-Server Model

VSS uses a network share for the repository database that relies on the developers having, basically, full control of the files therein. Subversion uses a true client-server model via http(s) or the proprietary svn protocol. I recommend the https protocol for compatibility and encryption.

Data Corruption with VSS

With VSS, it’s not a question of if the repository database will become corrupt and lose data, it is WHEN this will happen. Your source repository is supposed to be a rock - if a developer’s workstation crashes, you should only have lost HIS changes. You shouldn’t lose random files and data from the repository.

If you have developers spread across multiple time zones, the very act of both of them checking in can corrupt the database if they check in too close together, in the wrong order.

API

There is no good, usable, easily available published API for VSS and 3rd-party tools are weak for the most part. Subversion is open-source and inherently widely supported via API and many third-party plug-ins and additions.

Other notes:

Microsoft recommends that VSS is not suited well for large projects, but rather small projects with small teams. Microsoft themselves haven’t used VSS (in any widespread capacity) in over 10 years. If MS doesn’t believe in their own software, why should we?

ProduKey is a small utility that displays the ProductID and the CD-Key of MS-Office, Windows, Exchange Server, and SQL Server installed on your computer. You can view this information for your current running operating system, or for another operating system/computer - by using command-line options. This utility can be useful if you lost the product key of your Windows/Office, and you want to reinstall it on your computer.

Excerpt:

“The GetLastError() method of the Server object returns a reference to a generic HttpException wrapping the original exception that was passed from your ASP.NET page to the Application_Error event. Gain access to the original exception by calling its GetBaseException() method. This will provide the original exception instance, regardless of how many layers have been added to the exception stack. Once Application_Error has completed, it automatically performs a redirect to your custom error page that you can set up in web.config. See the MSDN documentation on how to set this up if you want it.”

Classes and structs

A class is allocated on the managed heap rather than on the stack and assignment between two variables results in both variables pointing to the same instance.

While the functionality is similar, structures are usually more efficient than classes. A struct takes up the amount of space (on the stack) that the value types defined in the struct take up together. You should define a structure, rather than a class, if the type will perform better as a value type than a reference type. Specifically, structure types should meet all of these criteria: Logically represents a single value; Has an instance size less than 16 bytes; Will not be changed after creation; Will not be cast to a reference type.

Immutable types in .Net, such as strings: Any change to this type causes the runtime to create a new object and abandon the old one. That happens invisibly, and many programmers might be surprised to learn that the following code allocates four new strings in memory:

1
2
3
4
5
6
7

// C#
string s;
s = "wombat";          // "wombat"
s += " kangaroo";      // "wombat kangaroo"
s += " wallaby";       // "wombat kangaroo wallaby"
s += " koala";         // "wombat kangaroo wallaby koala"
Console.WriteLine(s);

Only the last string has a reference; the other three will be disposed of during garbage collection. Avoiding these types of temporary strings helps avoid unnecessary garbage collection, which improves performance.

This article outlines how to get around this annoying, draconian limitation imposed by Micro$oft.

(more…)

“INSERT … ON DUPLICATE KEY UPDATE” will actually perform either an UPDATE or an INSERT, whichever one is necessary. The “REPLACE” statement will actually delete the row if it exists and insert the new row.

Example of “INSERT … ON DUPLICATE KEY UPDATE” (assuming column ‘a’ is the unique key):

1
2
3

INSERT INTO TABLE (a,b,c)
VALUES (1,2,3)
ON DUPLICATE KEY UPDATE b=2, c=3;

Example of “REPLACE”:

1
2

REPLACE INTO table_a (a,b,c)
VALUES(1,2,3);

Oracle 9i+ also has an extension that can somewhat similarly handle this conditional INSERT-or-UPDATE task: the MERGE statement, though not as intuitive and the code is not as easy to read. Here is an example of how one might implement MERGE for this situation:

1
2
3
4
5
6
7
8
9
10
11

MERGE INTO SCHEMA.table_a TA
USING (
 SELECT '1' a, '2' b, '3' c
 FROM DUAL
 ) E
ON (TA.a = E.a)
WHEN MATCHED THEN
 UPDATE SET TA.b = E.b, TA.c = E.c
WHEN NOT MATCHED THEN
 INSERT (TA.a, TA.b, TA.c)
 VALUES (E.a, E.b, E.c);

Comparing Oracle’s 11 line method to MySQL’s 3 line method, I must hand it to MySQL for its simpler and superior method.

References:
forums.devshed.com, dev.mysql.com, dev.mysql.com, www.mysqlperformanceblog.com, www.oracle.com

You can see the C# .Net equivalent here.

In Microsoft Visual C++ 8 (Visual Studio 2005), one useful use for the #pragma directive is to modify compiler warnings. This is from Microsoft:

#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...] )
#pragma warning( push[ ,n ] )
#pragma warning( pop )

The warning-specifier can be one of the following.

Warning-specifier	Meaning
1, 2, 3, 4	Apply the given level to the specified warning(s). This also has the effect of turning a specified warning on that is off by default.
default	Reset warning behavior to its default value. This also has the effect of turning a specified warning on that is off by default. The warning will be generated at its default, documented, level.See Compiler Warnings That Are Off by Default for more information.
disable	Do not issue the specified warning message(s).
error	Report the specified warnings as errors.
once	Display the specified message(s) only once.
suppress	Pushes the current state of the pragma on the stack, disables the specified warning for the next line, and then pops the warning stack, resetting the pragma state. You can only specify one warning for each suppress specifier, but multiple warning pragmas can operate on one line of code.suppress is only supported for C6000 warnings (code analysis warnings), which are enabled with the /analyze (Enterprise Code Analysis) compiler option.

The warning-number-list can contain any warning numbers. Multiple options can be specified in the same pragma directive as follows:

#pragma warning( disable : 4507 34; once : 4385; error : 164 )

This is functionally equivalent to:

// Disable warning messages 4507 and 4034.
#pragma warning( disable : 4507 34 )
 
// Issue warning 4385 only once.
#pragma warning( once : 4385 )
 
// Report warning 4164 as an error.
#pragma warning( error : 164 )

The compiler will add 4000 to any warning number that is between 0 and 999.

The compiler only supports up to 56 #pragma warning statements in a compiland.

For warning numbers in the range of 4700-4999, those associated with code generation, the state of the warning in effect when the compiler encounters the open curly brace of a function will be in effect for the rest of the function. Using the warning pragma inside the function to change the state of a warning greater than 4699 will only take effect after the end of the function. The following example shows the correct placement of warning pragmas to disable, and then restore, a code-generation warning message:

// pragma_warning.cpp
// compile with: /W1
#pragma warning(disable:4700)
void Test() {
   int x;
   int y = x;   // no C4700 here
   #pragma warning(default:4700)   // C4700 enabled after Test ends
}
 
int main() {
   int x;
   int y = x;   // C4700
}

Note that within a function body, the last setting of the warning pragma will be in effect for the entire function.

The warning pragma also supports the following syntax:

#pragma warning( push [ ,n ] )

#pragma warning( pop )

Where n represents a warning level (1 through 4).

The pragma warning( push ) stores the current warning state for all warnings. The pragma warning( push, n) stores the current state for all warnings and sets the global warning level to n.

The pragma warning( pop ) pops the last warning state pushed onto the stack. Any changes made to the warning state between push and pop are undone. Consider this example:

#pragma warning( push )
#pragma warning( disable : 4705 )
#pragma warning( disable : 4706 )
#pragma warning( disable : 4707 )
// Some code
#pragma warning( pop )

At the end of this code, pop restores the state of all warnings (including 4705, 4706, and 4707) to what it was at the beginning of the code.

When you write header files, you can use push and pop to ensure that changes to warning states made by the user do not prevent your headers from compiling properly. Use push at the beginning of the header and pop at the end. Suppose, for example, you have a header that does not compile cleanly at warning level 4. The following code changes the warning level to 3 then restores the original warning level at the end of the header:

#pragma warning( push, 3 )
// Declarations/ definitions
#pragma warning( pop )

See /FI and /w for compiler options that help you suppress warnings.