﻿<?xml version="1.0" encoding="utf-8"?><rss version="2.0"><channel><title>Ayende @ Rahien</title><link>http://ayende.com</link><description>Ayende @ Rahien</description><copyright>Copyright (C) Ayende Rahien  2004 - 2021 (c) 2026</copyright><ttl>60</ttl><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>Tundey,
  
random() returns a System.Int32, because that it what you ask it to return.
  
Tools like #Develop knows to display the signature that the compiler will take, so the intellisense angle is covered.
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment16</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment16</guid><pubDate>Wed, 19 Dec 2007 14:52:00 GMT</pubDate></item><item><title>Tundey commented on What makes Boo a great language</title><description>In your example, how do I know what your random() method return? Does it return a random int, double, float, long, duck ? If I don't know the type it returns, how do I know what I can do with it? 
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment15</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment15</guid><pubDate>Wed, 19 Dec 2007 13:55:03 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>Casey,
  
Ruby has a lot of the syntactic niceties, but it is a different model of a language.
  
You don't call methods in ruby, you send messages.
  
This has profound implications on the language design and implementation.
  
  
I'll play with Ruby when it is released, but so far, it feels like I can do more, and more easily, using Boo
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment14</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment14</guid><pubDate>Wed, 19 Dec 2007 11:38:27 GMT</pubDate></item><item><title>Casey commented on What makes Boo a great language</title><description>So ... why Boo and not Ruby?
  
  
Ruby is 'coming' in the DLR and presumably the CLR ... so what advantages does Boo have over Ruby? (the big advantage Ruby has over Boo is widespread usage)
  
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment13</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment13</guid><pubDate>Wed, 19 Dec 2007 10:33:06 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>It is duck typing, sure, but it is a very limited thing.
  
Duck typing on its own doesn't really give you much, the ability to interfer with that is the powerful part.
  
  
I also understand that VB's duck typing is purely reflection based, making it very slow.
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment12</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment12</guid><pubDate>Wed, 19 Dec 2007 05:15:17 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>No, I don't think there are any books on boo out there, but there is plenty of documentation in the site, and there is this:
  
http://mysite.mweb.co.za/residents/sdonovan/boo-book.html
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment11</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment11</guid><pubDate>Wed, 19 Dec 2007 05:08:36 GMT</pubDate></item><item><title>Mats Helander commented on What makes Boo a great language</title><description>Lol, that should have been duck As Object I suppose...my VB Fu getting rusty...;-) /Mats
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment10</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment10</guid><pubDate>Wed, 19 Dec 2007 01:33:35 GMT</pubDate></item><item><title>Mats Helander commented on What makes Boo a great language</title><description>@Ayende
  
  
What's your opinion on VB - it has "always" supported duck typing (well, since VB6 anyway, can't remember much further back than that). 
  
  
Public Sub MyMethod(Object duck)
  
    duck.FirstName = 'Mats" ' The duck must have a FirstName property
  
End Sub
  
  
In fact, all these features that are now suddenly so popular are just the things that allegedly made even VB.NET into a "toy language"...
  
  
/Mats
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment9</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment9</guid><pubDate>Wed, 19 Dec 2007 01:32:15 GMT</pubDate></item><item><title>Jon Skeet commented on What makes Boo a great language</title><description>Right - so the duck typing is always either explicit in the calling code, or by the type you're using implementing IQuackFu (or potentially similar interfaces for other duck typing elements). Broadly right?
  
  
Out of interest, are there any plans for books just on Boo at the moment?
  
  
Jon
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment8</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment8</guid><pubDate>Tue, 18 Dec 2007 23:18:58 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>You can ask the compiler to do something that looks like duck typing if it encounters a method that it doesn't understand.
  
This isn't the same as runtime duck typing.
  
  
If we take this:
  
  
xml = new XmlObject(xmlDocument);
  
print xml.FirstName
  
  
XmlObject implements IQuackFu, which is basically method missing.
  
This code translate to this code, strongly typed:
  
  
xml = new XmlObject(xmlDocument);
  
