The languages discussed in this special issue have a long history, which is perhaps why some have had several different names over the years. One such language is Lisp, the second-oldest programming language. For years, many somewhat dismissively described languages such as Lisp as "scripting languages." Today, we more commonly refer to them as dynamically typed languages, typified by Python and Ruby, and their impact is arguably greater than ever. This issue highlights the practical uses of such languages and shows how they're frequently a vehicle for innovation in the development sphere. This article is part of a special issue on dynamically typed languages

Tratt, L.

Wuyts, R.

English

Middlesex University Research Repository

2 8 I E E E  S O F T W A R E P u b l i s h e d  b y  t h e  I E E E  C o m p u t e r  S o c i e t y 0 7 4 0 - 7 4 5 9 / 0 7 / $ 2 5 . 0 0  ©  2 0 0 7  I E E Epractical uses of such languages and shows howthey’re frequently a vehicle for innovation inthe development sphere.What is a dynamically typedlanguage?Simply put, a dynamically typed languagedoesn’t require the user to statically specifytypes—for example, no declarations of int i,and so on. However, this doesn’t mean thatsuch languages are weakly typed. If, for exam-ple, a user tries to add a string to a bool at run-time, an error will immediately be raised. Stati-cally typed languages enforce the declarationsof (at least a minimum of) types and notify theuser at compile time of type-related errors thatmust be fixed. Shades of gray also exist betweenthe two extremes: many statically typed lan-guages defer certain checks to runtime, whiledynamically typed languages often performsome checks statically to warn users.Many people familiar with statically typedlanguages such as Java or C wonder if those whouse dynamically typed languages are too lazy todeclare types. Furthermore, they assume that notdeclaring types will decrease the software’s qual-ity: “Imagine how many runtime errors will re-sult!” Not surprisingly, they view “prototyping”or “scripting” languages as suitable only for verysmall or toy programs. However, if these lan-guages are so limited, why do leading companiessuch as Google publicly proclaim the benefits oflarge systems written in such languages? Thereare two answers to this question.First, current static type systems in main-stream object-oriented languages have little ex-pressive power. For example, although theyprevent users from adding a string to a bool,they don’t prevent them from accessing the firstelement of an empty list, creating off-by-one er-rors, or using null pointers. In fact, static typesystems can’t detect most common program-ming errors. Yet for such systems to work, de-velopers must spoon-feed (and sometimesstrong-arm) the types at development time sothat the type system—which is in essence a sep-arate system from the main language—knowswhat the code is really doing.The waters are muddied further becauseeven very simple approaches to testing capturefocus 1Dynamically Typed LanguagesThe languages discussed in this special issue have a long history,which is perhaps why some have had several different names overthe years. One such language is Lisp, the second-oldest program-ming language. For years, many somewhat dismissively describedlanguages such as Lisp as “scripting languages.” Today, we more commonlyrefer to them as dynamically typed languages, typified by Python and Ruby,and their impact is arguably greater than ever. This issue highlights theguest editors’ introductionLaurence Tratt, Bournemouth UniversityRoel Wuyts, IMECAuthorized licensed use limited to: MIDDLESEX UNIVERSITY. Downloaded on May 27,2010 at 08:12:48 UTC from IEEE Xplore.  Restrictions apply. virtually all, if not all, the errors that a statictype system would capture. Plus, as many of usunfortunately know, even extensive testing hasa hard job identifying off-by-one errors. DonRoberts formulated it perfectly at OOPSLA2005: “Static types give me the same feeling ofsafety as the announcement that my seat cush-ion can be used as a floatation device” (see http://martinfowler.com/bliki/OOPSLA2005.html). Second, static type systems—as their namesuggests—implicitly constrain the programmerat both compile time and runtime. In otherwords, static type systems tend to ossify pro-grams, making them less flexible, more difficultto work with, and less amenable to change.When a user wants to modify one aspect of a sys-tem, that system’s types could force numerousrewrites in unrelated parts of the system. (Thinkabout all the problems for subclasses once over-loading comes into the picture.) These rewritescan seriously inhibit any system experimenta-tion. In an age where we strive for reusable soft-ware, and where software must adapt quickly toexternal changes, programming languages thatreduce agility can be a significant disadvantage.However, this issue doesn’t aim to be one-sided zealotry for dynamically typed languages.Sometimes, users will pay whatever it costs (intime or money) for extra software reliability,such as when requesting software for a nuclearpower plant or an airplane’s autopilot function.So static type systems have their part to play, butthey’re by no means the only option. As in mostareas of life, the majority of software needs tobalance various factors, and in many cases theadvantages of dynamically typed languagescome to the fore. Rapid application develop-ment, with its emphasis on quickly producing in-cremental results, showcases this in many areas.A distinguished historyPeople often say of the Velvet Undergroundthat although they didn’t sell many records,every person who bought one of their recordsstarted a band. Two dynamically typed lan-guages deserve a similar epithet: Lisp andSmalltalk. While neither ever quite gainedmainstream success, both had a huge influenceon later languages—including many staticallytyped languages—and both are still used to-day. They’re an important part of the long anddistinguished history of dynamically typedlanguages.Lisp was the source of many programming-language firsts, such as automatic memorymanagement. It’s the ancestor of all extantfunctional languages, although, interestingly,most of its descendants are statically typedlanguages. One notable exception is Scheme, avery clean Lisp dialect with a sophisticatedmacro mechanism and module system. Smalltalk is a purely object-oriented lan-guage that pioneered the bytecode virtual ma-chine and graphical integrated developmentenvironments, long before C++ or Java werethought of. It inspired prototype-based (class-less) languages, notably Self, a language whosemany advances in VM technology we nowtake for granted via Java and.NET. An excellent example of a highly performantdynamically typed language is Lua. This smallbut powerful language is extremely well suited tobeing embedded into existing systems, as shownin the article “Traveling Light, the Lua Way.”However, for many years, dynamicallytyped languages were viewed as slow, unreli-able, and suitable only for small throw-awaytasks. Although a handful of people used dy-namically typed languages for complex sys-tems—such as the banks that embracedSmalltalk in the beginning of the ’80s—it wasgenerally felt that “real” programmers usedstatically typed languages. As with many other areas of computing, theemergence of the Web changed things. Creat-ing dynamic Web pages in languages such as Cwas painful, and the dynamically typed lan-guage Perl quickly became synonymous withWeb systems. However, Perl’s origins in sys-tems administration software—where small,inscrutable solutions were often the order ofthe day—prevented wider scale adoption. In the late ’90s, the object-oriented languagePython—in many ways, a more traditional lan-guage than Perl—came to the fore as a dynami-cally typed language suitable for both small andlarge systems. Python continues to be used in avariety of applications. The article “A CommonMedium for Programming Operations-ResearchModels” shows how to apply Python to do-mains traditionally dominated by staticallytyped languages. Today, languages such as Rubycontinue to emerge and prove themselves usefulin new spheres.The presentFor some time, the scarce resource when de-veloping software hasn’t been hardware butS e p t e m b e r / O c t o b e r  2 0 0 7 I E E E  S O F T W A R E 2 9Lisp andSmalltalk arean importantpart of the long anddistinguishedhistory ofdynamicallytyped languages.Authorized licensed use limited to: MIDDLESEX UNIVERSITY. Downloaded on May 27,2010 at 08:12:48 UTC from IEEE Xplore.  Restrictions apply. rather developer time. With hardware develop-ment continuing to follow, and sometimes sur-pass, Moore’s law, execution performance ormemory consumption are no longer the majorbottlenecks for most applications (excludingembedded systems or very large applicationservers). This removes what many people con-sider dynamically typed languages’ major obsta-cle—performance. Although this perception hasoften been at odds with reality (in several appli-cations, CLOS runs nearly as fast as C, and pro-duction Smalltalk systems have execution speedscomparable to Java), in the modern world, per-formance is generally irrelevant. Most applica-tions running on a modern desktop computerare fast enough, no matter what language wasused to write them. So, a chief benefit of dynam-ically typed languages is significantly reduced de-velopment time.A fundamental property of dynamicallytyped languages is their flexibility, and fromthe earliest days of Lisp, developers have usedthis property to turn the languages into do-main-specific languages. Of course, you canimplement DSLs in statically typed languages,but the complex syntax and semantics thatgenerally accompany static type systems makethis a more arduous task. DSLs in such lan-guages often resort to a parser or XML/XSLT-based approach, which defines a custom syn-tax and translates it into another language.Needless to say, developing such systems isn’tfor the faint of heart. Building a DSL in a dynamically typed lan-guage is far easier, as shown in “Building Do-main-Specific Languages for Model-DrivenDevelopment.” The article also highlights thatstatically typed systems (such as modelingsoftware) are often implemented in dynami-cally typed languages. Because the syntax ofmost dynamically typed languages is quitesmall and flexible, we can often forget parserand transformation approaches altogether.The resulting DSL is therefore more maintain-able and amenable to evolution, better fittingthe domain users’ ever-changing needs.Last, but certainly not least, we return to thedevelopment of Web applications. Even thoughscripting languages unlocked Web develop-ment’s potential for many users, application de-velopment on the Web is still much more chal-lenging than traditional approaches. Simple userfeatures such as the browser back button canwreak havoc on age-old programming models.The article “Seaside: A Flexible Environment forBuilding Web Applications” shows how to com-bine the functional programming concept ofcontinuations with pure object-oriented princi-ples to make developing sophisticated Web ap-plications as easy as developing desktop appli-cations. In addition to solving “old” problems, dy-namically typed languages are also playingtheir trump cards of easy use and deploymentto help develop Web 2.0 or the Semantic Web.“A Flexible Integration Framework for Se-mantic Web 2.0 Applications” discusses thebenefits of dynamically typed languages in thisdomain.Looking forwardThe outlook for dynamically typed lan-guages is better than ever before. Industrialuptake is increasingly rapid—for example, thefinancial sector is using dynamically typed lan-guages in critical systems such as JPMorgan’sKapital system. Supporting new types ofbonds and funds faster than your competitorsresults in multibillion-dollar gains. Politicalbarriers to use are also diminishing. Innovation in the dynamically typed lan-guages sphere remains strong—for example,advances in languages for distributed, concur-rent, or parallel programming. We also expectnew, beneficial features to continue to emergeand to gradually trickle down to the moreconservative statically typed languages. Wehope that this special issue gives you a flavorof not only how dynamically typed languagescan help you and your organization today, buthow they might drive future innovation.3 0 I E E E  S O F T W A R E w w w. c o m p u t e r. o r g / s o f t w a r eAbout the AuthorsLaurence Tratt is a senior lecturer at Bournemouth University and is a software con-sultant. He’s also the chief designer and implementer of the Converge programming language.His research interests include modeling (UML and MDD)—he has contributed to several inter-national standards—and domain specific languages. He received his PhD from King’s CollegeLondon. He’s a member of the IEEE Software Advisory Board. Contact him at laurie@tratt.net;http://tratt.net/laurie.Roel Wuyts is a senior scientist at IMEC (Leuven, Belgium) and a part-time professor atKU Leuven. His research interests include declarative metaprogramming, language symbiosis,components and composition, and development environments. He’s especially interested in dy-namic languages—primarily Smalltalk, Prolog, Self, and Scheme. He received his PhD fromthe Programming Technology Lab at the Vrije Universteit Brussel. Contact him at IMEC, Kapel-dreef 75, B-3001 Leuven, Belgium; roel.wuyts@imec.be.Authorized licensed use limited to: MIDDLESEX UNIVERSITY. Downloaded on May 27,2010 at 08:12:48 UTC from IEEE Xplore.  Restrictions apply. 

Introduction [Dynamically typed languages: special ed.]

https://repository.mdx.ac.uk/download/395ddf81c65ee6b1bb46163858bbf0d86895eb4f8dc46d25ee0b860bd5d43c1f/271419/Tratt-dynamically_typed_languages.pdf

Introduction [Dynamically typed languages: special ed.]

Abstract

Similar works

Full text

Available Versions

Middlesex University Research Repository