Comments on: Ruby is dynamically AND strongly typed http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/ Because programming should be fun Thu, 15 Jul 2010 19:48:22 +0000 http://wordpress.org/?v=2.9.2 hourly 1 By: Dynamic, static, weak and strong in languages « Altug Sahin's Blog http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-1022 Dynamic, static, weak and strong in languages « Altug Sahin's Blog Thu, 15 Jul 2010 19:48:22 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-1022 [...] came across this interesting post. Here is the [...] [...] came across this interesting post. Here is the [...]

]]> By: Frank http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-864 Frank Tue, 15 Sep 2009 04:26:07 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-864 Dilruk, in your example dynamic/static doesn't apply. It's the Strong/Weak aspect of typing that is affected. In ruby, your example would throw out an exception. In a weakly typed language, it would try to mix the two types... In most cases I guess it would give something like "This is a number7" Thanks for your comments everyone (I'm just 2 years late) ! Dilruk,

in your example dynamic/static doesn’t apply. It’s the Strong/Weak aspect of typing that is affected. In ruby, your example would throw out an exception. In a weakly typed language, it would try to mix the two types… In most cases I guess it would give something like “This is a number7″

Thanks for your comments everyone (I’m just 2 years late) !

]]> By: Dilruk http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-826 Dilruk Tue, 24 Feb 2009 21:45:55 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-826 A = "This is a number" What would be the result for A = A + 7 in a Dynamically typed language? A = “This is a number”
What would be the result for A = A + 7 in a Dynamically typed language?

]]> By: txt » Dynamic/Static/Strong/Weak Types http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-308 txt » Dynamic/Static/Strong/Weak Types Wed, 25 Jul 2007 18:16:17 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-308 [...] Original Article [...] [...] Original Article [...]

]]> By: Shadowfiend http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-305 Shadowfiend Sat, 14 Jul 2007 23:34:41 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-305 But that's often what's meant with weak. Weak means that there is a weak distinction between the types (more or less). In C, that's particularly evident because you get virtually no distinction between pointer types -- they're all integers at the end of the day, and you can do whatever you want with them. Casting lets you achieve just about anything, with no checking until you get a segfault in your running program :) But that’s often what’s meant with weak. Weak means that there is a weak distinction between the types (more or less). In C, that’s particularly evident because you get virtually no distinction between pointer types — they’re all integers at the end of the day, and you can do whatever you want with them. Casting lets you achieve just about anything, with no checking until you get a segfault in your running program :)

]]> By: Matt Giuca http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-304 Matt Giuca Fri, 13 Jul 2007 16:35:16 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-304 So from some of these comments (the guy who overloaded Ruby + and the guy who said C is weakly typed) - it seems like we can classify strong/weak as being a property of the OPERATORS themselves, not the type system! (For the most part). I wouldn't classify C as having a particularly weak type system. It lets you implicitly cast numbers around (eg. (int)3 + (float)4.7 => (float)7.7), but that's about it. For instance, C won't let you go "3" + 4 and give you 7 - which a truly "weak" type system will give you. Oh no, C is far worse - it isn't _weak_, it's _unsafe_! The 3rd classification after dynamic/static and weak/strong is safe/unsafe. In C if you do "3" + 4, you get ... a pointer 3 bytes past the end of the string! This is usually unacceptable in modern languages so it doesn't happen in most. But just a point, I wouldn't consider that "weakness". Sorry for getting off-topic. Oh, a very good article though! So from some of these comments (the guy who overloaded Ruby + and the guy who said C is weakly typed) – it seems like we can classify strong/weak as being a property of the OPERATORS themselves, not the type system! (For the most part).

I wouldn’t classify C as having a particularly weak type system. It lets you implicitly cast numbers around (eg. (int)3 + (float)4.7 => (float)7.7), but that’s about it. For instance, C won’t let you go “3″ + 4 and give you 7 – which a truly “weak” type system will give you.