print xml.QuackGet("FirstName");
  
  
The implementation of QuackGet depends on you, as the interface implementor.
  
In this case it will be something like:
  
  
def QuackGet(string name, args as (object)):
  
     return xmlDoc.SelectSingleNode(name).Value
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment7</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment7</guid><pubDate>Tue, 18 Dec 2007 18:49:06 GMT</pubDate></item><item><title>Jon Skeet commented on What makes Boo a great language</title><description>So is XmlObject always a dynamic object? There's no "as duck" in your earlier sample. With the explicit duck-ness I have no problem with it :)
  
  
I can't say I find myself missing duck typing particularly often, but I can see how it would be very useful occasionally.
  
  
Personally I'm happy with var, but there we go.
  
  
Nice to see Boo has good closure support, although I personally don't like significant whitespace (so at least it's a good job that there's an alternative!)
  
  
Jon
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment6</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment6</guid><pubDate>Tue, 18 Dec 2007 18:39:55 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>Jon,
  
var isn't really enough, not after you have gotten used to what the language can do for you when it is really trying.
  
duck typing is optional, and explicit. Boo is fully statically typed until you ask it to do things dynamically.
  
  
For instance:
  
  
str = "hello"
  
print str.ToUppert() # static call
  
  
d as duck = str
  
print d.ToLower() # dynamic call
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment5</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment5</guid><pubDate>Tue, 18 Dec 2007 18:26:59 GMT</pubDate></item><item><title>Arne Claassen commented on What makes Boo a great language</title><description>I came to C# from years of scripting language coding and automatic variable declaration, so I'll just have to disagree with your assessment that it is far less of a problem in reality. I like var and I like explicit type declaration, but automatic type declaration, while it is wrist-friendly makes for harder to read code. An explicit declaration means the variable appeared at this point in the scope, rather than earlier and this is a re-assignment.
  
  
But that's my personal preference. I like explicit syntax for readability.I admit that means I really need intellisense to not go crazy trying to type everything, but I infinitely prefer it to sparse syntax languages that just mean that I have to memorize more syntax shortcuts, rather than read the code.
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment4</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment4</guid><pubDate>Tue, 18 Dec 2007 16:27:29 GMT</pubDate></item><item><title>Jon Skeet commented on What makes Boo a great language</title><description>It feels like many of these are handled already to a slightly lesser extent with C# 3.
  
  
I've grown to love "var" (when used sensibly) but don't think I like the idea of actual automatic variable declaration.
  
  
Doesn't duck typing make the claim that Boo is statically typed a little less true? I guess the type of the variable is known statically, but expressions are resolved dynamically... it's one of those continuum jobbies rather than a straight "yes/no" answer.
  
  
Don't get me wrong - Boo is somewhere on my list of "languages I'd like to learn" but I think C# 3 has stolen *some* of its thunder.
  
  
Can't wait to actually start using C# 3 for production code...
  
  
Jon
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment3</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment3</guid><pubDate>Tue, 18 Dec 2007 14:45:12 GMT</pubDate></item><item><title>Ayende Rahien commented on What makes Boo a great language</title><description>Damien,
  
Yes, that is what everyone says, but it turns out to be far less of a problem in reality.
  
  
Duck typing is based on the same principals that are used on the DLR, there is a lot of caching and smarts involved in order to make sure that plain reflection is not necessary.
  
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment2</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment2</guid><pubDate>Tue, 18 Dec 2007 10:39:26 GMT</pubDate></item><item><title>Damien Guard commented on What makes Boo a great language</title><description>Automatic variable declaration reminds me too much of Option Explicit-less VBScript where you mistyped a variable name and then spent ages trying to find out why the code didn't quite work as you don't get any errors.  Do you any get warnings during compilation such as variable set but not referenced?
  
  
How does the duck typing work?  Is it reflection-based and potentially a performance hit?
  
  
[)amien
</description><link>http://ayende.com/3053/what-makes-boo-a-great-language#comment1</link><guid>http://ayende.com/3053/what-makes-boo-a-great-language#comment1</guid><pubDate>Tue, 18 Dec 2007 10:28:56 GMT</pubDate></item></channel></rss>