Archive

Archive for the ‘Programming Languages’ Category

New feature in Bike: member_missing

June 11th, 2012 Comments off

I always like the ability of objects to dynamically respond to a message without having an explicit binding. Something like method_missing in Ruby or DynamicObject in .NET. It would be great for Bike to have that capability. Fortunately, adding this feature was much easier than I thought, thanks to how the interpreter code was already laid out. Please join me welcoming member_missing in Bike! Let’s examine this feature more closely, shall we?

var obj = {
  member_missing: func(name) {
    return "Member: {0}".with(name);
  }
};

println(obj.notExist); # Member: notExist
println(obj.has_member('notExist')); # False

The code above creates an object and defines the special member_missing method, which will be invoked by the runtime whenever it can’t resolve a member. Therefore, when trying to access notExist, methodMissing is invoked with the member name as its only argument and has a chance to decide what to return. In this case, it returns a string showing what member was being accessed.

This works for method invocation as well. When the interpreter attempts to invoke a method, the first thing it does is resolving the method object (Bike.Function) before invoking it. Therefore, member_missing can also do its magic here by returning a method that the runtime will instead invoke.

obj = {
  member_missing: func(name) {
    if (name == "add") {
      return func(a, b) { a + b };
    }
  }
};

println(obj.add(1, 2)); # 3

You see, Bike’s member_missing doesn’t behave exactly like Ruby’s method_missing. I could modify the runtime to instead of invoking the function returned by member_missing, it will invoke something like method_missing (Bike edition!) and pass in the call information (e.g. name, arguments). Maybe that what I should have done for efficiency sake (i.e. avoid creating a function every time!). Then again, maybe later, one thing at a time, eh. For now, those who care about a bit of efficiency here and there, you can cache the generated method, as follow.

obj = {
  member_missing: func(name) {
    if (name == "cache") {
      return this.cache = func() {};
    }
  }
};

obj.cache();
println(obj.has_member('cache')); # True

The next time obj.cache() is invoked, member_missing() isn’t invoke anymore because an explicit binding already exists.

Now, a more interesting example demonstrating the power of member_missing. If this somehow reminds you of RailsActiveRecord, you’re right.

var db = {
  member_missing: func(name) {
    if (name.starts('find')) {
      return db[name] #! cache it !# = func(obj) {
        var sql = 'SELECT * FROM {0}'.with(name.sub(4).upper());
        obj.members(false, true).each_with_index(func(name, index) {
          sql += (index == 0 ? ' WHERE ' : ' AND ') +
                 name.upper() +
                 (obj[name] is Bike.String ? '' : '=') +
                 obj[name]
        });
        println('Executing...{0}{1}', NL, sql);
        return [#! Suppose I'm a product array, yay! !#];
      };
    }
  }
};

# SELECT * FROM PRODUCTS WHERE CATEGORYID=1 AND PRICE>1000
var products = db.findProducts({categoryId: 1, price: '>1000'});

Interested? Have Bike up and running and start hacking. The examples above can be found in GitHub.

The Bike Programming Language

February 19th, 2012 6 comments

Bike is a programming language that I develop.  I worked on this interesting toy project a while ago.  I was hoping to have had time to improve it further (plenty of things I want in a language) before announcing it in my blog.  However, work at my new startup has been so hectic (surprise, surprise…) that I can hardly find time to continue, so I guess I just put it out to the public and get everyone’s opinions.

In a nutshell, Bike is an interpreted language running on Windows and Mac/Linux (via Mono).  I developed Bike with the intention of building a language feel most natural by me so that I can use for daily programming tasks.  And since the existing languages that already feel natural to me are Ruby, JavaScript and C#, no surprise that these languages influenced Bike a great deal.  From the language perspective these are the important characteristics of Bike:

  • Dynamic and strong typing
  • Everything is an object
  • Prototypal inheritance
  • First-class function
  • CLR interoperability

No further ado, here’s some Bike.  First, hello world.

print 'Hello, world!'

Everything is object (note that the print function is passed as argument)

10.times( print );
0.upto( 10, print );

Calculating Fibonacci (return keyword is optional, semicolon is optional in the last statement of a block)

func fib( n ) {
    n <= 2 ? n : fib( n - 1 ) + fib( n - 2 )
}
print( "n: " );
var n = readln();
println( fib( n.to_number() ) );

Self-executing function

( func() {
    println( 'executed' );
} )();

Closure

var f = ( func( a, b ) {
     var c = 1;
     return func() { a + b + c };
} )( 2, 5 );
println( f() );

Currying

Bike.Function.curry = func( *args ) {
	if ( args == null || args.size() == 0 ) return this;
	var me = this;
	return func( *more ) {
		if ( more != null )
			args.add_all( more );
		me.call( this, *args );
	};
};

