DOCSLIB.ORG

Understanding Object Oriented Programming: Utilizing Visualization Tools to Simplify the Transition from Python to Java A

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Understanding Object Oriented Programming: Utilizing Visualization Tools to Simplify the Transition from Python to Java A UNDERSTANDING OBJECT ORIENTED PROGRAMMING: UTILIZING VISUALIZATION TOOLS TO SIMPLIFY THE TRANSITION FROM PYTHON TO JAVA A THESIS Presented to the University Honors Program California State University, Long Beach In Partial Fulfillment Of the Requirements for the University Honors Program Christian Blydt-Hansen Spring 2018 I, THE UNDERSIGNED MEMBER OF THE COMMITTEE, HAVE APPROVED THIS THESIS UNDERSTANDING OBJECT ORIENTED PROGRAMMING: UTILIZING VISUALIZATION TOOLS TO SIMPLIFY THE TRANSITION FROM PYTHON TO JAVA BY Christian Blydt-Hansen Alvaro Monge, Ph. D (Thesis Advisor) Computer Science California State University, Long Beach Spring 2018 ABSTRACT UNDERSTANDING OBJECT ORIENTED PROGRAMMING: UTILIZING VISUALIZATION TOOLS TO SIMPLIFY THE TRANSITION FROM PYTHON TO JAVA By Christian Blydt-Hansen Spring 2018 The purpose of this study is to create tools to help students transition between programming languages, specifically Python to Java. Two existing visualization tools, Python Tutor and Skulpt, were modified to work together to create a tool that helps students gain a deeper understanding of Object Oriented Programming. The degree to which students understand the Object Oriented aspects of Python is a good measure of how well they will be able to transition to Java. The modified tools let the user examine their program in depth and visualize how their programming environment changes as they step though their program line by line. A survey for California State University Long Beach Students has been created to evaluate how difficult transitioning from Python to Java was, and how well the concepts they learned in Python assisted them in learning Java. ACKNOWLEDGEMENTS I would like to acknowledge and thank the people that helped me and supported me throughout my thesis, and throughout my entire academic career. Firstly, I would like to thank my family for the continued support in pursuing my career in Computer Science, among many other things. I would also like to thank Dr. Alvaro Monge for the assistance and guidance that he provided to me as my advisor on this research. Finally, I would like to thank my friends who have grown with me throughout our time as computer science students. iii TABLE OF CONTENTS Page ACKNOWLEDGEMENTS........................................................................................................ iii LIST OF FIGURES..................................................................................................................... v CHAPTER 1. INTRODUCTION.......................................................................................................... 1 Tools to Transition Between Languages............................................................ 1 Python Tutor as a Tutoring Tool........................................................................ 2 Using Visualization Tools to Ease the Transition Between Languages............. 4 2. UTILIZING PYTHON TUTOR AND SKULPT........................................................... 6 Python Tutor....................................................................................................... 6 Stepping Tool..................................................................................................... 6 Stack Trace Visualization................................................................................... 8 Skulpt.................................................................................................................. 9 Python Tutor and Skulpt..................................................................................... 10 Modifying Python Tutor..................................................................................... 10 Integrating Skulpt into Python Tutor.................................................................. 12 For Loop Support................................................................................................ 14 Weakness............................................................................................................. 15 3. STUDENT SURVEY...................................................................................................... 16 4. CONCLUSION................................................................................................................ 18 APPENDIX.................................................................................................................................. 19 REFERENCES............................................................................................................................. 24 iv LIST OF FIGURES FIGURE Page 1. Stepping through Python code using Python Tutor....................................................... 7 2. Python Tutor stack trace visualization........................................................................... 8 3. Skulpt interactive editor................................................................................................. 9 4. Skulpt Turtle graphics.................................................................................................... 10 5. Modified Python Tutor execution trace......................................................................... 12 6. Python Tutor working with Skulpt................................................................................ 13 7. Using For Loops............................................................................................................ 15 v CHAPTER 1 INTRODUCTION Many students learning computer science at a high school and college level have trouble grasping certain topics. One topic that is difficult to grasp is the concept of Object Oriented Programming. Currently, at California State University Long Beach, students are having difficulties transitioning from Python to Java, and being able to fully understand Object Oriented Programming, methods, classes, and data structures. This challenging transition is the focus of this research. It is very common for undergraduate students to start off by learning Python as an introduction to computer science, then learn a more advanced language like Java. O'Brien (2014) talks about how this transition can be challenging for students who have never programmed in the new language. He compares the transition to an English speaker trying to learn Spanish. They are different languages, but you should try to utilize your knowledge of English to help you learn Spanish. Likewise, students should use their knowledge of Python to help them learn Java. Tools to Transition Between Languages One proposed solution to this difficult transition was to build a tutoring tool to help students by translating Python code into Java code (O’Brien, Goldman, & Miller, 2014). This tutoring tool would be in the form of an interactive website that gives students Python code and asks them to write the Java code equivalent. Their solution is then checked using JUnit testing, and students are given feedback based on the results. The process of creating sample questions 1 would be time consuming for instructors, so the tutoring tool would provide tests cases, as well as accept student written test cases to be used by all. While transitioning to Java to learn Object Oriented Programming can be difficult, Goldwasser and Letscher (2008) challenge that Python itself can be a useful way to teach Object Oriented Programming. They note that there is debate on whether students should be introduced to computer science by learning objects first, or by learning the basics in a simpler language. They agree that Object Oriented Programming is “central to modern software development and therefore integral to a computer science curriculum.” While Python is mainly viewed as a scripting language, they propose that Python is a fully object oriented language and can be used to teach object models and classes. While Goldwasser and Letscher teach their introductory courses in Python, they do so keeping in mind that students will need to transition to Java or C++ later. They believe that while transitioning, the Python concepts do not need to be forgotten, but instead built upon and slightly modified. They highlight the differences between Python, which is interpreted and dynamically typed, and Java which is compiled and statically typed. They also highlight to differences in syntax between the two languages, and use Python to help students understand instance variables. While the two languages differ in many ways, their teaching style helps to prepare students by teaching Java concepts to them while they are learning Python. Python Tutor as a Tutoring Tool The use of additional tools outside of the classroom may also greatly aid students in the transition from Python to Java. Philip J. Guo is the creator of Python Tutor, a web-based program visualization tool for Python and several other languages, including Java, JavaScript, TypeScript, and Ruby. In his paper (2013), he explains how his software helps students in 2 introductory level computer science courses gain a deeper understanding of Python by using visualization tools. From 2010-2013, over 200,000 people used Python Tutor when it was being used in many universities such as UC Berkley, MIT, the University of Washington, and the University of Waterloo for introductory computer science courses. Guo explains that the user can step through Python code while keeping track of the line of code being currently executed, step forwards and backwards through the execution, view stack frames and variables, view the contents of heap objects and pointers, view
Load more

