Literature Found

Results of searching with EnginneringVillage2

Title list

• Auslander, J., M. Philipose, et al. (1996). Fast, effective dynamic compilation. ACM SIGPLAN '96: Programming Language Design and Implementation, 21-24 May 1996, USA, ACM.
• Norvig, P. (2001). "Extreme rapid development." Software Development 9(3): 29-35.
• Bayne, M., R. Cook, et al. (2011). Always-available static and dynamic feedback. 2011 33rd International Conference on Software Engineering (ICSE 2011), 21-28 May 2011, Piscataway, NJ, USA, IEEE.
• Hou, D. and Y. Wang (2009). An empirical analysis of the evolution of user-visible features in an integrated development environment. Proceedings of the 2009 Conference of the Center for Advanced Studies on Collaborative Research. Ontario, Canada, ACM: 122-135.
• (2003). "Anatomy of an IDE." Electronic Design 51(10): 63.
• Duval, B. K. and L. Main (1997). "Javascript." Library Software Review 16(3): 164-173.
• Eich, B. (2005). "JavaScript at ten years." SIGPLAN Notices 40(9): 129.
• Feldthaus, A., T. Millstein, et al. (2011). Tool-supported refactoring for javascrip. 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA'11, October 22, 2011 - October 27, 2011, Portland, OR, United states, Association for Computing Machinery.
• Guha, A., C. Saftoiu, et al. (2010). The essence of javascript. 24th European Conference on Object-Oriented Programming, ECOOP 2010, June 21, 2010 - June 25, 2010, Maribor, Slovenia, Springer Verlag.
• Jensen, S. H., A. Mller, et al. (2009). Type analysis for JavaScript. 16th International Symposium on Static Analysis, SAS 2009, August 9, 2009 - August 11, 2009, Los Angeles, CA, United states, Springer Verlag.
• Kienle, H. M. (2010). "It's about Time to Take JavaScript (More) Seriously." IEEE Software 27(3): 60-62.
• Krapfenbauer, H., D. Ertl, et al. (2009). Support for programming embedded software with dynamically typed languages. 4th International Conference on Systems, ICONS 2009, March 1, 2009 - March 6, 2009, Gosier, Guadeloupe, IEEE Computer Society.
• Li, S., B. Cheng, et al. (2012). "JavaScript typing system with prediction." Jisuanji Yanjiu yu Fazhan/Computer Research and Development 49(2): 421-431.
• Muhammad, A., F. Al-Humaidan, et al. (2009). Interactive vs Integrated Development Environment for Scientific Computing. 2009 International Conference on Scientific Computing. CSC 2009, 13-16 July 2009, Las Vegas, NV, USA, CSREA Press.
• Richards, G., S. Lebresne, et al. (2010). An analysis of the dynamic behavior of JavaScript programs. ACM SIGPLAN 2010 Conference on Programming Language Design and Implementation, PLDI 2010, June 5, 2010 - June 10, 2010, Toronto, ON, Canada, Association for Computing Machinery.
• Rothlisberger, D., O. Greevy, et al. (2008). Exploiting runtime information in the IDE. 2008 IEEE 16th International Conference on Program Comprehension, 10-13 June 2008, Piscataway, NJ, USA, IEEE.
• van Deursen, A. (2009). What your IDE could do once you understand your code. 2009 11th IEEE International Symposium on Web Systems Evolution (WSE 2009), 25-26 Sept. 2009, Piscataway, NJ, USA, IEEE.
• van Deursen, A., A. Mesbah, et al. (2010). Adinda: A knowledgeable, browser-based IDE. 2010 32nd International Conference on Software Engineering (ICSE), 2-8 May 2010, Piscataway, NJ, USA, IEEE.
• Bolz, C. F., A. Kuhn, et al. (2008). Back to the future in one week: implementing a Smalltalk VM in PyPy. Self-Sustaining Systems. First Workshop, S3 2008., 15-16 May 2008, Berlin, Germany, Springer-Verlag.
• Ertl, D. and H. Krapfenbauer (2009). A case study of developing an IDE for embedded software using open source. 4th International Conference on Software Engineering Advances, ICSEA 2009, Includes SEDES 2009: Simposio para Estudantes de Doutoramento em Engenharia de Software, September 20, 2009 - September 25, 2009, Porto, Portugal, IEEE Computer Society.
• Anderson, C., P. Giannini, et al. (2005). Towards type inference for JavaScript. 19th European Conference on Object-Oriented Programming, ECOOP 2005, July 25, 2005 - July 29, 2005, Glasgow, United kingdom, Springer Verlag.
• Paulson, L. D. (2007). "Developers shift to dynamic programming languages." Computer 40(2): 12-15.
• Nierstrasz, O., A. Bergel, et al. (2005). On the revival of dynamic languages. 4th International Workshop on Software Composition,SC 2005, April 9, 2005 - April 9, 2005, Edinburgh, United kingdom, Springer Verlag.