func add( a, b ) { a + b }
var addTo2 = add.curry( 2 );
println( addTo2( 3 ) );

add = add.curry( 2, 3 );
println( add() );

Var-args and array expansion

func add_all( *numbers ) {
    numbers.reduce( 0, func( current, ele ) { current + ele; } );
}
println( add_all( 1, 2, 3 ) );
println( add_all( 1, 2, 3, 4 ) );

var arr = [ 1->10 ];
println( add_all( *arr ) );

Inheritance

var Person = {
    initialize: func( name ) {
        this.name = name;
    },
    to_string: func() {
        this.name;
    }
};

# clone person and invoke initialize on the new obj
var buu = Person.create( 'Buu' );
buu.fav_language = "Bike";
buu.to_string = func() {
    this.super( 'to_string' ) + "'s favorite language is " + this.fav_language;
};
println( buu );

.NET Interoperability

var list = System.Collections.ArrayList();
[ 0->9 ].each( func( i ) { list.Add( i ); } );

for ( var e in list ) print( e + ', ' );

0.upto( list.Count, func( i ){println( list[ i ] );} );

Dynamic code evaluation

var code = 'println( "This is cool!" );';
exec( code );
code = '2 * 3;';
println( exec code );
code = 'var person = {name: "John"};';
println( ( exec code ).name );
println( person.name );

There are more interesting features, but I guess that’s enough for you to get a feel of Bike. if/else/while/for/switch/rescue are all available but they are probably not needed much.  Bike also comes with a minimal base class library to work with file system, multithreading, HTTP, JSON, regex, unit test etc.  All these are written in Bike itself (mostly .NET wrapper since it’s fast to implement although pure native implementation would be interesting).

Go to https://github.com/buunguyen/Bike and check out the samples folder for more.  Interested?  Fork and contribute to the language and/or base class library.  Questions, ideas and feedback, please comment or email (see About).  Thanks and happy biking!

C# Training for Microsoft Customers

June 16th, 2011 1 comment

Slides for the C# training I conducted for Microsoft’s customers in Ho Chi Minh city on June 9th 2011. The training covered C# 3.0, LINQ, C# 4.0 and Dynamic Binding.

Some pictures of the training
Me

Me

Me

C# 4.0 Dynamic Binding at BarCamp Saigon 2010

December 13th, 2010 Comments off

I hugely enjoyed BarCamp Saigon 2010 which took place yesterday at RMIT University.  Learned a lot of things and met great people.

Below is the slidedeck I used for my session.  Source code is here.

Overview of C# 4.0

November 13th, 2008 7 comments

Note: This article is also posted at The Code Project. Refer to this link. There are quite interesting discussions going on there.

The .NET framework 4.0 CTP has just been released and I think it’s a good time to explore the new features of C# 4.0. In this post, I will introduce about the following features: dynamic lookup, generics covariance and contravariance support, optional and named parameters.
Read more…

When you learn new things, learn from books

August 19th, 2007 26 comments

I can hardly believe that there is any Java developer who never reads a Java book, or “agile developer” who never reads a book on XP, Scrum… Unfortunately, there are just so many many of those. In fact, many people I know/interview have very fundamental gaps in their knowledge and in most cases I discover that it is partly due to the fact that they never spend time learning things from books. Reasons provided often are: not enough time, internet resources are more than enough etc. In most situations, I don’t think it’s a good mindset to develop software. Read more…

Some basic (but effective) .NET interview questions

April 26th, 2007 50 comments

I’ve been interviewing many .NET development developers lately and one of the most surprising things is that many candidates, both junior and senior level, cannot correctly answer questions which I consider very basic. I compile a short list of such questions below, hopefully it maybe helpful for you as interviewees or interviewers. Read more…

Steve Yegge on the Next Big Language

February 13th, 2007 Comments off

What Steve Yegge considers the Next Big Language.  Sound like

  • Ruby + (Java || C# 1.x/2.0)
  • (JRuby || Groovy || Ruby.NET) + good_tools (esp. IDE)
  • C# 3.0 && dynamic_typing (not just type inference) && more_syntactic_sugar (return multiple values, object-literal syntax for hashmap etc.)

The Code is the Design

February 4th, 2007 13 comments

1. The Code is the Design

At university, most of us are taught that the development of a software should go through the following phases: requirement specification, design, construction (or coding), and testing.  By gathering system requirements (e.g. from the clients, market researches etc.), analysts would come up with a bunch of functional and supplementary requirement documents, use case model and specifications during the requirement specification phase.  Read more…

Design patterns: signs of languages' weaknesses?

January 31st, 2007 8 comments

A nice post by Mark Dominus about design patterns. I include the post here in case the link is modified. You should also read the response by Ralph Johnson and Mark’s follow-up. Read more…