Oh no, C is far worse – it isn’t _weak_, it’s _unsafe_! The 3rd classification after dynamic/static and weak/strong is safe/unsafe. In C if you do “3″ + 4, you get … a pointer 3 bytes past the end of the string! This is usually unacceptable in modern languages so it doesn’t happen in most. But just a point, I wouldn’t consider that “weakness”.

Sorry for getting off-topic. Oh, a very good article though!

]]> By: Shadowfiend http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-303 Shadowfiend Fri, 13 Jul 2007 13:59:17 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-303 @yriafelc -- yes, but in that situation, you've changed the `unmentioned' semantics of +to_str+ -- namely, that an object that has that method is, for all intents and purposes, a string, while +to_s+ means that it can be represented as one. Personally, I think String#+ should use +to_s+ rather than +to_str+. But then again, that's what string interpolation is for, so whatever. @yriafelc — yes, but in that situation, you’ve changed the `unmentioned’ semantics of +to_str+ — namely, that an object that has that method is, for all intents and purposes, a string, while +to_s+ means that it can be represented as one. Personally, I think String#+ should use +to_s+ rather than +to_str+. But then again, that’s what string interpolation is for, so whatever.

]]> By: jman http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-302 jman Fri, 13 Jul 2007 12:54:59 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-302 Excellent explanation of a easily misunderstood concept! Excellent explanation of a easily misunderstood concept!

]]> By: Stephan Schmidt http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-301 Stephan Schmidt Fri, 13 Jul 2007 08:27:25 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-301 Most of those discussions are wrong. The key concept to grasp in strong versus weak typing is that there is a distinction between reference typing and object typing. Java has static typed references and static typed objects. Person me = new Person("me") Both the reference and the object are static typed. People usually call this strong typing. me = Person.new Here the reference is dynamic typed and the object is static typed (although in Ruby objects can change their appearance during run-time). Dynamic typed references with static typed objects people usually call weakly typed. Groovy is makes the distinction more difficult. It support both dynamic and static references, just as needed. def me = new Person("me") and Person me = new Person("me") are both legal Groovy code. The first with dynamic typed references and the second with a static typed reference. I've written extensivly about the distinction more than <a href="http://stephan.reposita.org/archives/2006/03/29/weak-versus-strong-languages-who-wins-the-fight/ ">a year ago</a>. Peace -stephan -- Stephan Schmidt :: stephan@reposita.org Reposita Open Source - Monitor your software development http://www.reposita.org Blog at http://stephan.reposita.org - No signal. No noise. Most of those discussions are wrong.

The key concept to grasp in strong versus weak typing is that there is a distinction between reference typing and object typing. Java has static typed references and static typed objects.

Person me = new Person(“me”)

Both the reference and the object are static typed. People usually call this strong typing.

me = Person.new

Here the reference is dynamic typed and the object is static typed (although in Ruby objects can change their appearance during run-time). Dynamic typed references with static typed objects people usually call weakly typed.

Groovy is makes the distinction more difficult. It support both dynamic and static references, just as needed.

def me = new Person(“me”)

and

Person me = new Person(“me”)

are both legal Groovy code. The first with dynamic typed references and the second with a static typed reference.

I’ve written extensivly about the distinction more than a year ago.

Peace
-stephan

–
Stephan Schmidt :: stephan@reposita.org
Reposita Open Source – Monitor your software development
http://www.reposita.org
Blog at http://stephan.reposita.org – No signal. No noise.

]]> By: yriafelc http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/comment-page-1/#comment-299 yriafelc Thu, 12 Jul 2007 13:10:36 +0000 http://www.rubyfleebie.com/ruby-is-dynamically-and-strongly-typed/#comment-299 x = '3' x = x + 3 # Error! but: Class Fixnum def to_str self.to_s end end x = '3' x = x + 3 # x = '33' x = ‘3′
x = x + 3 # Error!

but:

Class Fixnum
def to_str
self.to_s
end
end

x = ‘3′
x = x + 3 # x = ‘33′

]]>