BigEvilEmpire: Code Log

Configure MySQL for UTF-8

2009-03-20T08:38:58Z

Ever saved a record into a MySQL database and upon retrieval of the record, you realized that the non-Latin characters(e.g. Asian characters) don't quite turn up as expected? Specifically, they turn up as a bunch of "?".

The likelihood of why this is occurring is that the MySQL database is configured as a default for Latin characters. In this day and age, one would assume that UTF-8 would be a de facto standard for this. Given my limited knowledge on database administration, I cannot fathom why Latin is chosen as a default over UTF-8. Shouldn't the benefit and the flexibility of supporting non-Latin characters outweigh whatever space that a Latin-only database saves (I am guessing this is the benefit) ?

Oh well, what would I know.

If UTF-8 is a foreign term, you absolutely need to read why it should even be a concern to any developer: The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets

For those, who see the need to support UTF-8 in your MySQL databases, fortunately you can do so by editing the MySQL configuration file (my.cnf). This file is typically found at: /etc/mysql/my.cnf if you are on Mac OS X or any UNIX/Linux-based OS.

Add the following to the my.cnf:

[client]
default-character-set = utf8 
...
... 

[mysqld]
default-character-set = utf8 
character-set-server  = utf8
default-collation     = utf8_general_ci
...

As an alternative, you can specify the default collation to be using "utf8_unicode_ci". The difference between them is :

For any Unicode character set, operations performed using the _general_ci collation are faster than those for the _unicode_ci collation. For example, comparisons for the utf8_general_ci collation are faster, but slightly less correct, than comparisons for utf8_unicode_ci. The reason for this is that utf8_unicode_ci supports mappings such as expansions; that is, when one character compares as equal to combinations of other characters. For example, in German and some other languages “ß” is equal to “ss”. utf8_unicode_ci also supports contractions and ignorable characters. utf8_general_ci is a legacy collation that does not support expansions, contractions, or ignorable characters. It can make only one-to-one comparisons between characters.

For more information on configuration of character-set:

Learning Ruby

2009-03-09T00:21:09Z

As I delved more into the world of the Ruby Programming language, I am discovering tools and resources that would be of help to someone new to Ruby. I want to log my learnings as I go along in hope that it would benefit anyone who might be trudging down this same path.

I may have jumped the gun when I wrote about using modules in Ruby. To kick-start learning about Ruby, it might be prudent to understand about the syntax of Ruby. There are several gems (pun intended) available online that cover the basics of the Ruby language:

In addition to these guides, there are also tools which are pretty handy for Ruby. For some quick action and experimentations with Ruby, there is always the Interactive Ruby Shell (commonly referred to as IRB). To use the IRB, just launch the Terminal app in Mac OS X and type "irb". Within the IRB, you will be able to enter Ruby commands and have the interpreter respond immediately.

$ irb