Recommended publications
  • C Language Tutorial
    C Language Tutorial Version 0.042 March, 1999 Original MS-DOS tutorial by Gordon Dodrill, Coronado Enterprises. Moved to Applix by Tim Ward Typed by Karen Ward C programs converted by Tim Ward and Mark Harvey with assistance from Kathy Morton for Visual Calculator Pretty printed by Eric Lindsay Applix 1616 microcomputer project Applix Pty Ltd Introduction The C programming language was originally developed by Dennis Ritchie of Bell Laboratories, and was designed to run on a PDP-11 with a UNIX operating system. Although it was originally intended to run under UNIX, there was a great interest in running it on the IBM PC and com- patibles, and other systems. C is excellent for actually writing system level programs, and the entire Applix 1616/OS operating system is written in C (except for a few assembler routines). It is an excellent language for this environment because of the simplicity of expression, the compactness of the code, and the wide range of applicability. It is not a good "beginning" language because it is somewhat cryptic in nature. It allows the programmer a wide range of operations from high level down to a very low level approaching the level of assembly language. There seems to be no limit to the flexibility available. One experienced C programmer made the statement, "You can program anything in C", and the statement is well supported by my own experience with the language. Along with the resulting freedom however, you take on a great deal of responsibility. It is very easy to write a program that destroys itself due to the silly little errors that, say, a Pascal compiler will flag and call a fatal error.
    [Show full text]
  • An Intelligent Debugging Tutor for Novice Computer Science Students Elizabeth Emily Carter Lehigh University
    Lehigh University Lehigh Preserve Theses and Dissertations 2014 An Intelligent Debugging Tutor For Novice Computer Science Students Elizabeth Emily Carter Lehigh University Follow this and additional works at: http://preserve.lehigh.edu/etd Part of the Computer Sciences Commons Recommended Citation Carter, Elizabeth Emily, "An Intelligent Debugging Tutor For Novice Computer Science Students" (2014). Theses and Dissertations. Paper 1447. This Dissertation is brought to you for free and open access by Lehigh Preserve. It has been accepted for inclusion in Theses and Dissertations by an authorized administrator of Lehigh Preserve. For more information, please contact [email protected]. An Intelligent Debugging Tutor For Novice Computer Science Students By Elizabeth Emily Carter Presented to the Graduate and Research Committee Of Lehigh University In Candidacy for the Degree of Doctor of Philosophy In Computer Science Lehigh University May 2014 © Copyright by Elizabeth Carter All rights reserved ii Approved and recommended for acceptance as a dissertation in partial fulfillment of the requirements for the degree of Doctor of Philosophy __________________ Date ________________________ Dissertation Advisor (Dr. Gang Tan) ___________________ Accepted Date Committee Members: _______________________ Dr. Gang Tan ________________________ Dr. Jeff Heflin ________________________ Dr. H. Lynn Columba ________________________ Dr. Glenn Blank iii Acknowledgements: First and foremost I would like to thank my de facto advisor Dr. Glenn Blank. He was the first faculty member I spoke to when I applied to Lehigh’s PhD program and he has guided me through the entire process. His guidance and editing assistance have been absolutely invaluable. I would like to thank Dr. Blank, Dr. Henry Odi, Dr. H.
    [Show full text]
  • Benchmarking the Stack Trace Analysis Tool for Bluegene/L
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Juelich Shared Electronic Resources John von Neumann Institute for Computing Benchmarking the Stack Trace Analysis Tool for BlueGene/L Gregory L. Lee, Dong H. Ahn, Dorian C. Arnold, Bronis R. de Supinski, Barton P. Miller, Martin Schulz published in Parallel Computing: Architectures, Algorithms and Applications , C. Bischof, M. B¨ucker, P. Gibbon, G.R. Joubert, T. Lippert, B. Mohr, F. Peters (Eds.), John von Neumann Institute for Computing, J¨ulich, NIC Series, Vol. 38, ISBN 978-3-9810843-4-4, pp. 621-628, 2007. Reprinted in: Advances in Parallel Computing, Volume 15, ISSN 0927-5452, ISBN 978-1-58603-796-3 (IOS Press), 2008. c 2007 by John von Neumann Institute for Computing Permission to make digital or hard copies of portions of this work for personal or classroom use is granted provided that the copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise requires prior specific permission by the publisher mentioned above. http://www.fz-juelich.de/nic-series/volume38 Benchmarking the Stack Trace Analysis Tool for BlueGene/L Gregory L. Lee1, Dong H. Ahn1, Dorian C. Arnold2, Bronis R. de Supinski1, Barton P. Miller2, and Martin Schulz1 1 Computation Directorate Lawrence Livermore National Laboratory, Livermore, California, U.S.A. E-mail: {lee218, ahn1, bronis, schulzm}@llnl.gov 2 Computer Sciences Department University of Wisconsin, Madison, Wisconsin, U.S.A. E-mail: {darnold, bart}@cs.wisc.edu We present STATBench, an emulator of a scalable, lightweight, and effective tool to help debug extreme-scale parallel applications, the Stack Trace Analysis Tool (STAT).
    [Show full text]
  • Warrior1: a Performance Sanitizer for C++ Arxiv:2010.09583V1 [Cs.SE]
    Warrior1: A Performance Sanitizer for C++ Nadav Rotem, Lee Howes, David Goldblatt Facebook, Inc. October 20, 2020 1 Abstract buffer, copies the data and deletes the old buffer. As the vector grows the buffer size expands in a geometric se- This paper presents Warrior1, a tool that detects perfor- quence. Constructing a vector of 10 elements in a loop mance anti-patterns in C++ libraries. Many programs results in 5 calls to ’malloc’ and 4 calls to ’free’. These are slowed down by many small inefficiencies. Large- operations are relatively expensive. Moreover, the 4 dif- scale C++ applications are large, complex, and devel- ferent buffers pollute the cache and make the program run oped by large groups of engineers over a long period of slower. time, which makes the task of identifying inefficiencies One way to optimize the performance of this code is to difficult. Warrior1 was designed to detect the numerous call the ’reserve’ method of vector. This method will small performance issues that are the result of inefficient grow the underlying storage of the vector just once and use of C++ libraries. The tool detects performance anti- allow non-allocating growth of the vector up to the speci- patterns such as map double-lookup, vector reallocation, fied size. The vector growth reallocation is a well known short lived objects, and lambda object capture by value. problem, and there are many other patterns of inefficiency, Warrior1 is implemented as an instrumented C++ stan- some of which are described in section 3.4. dard library and an off-line diagnostics tool.
    [Show full text]
  • Fortran for Students Macmillan Computer Science Series
    Fortran for Students Macmillan Computer Science Series Consulting Editor Professor F. H. Sumner, University of Manchester G. M. Birtwistle, Discrete Event Modelling on Simula J. K. Buckle, The JCL 2900 Series Derek Coleman, A Structured Programming Approach to Data * Andrew J. T. Colin, Programming and Problem-solving in Algo/68 * S. M. Deen, Fundamentals of Data Base Systems * David Hopkin and Barbara Moss, Automata * Roger Hutty, Fortran for Students H. Kopetz, Software Reliability A. Learner and A. J. Powell, An Introduction to Algo/68 through Problems * A. M. Lister, Fundamentals of Operating Systems, second edition * Brian Meek, Fortran, PL/1 and the A/gals Derrick Morris and Roland N. lbbett, The MUS Computer System John Race, Case Studies in Systems Analysis I. R. Wilson and A. M. Addyman, A Practical Introduction to Pascal * The titles marked with an asterisk were prepared during the Consulting Editorship of Professor J. S. Rohl, University of Western Australia. Fortran for Students Roger Rutty School of Mathematics, Computing and Statistics, Leicester Polytechnic © Roger Hutty 1980 All rights reserved. No part of this publication may be reproduced or transmitted, in any form or by any means, without permission. First published 1980 by THE MACMILLAN PRESS LTD London and Basingstoke Associated companies in Delhi Dublin Hong Kong Johannesburg Lagos Melboume New York Singapore and Tokyo ISBN 978-1-349-81447-3 ISBN 978-1-349-81445-9 (eBook) DOI 10.1007/978-1-349-81445-9 This book is sold subject to the standard conditions of the Net Book Agreement. The paperback edition of this book is sold subject to the condition that it shall not, by the way of trade or otherwise, be lent, resold, hired out, or otherwise circulated without the publisher's prior consent in any form of bin ding or cover other than that in which it is published and without a similar condition including this condition being imposed on the subsequen~ purchaser.
    [Show full text]
  • Does the Fault Reside in a Stack Trace? Assisting Crash Localization by Predicting Crashing Fault Residence
    The Journal of Systems and Software 148 (2019) 88–104 Contents lists available at ScienceDirect The Journal of Systems and Software journal homepage: www.elsevier.com/locate/jss Does the fault reside in a stack trace? Assisting crash localization by predicting crashing fault residence ∗ Yongfeng Gu a, Jifeng Xuan a, , Hongyu Zhang b, Lanxin Zhang a, Qingna Fan c, Xiaoyuan Xie a, Tieyun Qian a a School of Computer Science, Wuhan University, Wuhan 430072, China b School of Electrical Engineering and Computer Science, The University of Newcastle, Callaghan NSW2308, Australia c Ruanmou Edu, Wuhan 430079, China a r t i c l e i n f o a b s t r a c t Article history: Given a stack trace reported at the time of software crash, crash localization aims to pinpoint the root Received 27 February 2018 cause of the crash. Crash localization is known as a time-consuming and labor-intensive task. Without Revised 7 October 2018 tool support, developers have to spend tedious manual effort examining a large amount of source code Accepted 6 November 2018 based on their experience. In this paper, we propose an automatic approach, namely CraTer, which pre- Available online 6 November 2018 dicts whether a crashing fault resides in stack traces or not (referred to as predicting crashing fault res- Keywords: idence ). We extract 89 features from stack traces and source code to train a predictive model based on Crash localization known crashes. We then use the model to predict the residence of newly-submitted crashes. CraTer can Stack trace reduce the search space for crashing faults and help prioritize crash localization efforts.
    [Show full text]
  • Codechella: Multi-User Program Visualizations for Real-Time Tutoring and Collaborative Learning
    Codechella: Multi-User Program Visualizations for Real-Time Tutoring and Collaborative Learning Philip J. Guo, Jeffery White, Renan Zanelatto Department of Computer Science University of Rochester Rochester, NY 14627 [email protected], fjwhite37,[email protected] Abstract—An effective way to learn computer programming is to sit side-by-side in front of the same computer with a tutor or peer, write code together, and then discuss what happens as the code executes. To bring this kind of in-person interaction to an online setting, we have developed Codechella, a multi-user Web- based program visualization system that enables multiple people to collaboratively write code together, explore an automatically- generated visualization of its execution state using multiple mouse cursors, and chat via an embedded text box. In nine months of live deployment on an educational website – www.pythontutor.com – people from 296 cities across 40 countries participated in 299 Codechella sessions for both tutoring and collaborative learning. 57% of sessions connected participants from different cities, and 12% from different countries. Participants actively engaged with the program visualizations while chatting, showed affective exchanges such as encouragement and banter, and indicated signs of learning at the lower three levels of Bloom’s taxonomy: remembering, understanding, and applying knowledge. Keywords—program visualization, collaborative visualization, CS education Fig. 1. Codechella is a Web-based system that enables two or more people to collaboratively write code together, explore a detailed visualization of its I. INTRODUCTION execution state, and chat via text. All participants within a session see a real- time view of one another’s mouse cursors as colored hand icons (e.g., the red Despite the recent proliferation of free online re- hand for the user named “Curious Cat”) and mouse clicks as bubbles.
    [Show full text]
  • Daniel Yoo [email protected]
    Daniel Yoo [email protected] http://hashcollision.org/ Education Bachelor of Science (BS) in Electrical Engineering and Computer Science (EECS) in May 2001 at the University of California, Berkeley. PhD in Computer Science in May 2012 at Worcester Polytechnic Institute. Involved with the PLT research group at Brown University. Technical Skills Extensive experience with programming languages since 1995. Proficient in: Racket (Scheme), JavaScript, Java, C, Python, Perl, SQL, as well as Unix adminstration and tools like Emacs, LATEX, and Git. Work Experience and Projects • 2013{ Software Engineer at Google. In the Developer Infrastructure group. • 2012{2013 Postgraduate at the University of Utah. I explored compilation techniques for compiling Racket to Javascript, improved the Racket runtime, and continued to develop the WeScheme program- ming environment. • 2010{2013 Developing Whalesong (http://hashcollision.org/whalesong), a Racket-to-JavaScript compiler as part of the Moby and WeScheme projects. • 2009{2013 Writing and maintaining WeScheme (http://wescheme.org), an online programming en- vironment that provides an editing and runtime environment on the web browser. • 2009 Wrote the Moby Scheme Compiler (http://www.cs.brown.edu/~sk/Publications/Talks/Moby-Bootstrap/), a compiler from Beginner Student Language to smartphone platforms. • 2008 Taught for the CitizenSchools program (http://www.citizenschools.org/) at University Park Campus School in Worcester. I used the Bootstrap (http://www.bootstrapworld.org/) curriculum, which teaches math skills by having students program algebraic functions to build a computer game. • 2007{2008 Wrote the implementation of the Alchemy compiler, which takes a software specification written in the Alloy language and produces an implementation. (http://www.cs.brown.edu/~sk/ Publications/Papers/Published/kdfy-alchemy-trans-alloy-spec-impl/) • 2006 Worked with Guillaume Marceau at Brown University for Brown PLT summer session.
    [Show full text]
  • The Tutor-Web: an Educational System for Classroom Presentation, Evaluation and Self-Study
    ARTICLE IN PRESS Computers & Education xxx (2003) xxx–xxx www.elsevier.com/locate/compedu The tutor-web: An educational system for classroom presentation, evaluation and self-study Gunnar Stefansson Science Institute, University of Iceland, Dunhaga 5, 107 Reykjavik, Iceland Received 15 May 2003; accepted 18 September 2003 Abstract A general Web-based system for use in education, the tutor-web, has been developed for storage and presentation of electronic slides for classroom use, along with reference material, examples and quizzes. The primary novelty of the system is the structured linkage between the various pieces of information, to maintain coherence and focus on the educational content in spite of being Web-based. The system has been developed with an emphasis on teaching mathematics and statistics, but the design is generic. Students have full access to all material outside the classroom. Material within the tutor-web is organized into lectures and tutorials. The material can include text, equations and figures. The system can include multiple-choice questions and will automatically collect the returned answers as well as return rates and grades. The system can be used for generating and presenting electronic slides for in-class use but it can also provide a textbook which links together the slides and associated reference material. A formal definition of the format of content is used, but it is also easy to extend the definitions. Given the formal formats it requires only minimal effort to modify presentation forms and add entirely new ones. The tutor-web is a developing project in an open environment, for general access and open to anyone interested in developing it further or using it.
    [Show full text]
  • Feedback-Directed Instrumentation for Deployed Javascript Applications
    Feedback-Directed Instrumentation for Deployed JavaScript Applications ∗ ∗ Magnus Madsen Frank Tip Esben Andreasen University of Waterloo Samsung Research America Aarhus University Waterloo, Ontario, Canada Mountain View, CA, USA Aarhus, Denmark [email protected] [email protected] [email protected] Koushik Sen Anders Møller EECS Department Aarhus University UC Berkeley, CA, USA Aarhus, Denmark [email protected] [email protected] ABSTRACT be available along with failure reports. For example, log files Many bugs in JavaScript applications manifest themselves may exist that contain a summary of an application's exe- as objects that have incorrect property values when a fail- cution behavior, or a dump of an application's state at the ure occurs. For such errors, stack traces and log files are time of a crash. However, such information is often of lim- often insufficient for diagnosing problems. In such cases, it ited value, because the amount of information can be over- is helpful for developers to know the control flow path from whelming (e.g., log files may span many megabytes, most the creation of an object to a crashing statement. Such of which is typically completely unrelated to the failure), or crash paths are useful for understanding where the object is woefully incomplete (e.g., a stack trace or memory dump originated and whether any properties of the object were usually provides little insight into how an application arrived corrupted since its creation. in an erroneous state). We present a feedback-directed instrumentation technique Many bugs that arise in JavaScript applications manifest for computing crash paths that allows the instrumentation themselves as objects that have incorrect property values overhead to be distributed over a crowd of users and to re- when a failure occurs.
    [Show full text]
  • Towards Supporting Transfer of Programming Language Knowledge
    It’s Like Python But: Towards Supporting Transfer of Programming Language Knowledge Nischal Shrestha Titus Barik Chris Parnin NC State University Microsoft NC State University Raleigh, NC, USA Redmond, WA, USA Raleigh, NC, USA [email protected] [email protected] [email protected] Abstract—Expertise in programming traditionally assumes a other high-level languages which can confuse programmers binary novice-expert divide. Learning resources typically target such as the following: programmers who are learning programming for the first time, or expert programmers for that language. An underrepresented, yet Sequence indexing is base-one. Accessing the zeroth important group of programmers are those that are experienced element does not give an error but is never useful. in one programming language, but desire to author code in In this paper, we explore supporting learning of program- a different language. For this scenario, we postulate that an ming languages through the lens of learning transfer, which effective form of feedback is presented as a transfer from concepts occurs when learning in one context either enhances (positive in the first language to the second. Current programming environments do not support this form of feedback. transfer) or undermines (negative transfer) a related perfor- In this study, we apply the theory of learning transfer to teach mance in another context [7]. Past research has explored a language that programmers are less familiar with––such as transfer of cognitive skills across programming tasks like R––in terms of a programming language they already know– comprehension, coding and debugging [8], [9], [10]. There has –such as Python.
    [Show full text]
  • Stack Traces in Haskell
    Stack Traces in Haskell Master of Science Thesis ARASH ROUHANI Chalmers University of Technology Department of Computer Science and Engineering G¨oteborg, Sweden, March 2014 The Author grants to Chalmers University of Technology and University of Gothen- burg the non-exclusive right to publish the Work electronically and in a non-commercial purpose make it accessible on the Internet. The Author warrants that he/she is the author to the Work, and warrants that the Work does not contain text, pictures or other material that violates copyright law. The Author shall, when transferring the rights of the Work to a third party (for example a publisher or a company), acknowledge the third party about this agreement. If the Author has signed a copyright agreement with a third party regarding the Work, the Author warrants hereby that he/she has obtained any necessary permission from this third party to let Chalmers University of Technology and University of Gothenburg store the Work electronically and make it accessible on the Internet. Stack Traces for Haskell A. ROUHANI c A. ROUHANI, March 2014. Examiner: J. SVENNINGSSON Chalmers University of Technology University of Gothenburg Department of Computer Science and Engineering SE-412 96 G¨oteborg Sweden Telephone + 46 (0)31-772 1000 Department of Computer Science and Engineering Department of Computer Science and Engineering G¨oteborg, Sweden March 2014 Abstract This thesis presents ideas for how to implement Stack Traces for the Glasgow Haskell Compiler. The goal is to come up with an implementation with such small overhead that organizations do not hesitate to use it for their binaries running in production.
    [Show full text]