Will we only create and use dynamic languages in the future?

Since I’ve playing with some dynamic languages (Ruby and Clojure), I have been thinking about why would anybody create a new static typed language?! And I didn’t get the answer.

I started programming in Visual Basic and I taste its roots, which are almost all full of procedure commands (bunch of do, goto and end), then I moved to C#, sharper it changes the end’s for }’s and give us a little more power based on some premises: we can treat two different things in the same way, polymorphism. The last static language, but not the least, I used (and I use it) Java, abusing of his new way of treating a set of things equality, the interfaces and using its “powers” on reflections.

Although when I started to use Ruby I saw that I could treat a group of things equality without doing any extra work. I still need to code models and composed types, even though we can create or change them dynamically using “real power” of metaprogramming.

When I start to study and apply the Clojure and its principles, my first reaction was the rejection, how can I go on without my formal objects, how can I design software without a model in the head and so on. I wasn’t thinking about how actually I do software, currently I use TDD to design software and I don’t think what models I need to have, I do think in terms of “what I want”. At minimum, Clojure make me think about, do we really need object to design software?! .  A three days ago I saw an amazing video about similar thoughts: Some thoughts on Ruby after 18 months of Clojure.

Summarising: With my limited knowledge of theses languages, let’s suppose we use a function (which we don’t have source code) and we want to do something before that function is executed (intercept) using: VB I’ll need to check every single piece of code which we call this function and call another one, in Java we can use a AOP framework, in Ruby we can use the spells of metaprogramming. It seems that some frameworks, patterns and extra work aren’t needed more because of this dynamic language evolution.

My conclusions using dynamic languages (Clojure/Ruby) for now it’s: I write less code and reuse them more easy, so I don’t see any reason to create/use a new static typed language, would you see any motivation to do that?

PS: When I use C# (.Net Framework 1.3 – 2.0) it was not so super cool as today.

Advertisements

4 thoughts on “Will we only create and use dynamic languages in the future?

  1. The arguments for Static and Dynamic typing are at least as old as Lisp, so over 50 years for now. Clojure and Ruby are just new implementations of an old concept.

    The advantages of static typing include, obviously, safety: they give you an extra layer of tests that ensure at compile time that your values (objects or not) are being used correctly. Whether that’s really that useful depends on the application – certainly more critical software can use all the verification possible.

    But I think you should hold your judgment until you’ve used languages besides early C#/Java which are criticized even by static typing fans.

    Type inference, structural typing, static duck typing are features of type systems present in other languages (Haskell, OCaml, etc).

    Personally, I like Go: it gives you the ‘feel’ of a dynamic language while ensure plenty of static safety.

    • When I was writting the post I wasn’t think only about Static vs Dynamic and for sure they’re old concepts.

      Yeah I didn’t taste (for real production code) any other static typed language ;( so my judgment it’s limited to C# and Java.

      In fact, now I counted that I used more dynamic languages than static.

      I coded some playground apps using Scala and Haskell and my feeling weren’t very fine, maybe I didn’t get the required experience or give them the needed time, like I did with Clojure.

      Anyway, thanks I’ll give a look on golang. 😉

  2. Nice thoughts. Interesting that just this week José Valim tweeted something regarding how OO is universally sold as a good thing. Not necessarily. I think computer languages are starting to reach its YOUTH on its way to a more MATURE state.

    I’ve been playing recently with Ruby and Javascript (NodeJS), and each day more I more tedious of working with Java.

    Interesting discussion.

  3. There will always be a reason to invent a new language, whether it is needed or not. It is odd that C became the lower-level language for the Linux kernel, when Bliss http://en.wikipedia.org/wiki/BLISS — about the same age — had a lot more built into it to account for machine architecture. In C’s case, massive use probably ensured its continued life.

    I believe object-oriented design and programming specifically around C++ became mis-used, despite the warnings from the luminaries who were writing books and training, when C++ first came out.

    I think some of the concepts are getting out of hand, like object functional programming.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s