At the end of session, Soe introduced Google Summer of Code that I have never known about it. He encouraged us to join the competition to get more experiences or to help our favorite open source communities, and we also have a chance to be selected to win $5,000. It’s quite interesting competition.

I am very happy to see more and more people who are involved in the group to build our strong software development communities in Cambodia together Hopefully, you will join with us the next month event.

git clone git://github.com/samnang/learning-desgin-patterns.git

• In Visual Studio, Go to “Tools –> Options”
• Select “Environment –> Keyboard”
• In the “Show command containing:” text box, enter your unit-test runner like “TestDriven” or “Resharper_UnitTest”:
  For my personal I have assigned some shortcut keys on:
  • TestDriven.NET.RunTests –> (Ctrl+R, Ctrl+T)
  • TestDriven.NET.Debugger –> (Ctrl+R, Ctrl+D)
  • TestDriven.NET.Debugger –> (Ctrl+R, Ctrl+D)
  • TestDriven.NET.RerunTests –> (Ctrl+R, Ctrl+R)
  • Resharper.Resharper_UnitTest_ContextRun –> (Ctrl+R, Ctrl+N)
  • Resharper.Resharper_UnitTest_RunSolution –> (Ctrl+R, Ctrl+S)

  

• Click the “Press shortcut keys:” text box. Now press the the shortcut key to be assigned for running your tests and click the Assign button.
• Don’t forget to set “Use new shortcut in:” to “Text Editor”.

I hope it’s useful for Test Driven Developers who want to get away from using mouse.

Finally, if you are waiting for WPF to support Khmer Unicode, so now it is. Let’s build more and more Khmer localization applications.

The new look Start Page in Visual Studio 2010 Beta 2.

Multiple target frameworks and ASP.NET MVC 2 project template.

Dynamic type in C#

VS2010 offers a feature to generate class from calling code, it’s useful to use in TDD.

There many new features on VS2010 and .Net Framework 4 to play with. I really fun with the powerful features that they provide. Hopefully, you will give it a try!

Download: Visual Studio 2010 and the .NET Framework 4 Beta 2

• Public methods can be called by anyone—no access control is enforced. Methods are public by default (except for initialize, which is always private).
• Protected methods can be invoked only by objects of the defining class and its sub-classes. Access is kept within the family.
• Private methods cannot be called with an explicit receiver—the receiver is always the current object, also known as self. This means that private methods can be called only in the context of the current object; you can’t invoke another object’s private methods.

The difference between “protected” and “private” is fairly subtle and is different in Ruby than in most common OO languages. If a method is protected, it may be called by any instance of the defining class or its subclasses. If a method is private, it may be called only within the context of the calling object—it is never possible to access another object’s private methods directly, even if the object is of the same class as the caller.

Suppose you have two instances of the Foo class, A and B. In languages like C#, A and B can call each other’s private methods. In Ruby, you need to use a protected method for that. This is the main difference between private and protected methods in Ruby.

Suppose further that you have a class called Foo and a subclass SubFoo. In languages like C#, SubFoo has no access to any private methods defined by Foo. In Ruby, it provides no way to hide a class’s methods from its subclasses. In this way, Ruby’s private works like C#’s protected.

To demonstrate these differences, let’s see in a example below:

class Foo
  def public_default_bar
    "public"
  end

  protected
  def protected_bar
    "protected"
  end

  private
  def private_bar
    "private"
  end

  def private_bar=(bar)
    @bar = "private"
  end

  public
  def public_bar
    "public"
  end
end

class SubFoo < Foo
  def check_protected_method_explicit_receiver
    self.protected_bar #it works
  end

  def check_protected_method_implicit_receiver
    protected_bar #it works
  end

  def check_private_method_explicit_receiver
    self.private_bar #it doesn't work
  end

  def check_private_method_implicit_receiver
    private_bar #it works
  end

  def check_set_private_method_explicit_receiver
    self.private_bar = "foo" #it works, specail case only for set method
  end

  def check_set_private_method_implicit_receiver
    private_bar = "foo" #it doesn't call the method, it's just a local variable assignment here
  end
end

I put the comments on each method in SubFoo to clarify which method call works, but you can also instantiate object from SubFoo in irb and call each method to see the result. Hopefully, you get understand and use it correctly when you do class design.

Going to conferences is about getting inspired. It’s about getting some new ideas swirl around in your head. During that event, we will see skilled speakers with a lot of experiences and confidence on stage giving a talk on a topic that they really want to share. In addition, you will meet a lot of experienced IT guys, so it’s your opportunity to raise the topics that you want to have discussion in the community.

You can find more information on BarCamp Phnom Penh 2009 at http://barcampphnompenh.org, and also you will see some activities from the last year’s conference as well.

Are you ready for the event? I hope to see you there.

My New Visual Studio Theme

If you want it, you can download it here. Give an alternate theme a try and let me know what you think.

After I played with Ruby about a few hours, I started loving it. Ruby is a fun toy. Like the differences between spoken languages, Ruby differs from most other programming languages not only by syntax, but by culture, grammar, and customs. And some programmers consider Ruby is English for computers. Ruby brings a new way of thinking about programming and software development. I would like to show you very basic examples, let’s go to see snippet code comparing between C# and Ruby.

//Swap value between two variables
int a = 5, b = 10;
int temp = a;
a = b;
b = temp;

//Output message 3 times
for(int i = 0; i <= 3; i++)
 Console.WriteLine("Hello");

//Output message if condition is true string
str = string.Empty;
if(str == string.Empty)
 Console.WriteLine("str is empty");

#Swap value between two variables
a, b = 5, 10
a, b = b, a

#Output message 3 times
3.times { puts "Hello" }

#Output message if condition is true
str = ''
puts "str is empty" if str.empty?

Code comparisons above are not to show which language is bad and another is good, but I just want to show how I feel about new language. Ruby code is short and readable like in English. There are lots of more powerful features in Ruby that I haven’t mentioned here.

If you haven’t touched something new recently, why don’t you give Ruby a try?