A PROGRAMMING LANGUAGE TO FACILITATE THE TRANSITION FROM RAPID PROTOTYPING TO EFFICIENT SOFTWARE PRODUCTION

Francisco Ortin, Daniel Zapico, Miguel Garcia

Abstract

Dynamic languages are becoming increasingly popular for developing different kinds of applications, being rapid prototyping one of the scenarios where they are widely used. The dynamism offered by dynamic languages is, however, counteracted by two main limitations: no early type error detection and fewer opportunities for compiler optimizations. To obtain the benefits of both dynamically and statically typed languages, we have designed the StaDyn programming language to provide both approaches. Our language implementation keeps gathering type information at compile time, even when dynamic references are used. This type information is used to offer compile-time type error detection, direct interoperation between static and dynamic code, and better runtime performance. Following the Separation of Concerns principle, dynamically typed references can be easily turned into statically typed ones without changing the application source code, facilitating the transition from rapid prototyping to efficient software production. This paper describes the key techniques used in the implementation of StaDyn to obtain these benefits.

References

  1. Abadi, M., Cardelli, L., Pierce, B., and Plotkin, G. (1991). Dynamic typing in a statically typed language. ACM Transactions on Programming Languages and Systems, 13(2):237-268.
  2. Abadi, M., Cardelli, L., Pierce, B., Rémy, D., and Taylor, R. W. (1994). Dynamic typing in polymorphic languages. Journal of Functional Programming, 5:92- 103.
  3. Appel, A. (1998). Modern Compiler Implementation in ML. Cambridge University Press.
  4. Bracha, G. (2004). Pluggable type systems. In OOPSLA workshop on revival of dynamic languages.
  5. Bracha, G. and Griswold, D. (1993). Strongtalk: Typechecking Smalltalk in a production environment. In Proceedings of the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), pages 215-230, New York, NY, USA. ACM.
  6. Canning, P., Cook, W., Hill, W., Olthoff, W., and Mitchell, J. (1989). F-bounded polymorphism for objectoriented programming. In Press, A., editor, Proceedings of the fourth international conference on Functional programming languages and computer architecture, pages 273-280.
  7. Cardelli, L. (1988). Basic polymorphic typechecking. Science of Computer Programming, (8):147-172.
  8. Cartwright, R. and Fagan, M. (1991). Soft Typing. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI 7891), pages 278-292.
  9. Codehaus Foundation (2006). Boo, a wrist friendly language for the CLI. http://boo.codehaus.org.
  10. Cytron, R., Ferrante, J., Rosen, B. K., Wegman, M. N., and Zadeck, F. K. (1991). Efficiently computing Diwan, A., McKinley, K., and Moss, J. (1991). Type-based alias analysis. In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI 7891), pages 106-117.
  11. Emami, M., Ghiya, R., and Hendren, L. (1994). Contextsensitive inter-procedural points-to analysis in the presence of function pointers. In Proceedings of ACM SIGPLAN'94 Conference on Programming Language Design and Implementation, pages 224-256.
  12. Flanagan, C., Freund, S., and Tomb, A. (2006). Hybrid types, invariants, and refinements for imperative objects. In International Workshop on Foundations and Developments of Object-Oriented Languages (FOOL).
  13. Freeman, T. and Pfenning, F. (1991). Refinement types for ML. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), pages 268-277.
  14. Haldiman, N., Denker, M., and Nierstrasz, O. (2009). Practical, pluggable types for a dynamic language. Computer Languages, Systems & Structures, 35:48-62.
  15. Hudak, P., Jones, S., , and Wadler, P. (1991). Report on the programming language haskell version 1.1. Technical report, Departments of Computer Science, University of Glasgow and Yale University.
  16. Hugunin, J. (2007). Just glue it! Ruby and the DLR in Silverlight. In MIX Conference.
  17. Hürsch, W. and Lopes, C. (1995). Separation of concerns. Technical Report UN-CCS-95-03, Northeastern University, Boston, USA.
  18. Landi, W. and Ryder, B. (1992). A safe approximate algorithm for interprocedural pointer aliasing. In Conference on Programming Language Design and Implementation, pages 473-489.
  19. Meijer, E. and Drayton, P. (2004). Dynamic typing when needed: The end of the cold war between programming languages. In Proceedings of the OOPSLA Workshop on Revival of Dynamic Languages.
  20. Milner, R. (1978). A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17:348-375.
  21. Milner, R., Tofte, M., and Harper, R. (1990). The Definition of Standard ML. The MIT Press.
  22. Odersky, M., anb C. Röckl, V. C., and Zenger, M. (2002). A nominal theory of objects with dependent types. In European Conference on Object-Oriented Programming (ECOOP), pages 201-224.
  23. Odersky, M., Sulzmann, M., and Wehr, M. (1999). Type inference with constrained types. Theory and Practice of Object Systems, 5(1):35-55.
  24. Ortin, F. (2009). The StaDyn core type system. Technical report, Computer Science Department, University of Oviedo, Spain.
  25. Ortin, F. and Perez-Schofield, J. B. G. (2008). Supporting both static and dynamic typing. In Programming and Languages Conference (PROLE), pages 215-232.
  26. Ortin, F., Redondo, J. M., and Perez-Schofield, J. B. G. (2009). Efficient virtual machine support of runtime structural reflection. Science of Computer Programming, 74.
  27. Ortin, F., Zapico, D., and Cueva, J. M. (2007). Design patterns for teaching type checking in a compiler construction course. IEEE Transactions on Education, 50(3):273-283.
  28. Ortin, F., Zapico, D., Perez-Schofield, J. B. G., and Garcia, M. (2010). Including both static and dynamic typing in the same programming language. IET Software, (to be published).
  29. Parr, T. (2007). The Definitive ANTLR Reference: Building Domain-Specific Languages. Pragmatic Bookshelf.
  30. Pierce, B. C. (1992). Programming with intersection types and bounded polymorphism. Technical Report CMUCS-91-106, School of Computer Science, Pittsburgh, PA, USA.
  31. Pierce, B. C. (2002). Types and Programming Languages. The MIT Press.
  32. Plevyak, J. and Chien, A. (1994). Precise concrete type inference for object-oriented languages. In SIGPLAN Notices 29, 10, Proceeding of the OOPSLA Conference.
  33. Redondo, J. M. and Ortin, F. (2008). Optimizing reflective primitives of dynamic languages. International Journal of Software Engineering and Knowledge Engineering, 18(6):759-783.
  34. Rémy, D. and Vouillon, J. (1998). Objective ML: 'An effective object-oriented extension to ML'. Theory And Practice of Object Systems, 4(1):27-50.
  35. Shalit, A. (1996). The Dylan reference manual: the definitive guide to the new object-oriented dynamic language. Addison Wesley Longman Publishing Co.
  36. Siek, J. G. and Taha, W. (2007). Gradual typing for objects. In Proceedings of the 21st European Conference on Object-Oriented Programming (ECOOP).
  37. Siek, J. G. and Vachharajani, M. (2008). Gradual typing with unification-based inference. In Dynamic Languages Symposium.
  38. Thatte, S. (1990). Quasi-static typing. In Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (POPL), pages 367- 381, New York, NY, USA. ACM.
  39. Tucker, A. B. (1997). Type Systems. The Computer Science and Engineering Handbook. CRC Press.
  40. Venners, B. (2009). Twitter on Scala. a conversation with Steve Jenson, Alex Payne, and Robey Pointer. Artima Developer.