irb(main):001:0> myArray = [1,2,3,4,5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> myArray.each do |x|
irb(main):003:1* puts x
irb(main):004:1> end
1
2
3
4
5
=> [1, 2, 3, 4, 5]
irb(main):005:0>

For quick-access to view Ruby documentation off-line, you can always fall back on the ri documentation viewer. Launch the Terminal app in Mac OS X and invoke "ri" followed by the name of a Ruby class, module or method and ri will pull up the documentation accordingly.

Here are some sample usage of ri:

ri Array
ri 'Array#<<'
ri Array.each
ri Array::new

For any initiate to Ruby, these should be more than enough to get u moving along. Happy learning.

Using Ruby Modules

2009-03-03T08:15:29Z

In my recent pursue of learning Rails, I have gotten more exposure to the Ruby. The Ruby programming language is very pretty in terms of its syntax and the semantics. It is object-oriented and allow classes to import modules as mixins, which is the subject of this post.

I am still very new to Ruby and pretty much learning as I go along. This post is more to document my own learning than anything.

module MySharedModule
  HASH_CONSTANT = {:mykey => "value of mykey"}
  
  def mixin_method
    puts "calling mixin method"
  end
    
  class ClassInModule
    def self.class_method
      puts "calling class method"
    end
    
    def instance_method
      puts "calling instance_method"
    end
  end
end


class MyClass
  include MySharedModule
  
  def initialize
    # access module's constant
    # to be more verbose: MySharedModule::HASH_CONSTANT 
    puts HASH_CONSTANT[:mykey]    
    
    # access module method
    mixin_method
        
    # calls class method of a class in module
    # to be more verbose: MySharedModule::ClassInModule.class_method
    ClassInModule.class_method
        
    # instantiate, call instance method of class in module
    # to be more verbose: MySharedModule::ClassInModule.class_method
    instance = ClassInModule.new
    instance.instance_method    
  end
end


myClass = MyClass.new



# Output:
# value of mykey
# calling mixin method
# calling class method
# calling instance_method

To learn more about using modules in Ruby:

Bash Completion For Git

2009-01-15T07:10:23Z

Bash completion for Git is a very handy utility for a Git and Bash user. For the past few months, I have been trying out Git for source control. Having Bash completion for Git was useful in my attempts to get acquainted with the commands. So what exactly is Bash completion for Git?

If you are on Mac OS X, Bash comes with command completion. After typing part of a filename, command or pathname in Bash, hitting the <TAB> key will trigger Bash to prompt you with either the remaining portion of the filename or path. A subsequent <TAB> will then trigger a list of filenames or path that matches what has been keyed in so far.

Bash completion for Git works the same way by prompting you with available commands or filename.

One possible installation method would be using MacPorts. MacPorts is a really useful tool for compiling, installing and upgrading open-source software on the Mac OS X. It is command-line driven and is relatively simple to use.

sudo port install -u git-core +bash_completion +doc +svn

The command above installs Git with variants (variants are essentially additional options). In this case, MacPorts is installing Git with SVN, Git Man files (documentatons) and the main subject of our interest: Bash completion itself.

When installing new version of a port, MacPorts will make the existing version inactive and then install the latest version. Over time, you can wind up with a lot of inactive version for a port. The -u flag simply instructs MacPorts to uninstall any inactive ports.

The last step to this is to edit the user Bash configuration file in your home folder (~/.bash_profile) or the system-wide one (/etc/profile) and insert in the following:

if [ -f /opt/local/etc/bash_completion ]; then
  . /opt/local/etc/bash_completion
  export PS1='\h:\W$(__git_ps1 "(%s)") \u\$ '
fi

Apart from checking if the bash completion script exists and running it, the code above will also modify the Bash prompt so that you can always tell which Git branch you are currently working on. Handy information to have at the Bash prompt.

And it is done, Git for source control with extra help from Bash completion.

NSURLConnection With gzip

2008-10-20T00:04:32Z

It is nice to know that the NSURLConnection class supports gzip out of the box. The NSURLConnection class also does auto-decoding of the compressed data when the compressed content is received. However, by default even though the NSURLConnection class is handling this, it does not automatically add the required header to the HTTP request.

In order to inform the web server that the client is compression-aware and prefer to receive gzip-compressed content, you need to manually add the header to the HTTP request:

NSURL *url = [NSURL URLWithString:@"http://www.fubar.com/webservice.xml"];
NSMutableURLRequest* urlReq = [[NSMutableURLRequest alloc] initWithURL:url];

//add gzip-encoding to HTTP header
[urlReq setValue:@"gzip" forHTTPHeaderField:@"Accept-Encoding"];

If the web server supports gzip compression, the response that it returns to your Cocoa application or iPhone app will be compressed.

By utilizing gzip-compressed content, it reduces response time for a HTTP response because the size of the HTTP response is smaller. This may have a considerable impact to native iPhone apps that rely heavily on web services since the overall network traffic is optimized and data transfer is more responsive.

For those new to gzip compression, BetterExplained has a very good article explaining how gzip help in site optimization.

Creating iPhone App Without XIB

2008-10-17T05:15:16Z

The XIB file format is introduced in the Interface Builder 3 on Leopard. It replaces the previous file format NIB, short for NeXT Interface Builder. The Interface Builder application is a GUI for building and assembling user-interface objects, images and references to sounds for your Mac application. It allows you to drag and drop user-interface objects such as buttons, tableviews onto a window and layout the objects visually. These objects are archived and saved as a XIB file. When an application launches, these XIB files are loaded and un-archived. The user-interface objects are then made available to the application.

For those who are keen to know more about the inner workings of XIB files, I would recommend checking out Fraser Speirs' post on XIB files.

Using the Interface Builder is a convenient way to handle views hierachy and user-interface objects but however, you can also opt to handle these programmatically. To do that, create a new Project in XCode and use the "Window Based Application" template. This template is the basic and simplest template and it is ideal for this purpose.

The template provides the MainWindow.xib file which is unnecessary since we are programatically creating the user-interface objects. You can delete it and also remove the reference to this XIB file by deleting the last entry "Main nib file base name" in the Info.plist file.

You would then edit the main.m file as shown below:

int main(int argc, char *argv[]) {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    int retVal= UIApplicationMain(argc,argv,@"UIApplication",@"AppDelegate");
    [pool release];
    return retVal;
}

The main.m file, as the name suggests, contains the code that will run when the application gets launched. By editing the main.m file as shown, the code will create an instance of a UIApplication class named "AppDelegate".

The last step to this would be to set up the AppDelegate class:

#import "AppDelegate.h"

@implementation AppDelegate

@synthesize window;

-(void)applicationDidFinishLaunching:(UIApplication *)application {
	window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
	window.backgroundColor = [UIColor whiteColor];

    // Override point for customization after application launch
    [window makeKeyAndVisible];
}


-(void)dealloc {
    [window release];
    [super dealloc];
}

@end

All that the AppDelegate class does is to create the main window of the application and make it visible. Voila! Now you are all set to go! A basic iPhone App without any XIB file.

Private Methods In Objective-C

2008-10-03T06:50:45Z

Even though Objective-C has support for private, protected and public instance variables, there is no notion of private methods. Every method is considered as public. However, there is an easy approach to make mock private methods by using categories.

//--------------------------------------------
// File: SomeClass.h
//--------------------------------------------

@interface SomeClass
+ (void)publicClassMethod;
- (void)publicInstanceMethod;
@end

The interface definition would be the same; just declaring the public methods available (as shown above). However for the implementation of the class, an additional definition for the category would be required and the implementation for the private method will follow after the usual implementation for the class.

//--------------------------------------------
// File: SomeClass.m
//--------------------------------------------

@interface SomeClass (Private)
+ (void)hiddenClassMethod;
- (void)hiddenInstanceMethod;
@end


@implementation SomeClass
+ (void)publicClassMethod{
	//This class method is public
};

- (void)publicInstanceMethod
	//This instance method is public
}
@end


