Jon Skeet: Coding Blog - All Comments

re: Noda Time is born

Ben Voigt [C++ MVP] — Fri, 20 Nov 2009 23:17:50 GMT

I suggest doxygen for code documentation. It has the advantage of being comment-compatible with javadoc...

Also I wonder if English-only exceptions isn't the wrong way to handle the search concern. How about numbered exception prefixes (NODA001: February hasn't got 34 days) just like the compiler has? This way the correct search keyword is immediately obvious and not likely to return false positives.

re: Contract classes and nested types within interfaces

Ben Voigt [C++ MVP] — Fri, 20 Nov 2009 22:08:12 GMT

@Alois:

That may be true for interfaces (which can have only public members anyway), but types nested within classes are more than just a naming convention -- they have access to private members of the containing class (given an instance of course for access to non-static members, we're still talking .NET nested classes and not Java inner classes).

Social comments and analytics for this post

uberVU - social comments — Fri, 20 Nov 2009 18:00:41 GMT

This post was mentioned on Twitter by softienews: Jon Skeet's Blog: Where do you benefit from dynamic typing?: Disclaimer: I don't want this.. http://bit.ly/23YUcn

re: Where do you benefit from dynamic typing?

oleksandr petrov — Fri, 20 Nov 2009 17:27:30 GMT

As an example, i need (really often) to have Mix-Ins or multiple inheritance.

For instance, i have a class that describes how my page (or user control) should be rendered. I want it to be extensible.

public class HowToRenderControlA {

public bool ShowThis {get;set;}

public bool ShowThat {get;set;}

}

Then i want to show how to Control B. I create another class.

Then i have a control C, that has lot in common with A and B, and it would be great if i could have those classes all together and their properties accessible.

Or just add a custom something to A or B in some cases.

It's easy implementable in Python, Ruby, Scala, but takes reflection (or Lin-fu, Castle) in c#. And, btw, if i even dared to use lin-fu, i need to call my methods / access properties not thorugh .CallMethod(), but through ("CallMethod", object[] {}). You know what i mean? :)

re: Where do you benefit from dynamic typing?

Stilgar — Fri, 20 Nov 2009 10:30:07 GMT

"If that component is written using dynamic typing, I have to pore over the documentation and unit tests to know what I can expect to pass in and what it should mean. Static typing gives me that information in a much more efficient form, IME."

This is one of the things I had in mind when I pointed out BRUTAL intellisense. I believe it can save enough time to compensate for the additional code you write when using static typing.

I am not really sure whether dynamic typing requires more unit test. I can see it allowing more branches => the need for more tests but I am not sure if this is what happens in practice. My experience with unit testing is limited and I'm ashamed of that :(

re: Where do you benefit from dynamic typing?

skeet — Fri, 20 Nov 2009 10:12:45 GMT

@Stilgar: Thanks for that comment, it's very interesting. I agree with you about untyped environments, although not so much about the UI side of things - even if you don't have *total* type knowledge, you still often know that you have "a control" which will have certain properties etc.

I also disagree about: "If you have unit tests why bother with type safety" - to me the answer is "because it makes it easier to be correct about how I use a component". If that component is written using dynamic typing, I have to pore over the documentation and unit tests to know what I can expect to pass in and what it should mean. Static typing gives me that information in a much more efficient form, IME.

Also, "having unit tests" isn't a binary condition - I've often seen suggestions that dynamic environments require *more* unit tests than static environments. Thus type safety (not quite the same as static typing, of course) reduces the testing burden. You still need unit tests, but potentially fewer.

re: Where do you benefit from dynamic typing?

Stilgar — Fri, 20 Nov 2009 10:02:17 GMT

To me dynamic typing is useful when the domain you are dealing with is itself untyped in nature. As have been pointed out several times in the comments XML (XML-RPC, etc.) is such a domain. If you are dealing with such a domain you need to cast all the time which means that you are practically using dynamic typing because your code can fail at runtime if you did not made the right assumptions when casting.

It seems that especially in web programming people tend to use many untyped representations of the data like XML, HTML, JSON. This is why I believe that JavaScript is so well suited for the web and DOM manipulation in C# (without dynamic) will be much more painful. Also it seems that UI code tends to be untyped. HTML is one example but you can look at WPF or even Win Forms. Usually you have a tree of controls, you don't know the exact type of the control and you need to cast. What is more UI code does not need to be strongly typed that much because usually nothing depends on it so a bug in it will not propagate to any other layers in the application and you are not likely to have unexpected branches of the code.

On the other hand the backend needs to use static typing. It will help with the performance and it will help track all the dependencies when you make a change. Also static typing should not serve as an excuse not to have unit tests (as it happens in my projects :) ) and if you have unit tests why bother with type safety. To me the biggest benefit of static typing is BRUTAL intellisense and refactoring capabilities.

re: Where do you benefit from dynamic typing?

Adam Robinson — Thu, 19 Nov 2009 17:39:40 GMT

"Those sorts of things are more a failure of PHP than of dynamic typing"

But is the concept *truly* separable from the language? In the end, we're talking about the way that the compiler (or interpreter) handles the code. By some standards, VB.NET supports "dynamic typing" with Option Strict off. Clearly its reflective late binding is...um...less than performant, but the concept of not having a clear inheritance hierarchy (that's visible at that point in the code, anyway) to prove or disprove the existence of a type member is still there.

re: OMG Ponies!!! (Aka Humanity: Epic Fail)

pbean — Thu, 19 Nov 2009 10:24:02 GMT