Eventually not all items may be used, this is just a draft list to store all bibliography found using search engines like EnginneringVillage2.

Abstracts

• Auslander, J., M. Philipose, et al. (1996). Fast, effective dynamic compilation. ACM SIGPLAN '96: Programming Language Design and Implementation, 21-24 May 1996, USA, ACM.
  Dynamic compilation enables optimizations based on the values of invariant data computed at run-time. Using the values of these runtime constants, a dynamic compiler can eliminate their memory loads, perform constant propagation and folding, remove branches they determine, and fully unroll loops they bound. However, the performance benefits of the more efficient, dynamically-compiled code are offset by the run-time cost of the dynamic compile. Our approach to dynamic compilation strives for both fast dynamic compilation and high-quality dynamically-compiled code: the programmer annotates regions of the programs that should be compiled dynamically; a static, optimizing compiler automatically produces pre-optimized machine-code templates, using a pair of dataflow analyses that identify which variables will be constant at run-time; and a simple, dynamic compiler copies the templates, patching in the computed values of the run-time constants, to produce optimized, executable code. Our work targets general purpose, imperative programming languages, initially C. Initial experiments applying dynamic compilation to C programs have produced speedups ranging from 1.2 to 1.8
• Bayne, M., R. Cook, et al. (2011). Always-available static and dynamic feedback. 2011 33rd International Conference on Software Engineering (ICSE 2011), 21-28 May 2011, Piscataway, NJ, USA, IEEE.
  Developers who write code in a statically typed language are denied the ability to obtain dynamic feedback by executing their code during periods when it fails the static type checker. They are further confined to the static typing discipline during times in the development process where it does not yield the highest productivity. If they opt instead to use a dynamic language, they forgo the many benefits of static typing, including machine-checked documentation, improved correctness and reliability, tool support (such as for refactoring), and better runtime performance. We present a novel approach to giving developers the benefits of both static and dynamic typing, throughout the development process, and without the burden of manually separating their program into statically and dynamically-typed parts. Our approach, which is intended for temporary use during the development process, relaxes the static type system and provides a semantics for many type-incorrect programs. It defers type errors to run time, or suppresses them if they do not affect runtime semantics. We implemented our approach in a publicly available tool, DuctileJ, for the Java language. In case studies, DuctileJ conferred benefits both during prototyping and during the evolution of existing code.
• (2003). "Anatomy of an IDE." Electronic Design 51(10): 63.
  The modular and microkernel design applications of Java-based Eclipse integrated development environment (IDE) are discussed. Eclipse runs on top of Java virtual machine, making it very portable. The Eclipse platform runs on a small microkernel that sets up the environment and handles the various plug-ins.
• Duval, B. K. and L. Main (1997). "Javascript." Library Software Review 16(3): 164-173.
  Web pages are becoming increasingly more dynamic. This article examines Javascript as a means of increasing user interactivity with a Web page. The fundamentals of Javascript are discussed, and several examples of Javascript in action are included. The context is its use in libraries
• Eich, B. (2005). "JavaScript at ten years." SIGPLAN Notices 40(9): 129.
  Summary form only given. This talk presents the tumultuous history of JavaScript, from its first appearance in Netscape 2 beta releases in the fall of 1995 through the present, with emphasis on the unvarnished, real-world side of designing, implementing, shipping, and standardizing a functional programming language used by millions of people. JavaScript was conceived of as an "object-based scripting language", but its inspiration came originally from Scheme, with an admixture of Self. Designing a language to fit the constraints of the target audience of HTML authors, the embedding browser application, and the market conditions of that time was challenging. We discuss what worked and what did not, and how the language evolved due to competition and dejure standardization. The talk ranges widely over the history of the Web, including the recent renaissance of JavaScript and its development in the ECMA standards group. We close by presenting new work likely to appear in the next version of the language
