I hate the new Gmail look

I’ve managed to keep the classic Gmail look until today, when all of a sudden Gmail morphed irreversibly into the horrendous new interface, gray and white, without colors or contrast. The option to revert to the old good look cannot be found anymore, so that I’m stuck into this ominous thing! And the built-in themes don’t help!

I’m about to install Stylish addon and slap some CSS over this ugly interface, which I hate with passion. Let me say it again: I hate the new Gmail interface, which seems to have been inspired by the nothing.

Google is becoming more evil day after day.

Finding memory leaks in Win32

I’ve just discovered an interesting function to aid the Win32 programmer in finding eventual memory leaks in debugging mode, and with a very straightforward use: _CrtDumpMemoryLeaks.

The function compares the current memory state with the one at the program start, and if any unnalocated memory block is found, it returns TRUE and prints some debug information on the output window. So, to use it effectively, without false positives, one must call it when all objects are out of scope. Here’s an example:

#include <crtdbg.h>
#include <string>
int WINAPI wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int)
{
	std::wstring name = L"abcdef";
	_CrtDumpMemoryLeaks(); // will accuse a leak!
	return 0;
}

In the code above, there will be a false positive, because the string object didn’t go out of scope yet, therefore its destructor wasn’t called so far, so there’s still memory allocated. But this would rather lead to our expectations:

#include <crtdbg.h>
#include <string>
int WINAPI wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int)
{
	{
		std::wstring name = L"abcdef";
	}
	_CrtDumpMemoryLeaks(); // no leaks!
	return 0;
}

Now, since the string was declared within the scope of the nested block, its destructor will be called when the nested block ends, and no memory will remain allocated after it. This way, _CrtDumpMemoryLeaks will correctly report no leaks; indeed, nothing will be printed to the output window.

And the function is removed when _DEBUG is not defined, so you don’t need to worry about it on your release builds.

I particularly found it useful to use the _CrtDumpMemoryLeaks call inside an _ASSERT macro, so that when a memory leak is found, a huge popup will honk right in my face, in addition to the debug messages. So I actually proceed like this:

_ASSERT(!_CrtDumpMemoryLeaks());

Portable Git on Windows

I use Git on Linux a lot, but these days I was willing to use it on Windows too. I remember some time ago I found some ugly installers, so I thought there should be a portable package. For my surprise, I found one: msysgit. It’s a self-contained package build upon MinGW with everything one would need.

And it’s incredibly easy to use: just unzip the package anywhere, then doubleclick “git-bash.bat”. Like magic, you have a Linux-like terminal with a ready-to-use Git. And all the stuff exhales quality: it seems to be very well built and feels good on the tip of the fingers.

Now if you need to use Git on Windows, there’s no other way to go but msysgit.

Load Explorer file extension icon in Win32

When programming with C and Win32, sometimes you need to load an icon, as displayed on Windows Explorer, relative to a file extension. For example, you need to load the Explorer icon associated to the “txt” file extension.

Here is a quick function I use to do it:

HICON ExplorerIcon(const wchar_t *fileExtension)
{
	wchar_t extens[10];
	SHFILEINFO shfi = { 0 };

	lstrcpy(extens, L"*.");
	lstrcat(extens, fileExtension);
	SHGetFileInfo(extens, FILE_ATTRIBUTE_NORMAL, &shfi, sizeof(shfi),
		SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);
	SHGetFileInfo(extens, FILE_ATTRIBUTE_NORMAL, &shfi, sizeof(shfi),
		SHGFI_ICON | SHGFI_SMALLICON | SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES);

	return shfi.hIcon; // use DestroyIcon() on this handle
}

// Usage example:
HICON hIconTxt = ExplorerIcon(L"txt");

Remember to release the HICON handle by calling DestroyIcon after using it, or you’ll have a resource leak.

My Firefox addons

Just to mention, these are the addons I’m using today on my Firefox 10.0.2:

• Adblock Plus 2.0.3 — Blocks all advertising content according to filters. I use to install this addon wherever computer I am at, and apart from a few subscriptions, I also have a couple rules of my own.
• Download Statusbar 0.9.10 — Replaces the traditional download window with small progress bars at the bottom of Firefox.
• Element Hiding Helper for Adblock Plus 1.2.1 — Extra functionality to Adblock Plus, easing the process of select specific elements within a page for adding blocking rules.
• F6 0.2 — When working with the tabs on top, when you hit F6 key you put the focus on the tabs, instead of the address bar. This addon makes sure that the address bar will be focused when you hit F6.
• Flagfox 4.1.12 — Displays a flag from the country where the site is from, not by its country code top level domain, but rather by its server location, determined by its IP address.
• Forecastfox 2.0.21 — Adds a weather monitor on the toolbar, displaying current weather and temperature. I was told the data is picked up from airports. It has shown to be fairly accurate.
• UI Fixer 1.4.4 — Rearranges the horrible design of new Firefox interface, for example, restoring the text on the titlebar and placing the orange button at the toolbar.
• Undo Close Tab Replacement 6 — Shows a list of the most recently closed pages, so any of them can be reopened again.