Download


Paper Citation


in Harvard Style

Ortin F., Zapico D. and Garcia M. (2010). A PROGRAMMING LANGUAGE TO FACILITATE THE TRANSITION FROM RAPID PROTOTYPING TO EFFICIENT SOFTWARE PRODUCTION . In Proceedings of the 5th International Conference on Software and Data Technologies - Volume 2: ICSOFT, ISBN 978-989-8425-23-2, pages 40-50. DOI: 10.5220/0002978500400050


in Bibtex Style

@conference{icsoft10,
author={Francisco Ortin and Daniel Zapico and Miguel Garcia},
title={A PROGRAMMING LANGUAGE TO FACILITATE THE TRANSITION FROM RAPID PROTOTYPING TO EFFICIENT SOFTWARE PRODUCTION},
booktitle={Proceedings of the 5th International Conference on Software and Data Technologies - Volume 2: ICSOFT,},
year={2010},
pages={40-50},
publisher={SciTePress},
organization={INSTICC},
doi={10.5220/0002978500400050},
isbn={978-989-8425-23-2},
}


in EndNote Style

TY - CONF
JO - Proceedings of the 5th International Conference on Software and Data Technologies - Volume 2: ICSOFT,
TI - A PROGRAMMING LANGUAGE TO FACILITATE THE TRANSITION FROM RAPID PROTOTYPING TO EFFICIENT SOFTWARE PRODUCTION
SN - 978-989-8425-23-2
AU - Ortin F.
AU - Zapico D.
AU - Garcia M.
PY - 2010
SP - 40
EP - 50
DO - 10.5220/0002978500400050