Skip to: Site menu | Main content

Home Print

Boo is a new object oriented statically typed programming language for the Common Language Infrastructure with a python inspired syntax and a special focus on language and compiler extensibility.

If you want to try boo, read the Getting Started guide. To dive deeper, follow the link to the Wiki pages.

News

Last changed Sep 01, 2009 23:59 by Cedric Vivier

You read it right and it was about time!

Boo 0.9.2 is mostly a maintainance release, yet it introduces a few new features worth highlighting :

  • Unsafe code support including pointer manipulation for richer interoperability with native code [BOO-1202]
    unsafe ptr as long = astruct:
        *ptr = 0
        ++ptr
    
  • Generic array/matrix constructors [BOO-1203]
    a = array[of int](3)        #creates an array of 3 ints
    m = matrix[of int,int](3,3) #creates a 3x3 int matrix
    
  • Literal regular expression options [BOO-1237]
    /boo/i.IsMatch("BOO") #case-insensitive match
    
  • Boo now runs on medium-trust environments [BOO-1215] (such as Mosso ASP.NET platform)

On top of the usual bunch of bug fixes (see the ChangeLog), this release significantly improves generated IL, resulting in up to 40% leaner assemblies among other performance improvements.

Contributed to this release: Cedric Vivier, Daniel Grunwald, Dmitry Malyshev, Greg Nagel, Joao Braganca, Martinho Fernandes, Paul Lange and Rodrigo B. De Oliveira.

Download it an have fun!

Posted at Sep 01, 2009 by Cedric Vivier | 1 comment
Last changed Mar 18, 2009 12:32 by Cedric Vivier

Just after two months of the huge 0.9 release, here is Boo 0.9.1 - bringing more new features and bug fixes.

Highlights of this release are:

  • Macro definition arguments [BOO-1146] - macro definitions can define typed arguments as with any method definition.
    macro repeatLines(repeatCount as int, lines as string*):
        for line in lines:
            for i in range(repeatCount):
                print line
    
    repeatLines 2, "boo", "rocks"
    
  • Nested macros extensions [BOO-1140] - nested macros no longer have to be defined within their parent macro block.
    macro parent:
        yield
    
    macro parent.child:
        yield [| print "parent.child" |]
    
    parent:
        child
    
  • Omitted expression for member references [BOO-1150] - `.foo' is now equivalent to `self.foo' by default. This behavior can easily be changed by a macro or compiler step.
    macro with(target, body as Expression*):
        for expression in body:
            match expression:
                case BinaryExpression(Left: mre = MemberReferenceExpression(Target: OmittedExpression())):
                    mre.Target = target
                    yield
    
    with System.Threading.Thread.CurrentThread:
        .CurrentCulture = CultureInfo.InvariantCulture
        .CurrentUICulture = CultureInfo.InvariantCulture
    
  • Volatile fields [BOO-806]
    class Threaded:
        [volatile] foo as int
    
  • TypeSystem refactoring - brings cleaner API and faster compilation (-30% time)

Take note that from now on strong versioning is used on Boo releases, this release assemblies are versioned `2.0.9.1'.

Contributors to this release: Cedric Vivier, Daniel Grunwald, JB Evain, Rodrigo B. De Oliveira.

Read the changelog for the complete list of improvements.

Download it now and have fun!

Posted at Mar 18, 2009 by Cedric Vivier | 0 comments
Last changed Jan 27, 2009 11:29 by Cedric Vivier

It's been a long time but the biggest release ever of Boo is right here now!

Huge improvements all over the board as you can read in the full changelog, its chief weapons are:

  • Generator macros [BOO-1077] - macros are no longer limited to returning a single statement or block and instead are able to yield an indefinite number of nodes:
  • Nestable macros [BOO-1120] - macro definitions can be nested to allow for context sensitive keywords
  • Type member macros [BOO-415] - macros can be used in class definition bodies
  • Pattern matching [BOO-1106] - simple but powerful object pattern matching with the match/case/otherwise macros
  • Support for generic extension methods [BOO-937] - LINQ style extension methods
  • Generic parameter constraints [BOO-935] and Generic parameter type inference [BOO-1102]
  • Strict mode [BOO-1115] - strict mode changes a few compiler rules: default visibility for members is private, method parameter types and return types must be explicitly declared, among other things
  • Asymmetric property accessor visibility [BOO-1094]
  • String interpolation formatting (eg. "0x${n:x4}") [BOO-1006]
  • Support for SilverLight profile [BOO-1117] - and Vladimir Lazunin kicked it off with a Tetris example.

You can read examples on these 0.9 new features on Rodrigo's blog.

This release is brought to you by Avishay Lavie, Cedric Vivier, Daniel Grunwald, Marcus Griep and Rodrigo B. De Oliveira.

Download it now and have fun!

Join the mailing-list for questions and latest updates about Boo development.

Posted at Jan 27, 2009 by Cedric Vivier | 0 comments

Bamboo would like to thank

  • Georges Benatti who always believed the idea, thanks man!
  • Carlinhos for always being there
  • cv for being so enthusiastic and introducing the project to the hausmates
  • the hausmates for such a warm welcome and the great infrastructure
  • Terence Parr for the great ANTLR tool along with all the people who hang on the ANTLR group
  • The guys from the Mono Brasil project
  • Guido van Rossum for coming up with such a great language that eventually served me as inspiration to start this project
  • The one who supported me all the way through this last 10 years: I love you, Ma!