Hide members on inheritance in C++

I was working on my personal Win32 classes, when I came across something I was willing to do. Suppose I have the following class:

class Base {
protected:
	int someValue;
	void doSomething();
public:
	void thePublicMethod();
	void anotherPublicMethod();
};

Since someValue and doSomething() are protected, they are visible and can be used by any subsequent derived class. Then, let’s have a derived class:

class Derived : public Base {
	void newStuff() {
		someValue = 42;
		doSometing();
	}
};

The public methods are still public. Now see that I used someValue and doSomething() inside newStuff() method, which is private. And now I don’t want subsequent derived classes to have access to someValue and doSometing(). I want to hide them from subsequent derived classes.

At first, I thought it wouldn’t be possible without redefining and overriding, which would add bloat here. But then I came across a trick I didn’t know, which allows you to hide both methods and variables without redefining or overriding them:

class Derived : public Base {
	Base::someValue;
	Base::doSomething; // now they are protected: hidden!

	void newStuff() {
		doSometing();
		someValue = 42;
	}
};

This trick changes the access modifier of methods and member variables without touching them, with zero overhead or additional bloat. Yes, C++ is a damn complex language.

Optimization settings for Visual C++ 2008

These are the optimization settings I use on Visual C++ 2008. These settings are set to the release builds, on the project settings window, and they complement the default release settings.

• C/C++
  • General
    • Debug Information Format: Disabled
  • Code Generation
    • Enable String Pooling: Yes
    • Enable C++ Exceptions: No
    • Runtime Library: Multi-threaded (/MT)
    • Enable Enhanced Instruction Set: Streaming SIMD Extensions 2 (/arch:SSE2)
• Linker
  • Debugging
    • Generate Debug Info: No

On debug builds I don’t change the settings much: I just disable the C++ exceptions, and enable the SSE2 and the string pooling.

Dennis Ritchie is dead

Known and remembered only by true programmers, the creator of the C programming language, Dennis Ritchie, has passed away, at the age of 70.

As a great fan of the C language myself, I'm deeply saddened by the news. C language shaped pretty much everything we have today in terms of programming, and almost everything we have today was written in C, and C is still the most widely used language. And C was released in 1973 – 38 years ago. So think about the importance of this man.

Rest in peace, Dennis. Your legacy will be eternal.

Smells Like Teen Spirit for orchestra

I started having formal music training when I was a child, and although I didn’t have any classes for years, I still like to study music when I have time, specially orchestration and related disciplines. Writing music for orchestra is not an easy task and it requires not only a lot of study, but also a lot of practice.

Today is the 20th anniversary of Nirvana’s Nevermind album. At the time it was released I was just a kid, and it made me to play a lot of guitar. So after 20 years I decided to make a tribute to Smells Like Teen Spirit and write a full orchestra arrangement to this song, mixing the original voice track over it – this voice track can be easily found on YouTube.

It took me about a month to write, render and mix the whole thing, and so far I’m pretty satisfied with the results. It gave that 4-chord music a whole new dimension. And here it is: Smells Like Teen Spirit for orchestra.

A sprintf with automatic memory allocation

Personally, I’m a sprintf lover. Not only in C, but in any program language that implements it. I use sprintf all the time, it’s extremely simple, clean and quick.

The sprintf version found on the C standard library requires a previously allocated memory space, where the formatted string will be placed after the operation. However, there are many times where you don’t know how long the result string can be, or you simply don’t want to waste space with a “worst case scenario” allocation. I used to face this a lot. There’s a GNU extension called asprintf, which you can use on Linux, but it doesn’t return the pointer, it returns the number of bytes – although it’s fine, it’s not exactly what I wanted.

So I decided to write my own version of a sprintf function which automatically finds out how much space is needed, allocates the memory and then returns the pointer, with the formatted string. Then I just have to free the pointer after use.

In order to accomplish this task, I used some least known functionalities from the C standard library, so it may be interesting to you to study how I did the job, so the technique can be applied when you need. Also, I found out that some of them behave differently on Linux and Win32. The idea is simple, though: find out how much memory is needed; allocate the memory; call sprintf; return the pointer. After all, I ended up with a valuable and handly function to work with.

This is the Linux version:

char* allocfmt(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	int len = vsnprintf(0, 0, fmt, ap);
	va_end(ap);

	va_start(ap, fmt);
	char *retbuf = malloc(sizeof(char) * (len + 1));
	vsprintf(retbuf, fmt, ap);
	va_end(ap);
	return retbuf;
}