@implementation SomeClass (Private)
+ (void)hiddenClassMethod{
  //This class method is private
}

- (void)hiddenInstanceMethod{
  //This instance method is private
}
@end

To avoid writing a separate @implementation block for the private method, we can use "anonymous" categories. This is done and demonstrated below by omitting a name in the parentheses of the second @interface block.

//--------------------------------------------
// File: SomeClass.m
//--------------------------------------------

@interface SomeClass ()			//name is omitted for the category
+ (void)hiddenClassMethod;
- (void)hiddenInstanceMethod;
@end


@implementation SomeClass
+ (void)publicClassMethod{
	//This class method is public
};

- (void)publicInstanceMethod
	//This instance method is public

+ (void)hiddenClassMethod{
  //This class method is private
}

- (void)hiddenInstanceMethod{
  //This instance method is private
}

@end

Despite all these, one thing to be mindful of is that there are no true private methods in Objective-C. These mock private methods will still be available during run-time. The documented use of categories is to add methods to an existing class without requiring the actual source. It enables the functionality of the class to be extended without sub-classing.

Hiding Folders From The Finder

2008-09-23T08:03:39Z

Mac OS X is a Unix-based operating system and because of that, it comes with a directory structure that is similar to the Unix operating system. What this means is that you will have directories like "etc", "var", "usr" etc. at your root. At this point some of you may think I am sprouting nonsense. Those directories do not even appear in the Finder. What am I talking about?!

Well, here is the thing. Those directories do exist but however, they do not appear in the Finder and are well hidden away from the UI of the Mac OS X. These directories contain important files for the OS and the average user would never have the need to mess with the content inside them.

I use MacPorts to manage my command-line open-source software on my Mac. By default, MacPorts installs the software to the directory "/opt/local". It creates a directory "opt" and that directory appears in the Finder. Thankfully there is a way to hide this directory from the Finder like the ones mentioned earlier.

There are two useful tools that comes with the Developer Tools: GetFileInfo and SetFile. They can be found in this directory: /Developer/Tools/

To hide any directory (in this case, the "opt" directory) from the Finder, run the following command in Terminal:

sudo SetFile -a V /opt

To view the file attributes of a file or directory, run the following command:

GetFileInfo /opt

In this example, you can see that the directory "/opt" has an uppercase "V" in its attributes. This flag indicates that the directory is to be hidden from the Finder.