• Feldthaus, A., T. Millstein, et al. (2011). Tool-supported refactoring for javascrip. 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications, OOPSLA'11, October 22, 2011 - October 27, 2011, Portland, OR, United states, Association for Computing Machinery.
  Refactoring is a popular technique for improving the structure of existing programs while maintaining their behavior. For statically typed programming languages such as Java, a wide variety of refactorings have been described, and tool support for performing refactorings and ensuring their correctness is widely available in modern IDEs. For the JavaScript programming language, however, existing refactoring tools are less mature and often unable to ensure that program behavior is preserved. Refactoring algorithms that have been developed for statically typed languages are not applicable to JavaScript because of its dynamic nature. We propose a framework for specifying and implementing JavaScript refactorings based on pointer analysis. We describe novel refactorings motivated by best practice recommendations for JavaScript programming, and demonstrate how they can be described concisely in terms of queries provided by our framework. Experiments performed with a prototype implementation on a suite of existing applications show that our approach is well-suited for developing practical refactoring tools for JavaScript. Copyright is held by the author / owner(s).
• Guha, A., C. Saftoiu, et al. (2010). The essence of javascript. 24th European Conference on Object-Oriented Programming, ECOOP 2010, June 21, 2010 - June 25, 2010, Maribor, Slovenia, Springer Verlag.
  We reduce JavaScript to a core calculus structured as a small-step operational semantics. We present several peculiarities of the language and show that our calculus models them. We explicate the desugaring process that turns JavaScript programs into ones in the core. We demonstrate faithfulness to JavaScript using real-world test suites. Finally, we illustrate utility by defining a security property, implementing it as a type system on the core, and extending it to the full language. 2010 Springer-Verlag Berlin Heidelberg.
• Jensen, S. H., A. Mller, et al. (2009). Type analysis for JavaScript. 16th International Symposium on Static Analysis, SAS 2009, August 9, 2009 - August 11, 2009, Los Angeles, CA, United states, Springer Verlag.
  JavaScript is the main scripting language for Web browsers, and it is essential to modern Web applications. Programmers have started using it for writing complex applications, but there is still little tool support available during development. We present a static program analysis infrastructure that can infer detailed and sound type information for JavaScript programs using abstract interpretation. The analysis is designed to support the full language as defined in the ECMAScript standard, including its peculiar object model and all built-in functions. The analysis results can be used to detect common programming errors - or rather, prove their absence, and for producing type information for program comprehension. Preliminary experiments conducted on real-life JavaScript code indicate that the approach is promising regarding analysis precision on small and medium size programs, which constitute the majority of JavaScript applications. With potential for further improvement, we propose the analysis as a foundation for building tools that can aid JavaScript programmers. 2009 Springer.
• Kienle, H. M. (2010). "It's about Time to Take JavaScript (More) Seriously." IEEE Software 27(3): 60-62.
  JavaScript is often seen as a toy language. Yet, it offers a powerful mix of interesting language features based on functional programming, prototyping, and mutable objects. Web 2.0 apps use JavaScript extensively to realize sophisticated client-side functionality. Taken this into account, it isn't surprising that JavaScript made it to the top 10 in a survey on the most popular programming languages. JavaScript's capabilities are showcased by the Lively Kernel, which is an interactive platform and web development environment that runs in a browser window. It's implemented entirely in JavaScript, demonstrating that despite its weaknesses, JavaScript can be used as a general-purpose and systems programming language. 2010 IEEE.
• Krapfenbauer, H., D. Ertl, et al. (2009). Support for programming embedded software with dynamically typed languages. 4th International Conference on Systems, ICONS 2009, March 1, 2009 - March 6, 2009, Gosier, Guadeloupe, IEEE Computer Society.
  The support for programming embedded software still lags behind the support for PCs. In particular, dynamically typed languages are not yet widely available for embedded systems. The work presented in this paper shows how we support embedded software programming by bringing the benefits of dynamically typed languages to embedded systems. Dynamically typed languages are particularly suitable for rapid prototyping of software and boost the time-to-market. It is common to have rich tool sets available for developing PC software. So, we strive for similar programming support for embedded software and present an implemented and integrated development environment. It supports the dynamically typed language Python. 2009 IEEE.