And this is the Unicode-ready Win32 version:

#include <tchar.h>
#include <windows.h>
LPTSTR allocfmt(LPCTSTR fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	int len = _vsctprintf(fmt, ap);
	TCHAR *retbuf = malloc(sizeof(TCHAR) * (len + 1));
	_vsntprintf(retbuf, len, fmt, ap);
	va_end(ap);

	*(retbuf + len) = 0;
	return retbuf;
}

Fast, in-place C string trim

I want to share with the world this code for a fast trim function in C which is part of my personal library, and that I use quite often. It performs both left and right trim as an in-place operation, changing the original string. The return value is the same pointer that was passed as argument.

This is the version I use on Linux:

char* trim(char *s)
{
	char *pRun = s;
	while(*pRun == ' ') ++pRun;
	if(pRun != s)
	memmove(s, pRun, (strlen(pRun) + 1) * sizeof(char));
	pRun = s + strlen(s) - 1;
	while(*pRun == ' ') --pRun;
	*(++pRun) = 0;
	return s;
}

And this is the version I use on Win32, which is Unicode-ready:

LPTSTR trim(LPTSTR s)
{
	TCHAR *pRun = s;
	while(*pRun == TEXT(' ')) ++pRun;
	if(pRun != s)
	memmove(s, pRun, (lstrlen(pRun) + 1) * sizeof(TCHAR));
	pRun = s + lstrlen(s) - 1;
	while(*pRun == TEXT(' ')) --pRun;
	*(++pRun) = 0;
	return s;
}

How to install Chromium on Windows

Note: This post was updated on February 20, 2014.

Google Chrome is a modern browser, the most advanced one we have today. But unfortunately Google, on its way to world domination, uses it to silently collect personal data from you. Yes it does, even with those anti-privacy options unset – and it further links the information to your Google account, what is even worst. But there is a way to enjoy this amazing browser, away from Google’s eyes: directly using the open source project which feeds Chrome: Chromium.

Since I couldn’t find a decent tutorial anywhere, I decided to write my own, this step-by-step guide on how to download and install Chromium on Windows.

Chromium is usually used by the developers, but it’s also available to anyone who wants. This excellent post explains in detail how the versioning works. The Chromium builds for Windows are published on Chromium repository. These builds are made automatically by the buildbot. Beware: this is the cutting-edge repository, so any version may have bugs (if you find a bug, just download another version, by the way).

You’ll notice that some build numbers are missing: it happens because the buildbot only publishes the builds which pass 100% through all the automatic tests. The most recent build number which was published is written down as latest good known revision. I prefer to download the latest build of previous version, the one who became the Chrome beta stage, which is likely to be fairly stable.

The current (February 20, 2014) Chromium version under development is 35, therefore I recommend to get the last build of Chromium 34 (build 252031) which can be downloaded here.

History of last builds:
23 (2012-09-20) 157677, 24 (2012-10-30) 164895, 25 (2012-12-19) 173798, 26 (2013-02-13) 182231,
27 (2013-03-27) 190946, 28 (2013-05-08) 198631, 29 (2013-06-26) 208550, 30 (2013-08-14) 217340,
31 (2013-09-25) 225096, 32 (2013-11-05) 233008, 33 (2013-12-17) 241258, 34 (2014-02-20) 252031.

Although named “chrome”, this is in fact Chromium. Once downloaded, unzip the chrome-win32 folder into your “Program Files (x86)” folder (if in Windows XP, into your “Program Files”). Then doubleclick the chrome.exe file, and it will automatically do three things:

• create a shortcut to Chrome on your desktop, which you’ll probably want to drag into your start menu;
• create a small Registry entry at “HKEY_CURRENT_USER\Software\Chromium”; and
• create your profile folder on the following directory:
  • on Windows 7: “C:\Users\<user>\AppData\Local\Chromium”
  • on Windows XP: “C:\Documents and Settings\<user>\Local Settings\Application Data\Chromium”

At this point, Chromium is ready to run.

To update Chromium: Chromium doesn’t have automatic updates, you must do so manually. To update the Chromium version to the latest (or rollback), just download and unzip the “chrome-win32” folder over your current one, overwriting all files. Your profile folder isn’t touched.

To uninstall Chromium: these Chromium packages don’t create uninstall entries on the Windows Control Panel. To uninstall Chromium, you must essentially undo all the steps done on the installation: delete the “chrome-win32” folder, the shortcut, your profile folder (if you want to remove all your personal stuff) and the Registry entry.

And that’s it. Enjoy this great browser.

Follow up (Jun/2017): I stopped tracking these a while ago, but I released the app I developed to check the Chromium releases: Chromium Peeker is now open source.