Brilliant! I wish I could have been there!

And here I always thought I was a bad programming for having difficulty with timezones.

re: Where do you benefit from dynamic typing?

[ICR] — Thu, 19 Nov 2009 00:35:29 GMT

"A number get interpreted as a string when it shouldn't"

Those sorts of things are more a failure of PHP than of dynamic typing. PHP does very odd things and likes to interpret too many things as strings.

Whilst not strictly relevant, www.pphsg.org/.../types.html is an interesting read.

To me the benefit of dynamic in C# is that it provides a uniform way of doing what we already do a dozen different ways -- communicate with IronPython, XML, JSON, web services etc.

re: Just how spiky is your traffic?

skeet — Wed, 18 Nov 2009 16:47:46 GMT

@Chris S: It depends on the service, really :) Of course the scale of things also depends on what you're *doing* in each request, which is basically a more general way of saying the same thing: not all requests are equal.

re: Just how spiky is your traffic?

Chris S — Wed, 18 Nov 2009 16:39:43 GMT

@Jon - does a QPS just count as a single page request, while a hit includes all page resources?

1m hits a month might include images, javascript files in which case .NET is being used even less than once every two seconds.

10,000 page views a month is a big site in world :[

re: Where do you benefit from dynamic typing?

Jason Baker — Wed, 18 Nov 2009 14:03:45 GMT

@skeet - Yeah, but you're Jon Skeet. :-)

In all seriousness though, I'm a bit of a newb when it comes to typing in Java/C# and I seem to have issues with typing in C#. Although I'm sure I can get around this issue with some experience, that at least makes dynamic typing more approachable.

I suppose what it ultimately boils down to is reduced complexity. Interfaces? Don't need 'em. XML schemas for XML-RPC calls? Don' t need 'em. True, none of these add a huge amount of complexity, but my experience is that programming is ultimately more a game of hiding a bunch of little details more than it is about fighting huge complexity issues.

The biggest benefit is that with dynamic typing, I don't usually think about types. If I name something people, then I think of it as representing people. Type inferencing is a two-edged sword for this problem. The majority of the time, I don't have problems. But when I do something wrong, it can be difficult to figure out exactly what went wrong because all of the type information is obscured. With dynamic typing I can at least hit it with a debugger when I get typing issues.

Lastly, I don't disagree with you regarding the benefits of static typing. The difference is that now you're thinking in terms of pros and cons of *both* static and dynamic typing. By reading just the blog post, it comes off as though you're only thinking about the pros and cons of dynamic typing. It's difficult to do a comparison when you're only thinking about one side of the story. :-)

re: Where do you benefit from dynamic typing?

Oliver Clothesoff — Wed, 18 Nov 2009 05:48:21 GMT

(1) It is easier to write higher-order code with dynamic types. For example, I have a set of operations that each use different subsets of the methods on interface A. If I just want to use one operation on my new type, I have to implement all methods on A even though it's not necessary. With dynamic types, you just use the operation and hope it works.

(2) In rapid prototyping, one can make changes quickly without having to update type signatures everywhere. Type inference reduces this burden in ML, but C#/Java is still a pain.

Dynamic types are too dangerous, but C# is too verbose. The right balance is static typeing with type inference.

re: Where do you benefit from dynamic typing?

Bare Grills — Tue, 17 Nov 2009 21:57:34 GMT

I have been waiting for dynamic for some time to fill the IDispatch void.

I am building .net components on a c++ plugin framework and some of the event driven subscriptions fail due to lack of IDispatch support.

with .Net 4.0 I should be able to easily register a derived dynamicobject type.

re: Where do you benefit from dynamic typing?

skeet — Tue, 17 Nov 2009 21:07:32 GMT

@Matthew: dynamic is only to do with dynamic typing, but there's more to dynamic typing than duck typing. I'll have a look at the swizzle stuff later on :)

re: Where do you benefit from dynamic typing?

Matthew Scharley — Tue, 17 Nov 2009 20:55:13 GMT

I see C#'s dynamic keyword as so much more than just dynamic (duck) typing. There's a whole world of fun stuff to do with DynamicObject.

For instance, someone asked about an equivalent to HLSL swizzles in C#. Now, these don't use duck typing, infact it's very clear at compile time by examination of the code exactly what types are being thrown around (even though the compiler can't because it's using the dynamic keyword)

For an explanation of the code I wrote and some usage, you can see matt.scharley.me/.../swizzle or for direct download of the code, matt.scharley.me/.../24

re: Where do you benefit from dynamic typing?

skeet — Tue, 17 Nov 2009 20:23:06 GMT

@Alan: I don't see much in there about dynamic typing specifically. (I'm also somewhat bemused by the line "You'd never see a Java program that was configured by writing Java code" - someone hasn't used Guice...)

It seems mostly to be about trying to avoid writing Ruby with a Java accent, which is all very well but it doesn't give me much idea of why dynamic typing is a good thing.

re: Where do you benefit from dynamic typing?

maht — Tue, 17 Nov 2009 20:04:05 GMT

"17.3" * 3

re: Where do you benefit from dynamic typing?

Alan Hecht — Tue, 17 Nov 2009 20:02:44 GMT

@Max C

Here's a good Rubyist perspective on dynamic vs. static typing:

weblog.jamisbuck.org/.../legos-play-doh-and-programming

It's about Ruby vs. Java, but I think what's said is applicable to this discussion. Jamis prefers Ruby, and I think he does a fair job of comparing Ruby & Java development techniques.