• Li, S., B. Cheng, et al. (2012). "JavaScript typing system with prediction." Jisuanji Yanjiu yu Fazhan/Computer Research and Development 49(2): 421-431.
  As the Internet and the World Wide Web become more and more popular nowadays, and the JavaScript programming language is becoming a key role in Web browsers, investigation on the behavior of JavaScript applications is important to improve Web browser's performance and user experience. Traditional study believes that, the dynamic typing nature of the JavaScript language is the major performance bottleneck. So the main optimizations of most advanced mainstream JavaScript engines are all focused on dynamic typing problems. To learn the dynamic typing nature of JavaScript language in depth, two novel predication-based algorithms, called "type prediction" and "position-based inline caching", are introduced to tackle the problems. With these algorithms, the typing system of JavaScript language is studied systematically and the techniques are evaluated with a representative JavaScript performance benchmark-SunSpider. In experiments with the SunSpider applications, the predication-based algorithms can identify the types with 99% accuracy on average. And so it is believed that although the JavaScript language provides abundant dynamics with its typing system, the actual applications do not really use all the features and hence their behaviors are static at most time. This is the first time that such discovery is made and published.
• Muhammad, A., F. Al-Humaidan, et al. (2009). Interactive vs Integrated Development Environment for Scientific Computing. 2009 International Conference on Scientific Computing. CSC 2009, 13-16 July 2009, Las Vegas, NV, USA, CSREA Press.
  This paper argues that most scientific development tools are interactive but not integrated. It also argues that most scientific tools lack in integration with standard programming languages to build complex scientific applications using proper software engineering practices. It presents the desirable features of an integrated development environment (IDE) for scientific computing. jMatlab is an eclipse based scientific interpreter modeled after Matlab. This paper presents the features and integration examples of this tool to emphasis the need for a true IDE for scientific computing.
• Richards, G., S. Lebresne, et al. (2010). An analysis of the dynamic behavior of JavaScript programs. ACM SIGPLAN 2010 Conference on Programming Language Design and Implementation, PLDI 2010, June 5, 2010 - June 10, 2010, Toronto, ON, Canada, Association for Computing Machinery.
  The JavaScript programming language is widely used for web programming and, increasingly, for general purpose computing. As such, improving the correctness, security and performance of JavaScript applications has been the driving force for research in type systems, static analysis and compiler techniques for this language. Many of these techniques aim to reign in some of the most dynamic features of the language, yet little seems to be known about how programmers actually utilize the language or these features. In this paper we perform an empirical study of the dynamic behavior of a corpus of widely-used JavaScript programs, and analyze how and why the dynamic features are used. We report on the degree of dynamism that is exhibited by these JavaScript programs and compare that with assumptions commonly made in the literature and accepted industry benchmark suites. 2010 ACM.
• Rothlisberger, D., O. Greevy, et al. (2008). Exploiting runtime information in the IDE. 2008 IEEE 16th International Conference on Program Comprehension, 10-13 June 2008, Piscataway, NJ, USA, IEEE.
  Developers rely on the mechanisms provided by their IDE to browse and navigate a large software system. These mechanisms are usually based purely on a system's static source code. The static perspective, however, is not enough to understand an object-oriented program's behavior, in particular if implemented in a dynamic language. We propose to enhance IDEs with a program's runtime information (e.g., message sends and type information) to support program comprehension through precise navigation and informative browsing. To precisely specify the type and amount of runtime data to gather about a system under development, dynamically and on demand, we adopt a technique known as partial behavioral reflection. We implemented navigation and browsing enhancements to an IDE that exploit this runtime information in a prototype called Hermion. We present preliminary validation of our experimental enhanced IDE by asking developers to assess its usefulness to understand an unfamiliar software system.
• van Deursen, A. (2009). What your IDE could do once you understand your code. 2009 11th IEEE International Symposium on Web Systems Evolution (WSE 2009), 25-26 Sept. 2009, Piscataway, NJ, USA, IEEE.
  The paper is talking about integrated development environment (IDE), a software application that provides comprehensive facilities for software development.
• van Deursen, A., A. Mesbah, et al. (2010). Adinda: A knowledgeable, browser-based IDE. 2010 32nd International Conference on Software Engineering (ICSE), 2-8 May 2010, Piscataway, NJ, USA, IEEE.
  In practice, many people have to work together to develop and maintain a software system. However, the programmer's key tool, the Integrated Development Environment (IDE), is a solo-tool, serving to help individual programmers understand and modify the system. Such an IDE does not leverage the knowledge other team members may have of the design and implementation of the system. We propose to resolve this problem by exploring, experimentally, new ways of inferring knowledge from past IDE-interactions, and of maximizing collaboration among developers. Our approach, called Adinda, revolves around transforming the IDE into a set of integrated services, accessible via a web browser, and enriched with Web 2.0 technologies. Such services will not only help developers perform traditional IDE tasks, but also facilitate the required informal communication and collaboration needs of software development projects. In this paper, we report on our vision, approach and challenges for building Adinda, and initial results.
• Bolz, C. F., A. Kuhn, et al. (2008). Back to the future in one week: implementing a Smalltalk VM in PyPy. Self-Sustaining Systems. First Workshop, S3 2008., 15-16 May 2008, Berlin, Germany, Springer-Verlag.
  We report on our experiences with the Spy project, including implementation details and benchmark results. Spy is a re-implementation of the Squeak (i.e., Smalltalk-80) VM using the PyPy toolchain. The PyPy project allows code written in RPython, a subset of Python, to be translated to a multitude of different backends and architectures. During the translation, many aspects of the implementation can be independently tuned, such as the garbage collection algorithm or threading implementation. In this way, a whole host of interpreters can be derived from one abstract interpreter definition. Spy aims to bring these benefits to Squeak, allowing for greater portability and, eventually, improved performance. The current Spy codebase is able to run a small set of benchmarks that demonstrate performance superior to many similar Smalltalk VMs, but which still run slower than in Squeak itself. Spy was built from scratch over the course of a week during a joint Squeak- PyPy Sprint in Bern last autumn.
• Ertl, D. and H. Krapfenbauer (2009). A case study of developing an IDE for embedded software using open source. 4th International Conference on Software Engineering Advances, ICSEA 2009, Includes SEDES 2009: Simposio para Estudantes de Doutoramento em Engenharia de Software, September 20, 2009 - September 25, 2009, Porto, Portugal, IEEE Computer Society.
  IDEs (Integrated Development Environments) support software developers in their implementation work. However, embedded software has specific requirements, so an off-the-shelf IDE for this purpose does not exist. In such a case, this paper recommends developing a customized IDE based on open source software. We present a case study of developing such an IDE for the languages C#, Python and JavaScript. We used several open source projects with varying project status as a basis for our development. We analyzed developer communication within these open source projects and identified the benefits and the potential pitfalls for the case study. Moreover, we present the effort made in terms of person months and that reuse of open source software improves cost-efficiency for the development of such IDEs. 2009 IEEE.
• Anderson, C., P. Giannini, et al. (2005). Towards type inference for JavaScript. 19th European Conference on Object-Oriented Programming, ECOOP 2005, July 25, 2005 - July 29, 2005, Glasgow, United kingdom, Springer Verlag.
  Object-oriented scripting languages like JavaScript and Python are popular partly because of their dynamic features. These include the runtime modification of objects and classes through addition of fields or updating of methods. These features make static typing difficult and so usually dynamic typing is used. Consequently, errors such as access to non-existent members are not detected until runtime. We first develop a formalism for an object based language, JS0, with features from JavaScript, including dynamic addition of fields and updating of methods. We give an operational semantics and static type system for JSo using structural types. Our types allow objects to evolve in a controlled manner by classifying members as definite or potential. We define a type inference algorithm for JS0 that is sound with respect to the type system. If the type inference algorithm succeeds, then the program is typeable. Therefore, programmers can benefit from the safety offered by the type system, without the need to write explicitly types in their programs. Springer-Verlag Berlin Heidelberg 2005.
• Paulson, L. D. (2007). "Developers shift to dynamic programming languages." Computer 40(2): 12-15.
  Software developers are always looking for ways to boost their effectiveness and productivity and perform complex jobs more quickly and easily, particularly as projects have become increasingly large and complex. Programmers want to shed unneeded complexity and outdated methodologies and move to approaches that focus on making programming simpler and faster. With this in mind, many developers are increasingly using dynamic languages such as JavaScript, Perl, Python, and Ruby. Although software experts disagree on the exact definition, a dynamic language basically enables programs that can change their code and logical structures at runtime, adding variable types, module names, classes, and functions as they are running. These languages frequently are interpreted and generally check typing at runtime
• Nierstrasz, O., A. Bergel, et al. (2005). On the revival of dynamic languages. 4th International Workshop on Software Composition,SC 2005, April 9, 2005 - April 9, 2005, Edinburgh, United kingdom, Springer Verlag.
  The programming languages of today are stuck in a deep rut that has developed over the past 50 years. Although we are faced with new challenges posed by enormous advances in hardware and internet technology, we continue to struggle with old-fashioned languages based on rigid, static, closed-world file-based views of programming. We argue the need for a new class of dynamic languages that support a view of programming as constant evolution of living and open software models. Such languages would require features such as dynamic first-class namespaces, explicit meta-models, optional, pluggable type systems, and incremental compilation of running software systems. Springer-Verlag Berlin Heidelberg 2005.