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

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

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

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

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

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

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 the program’s console output, and generate a shareable URL of an exact point of their execution. Python Tutor has three main categories of use cases: instructors using it as a teaching aid in a classroom, digital textbooks using it to embed Python visualizations, and students using it out of the classroom for studying. In the classroom, Python Tutor has been helping instructors to clarify concepts such as

“tracing parameters and return values through function calls, control flow, exceptions, scope, recursion, local variable lifetimes, and understanding aliasing when there are multiple identifiers referencing the same object” (Guo, 2013). In digital textbooks, visualization tools are embedded into the textbook so that students may interact with Python code examples, as opposed to just viewing drawings. As an independent study tool, in 2013, there were over 30,000 unique IP address visits per month, most of which came from independent learners. Students use this program to debug their code, and understand concepts like recursion using the stepping tool.

As a tutoring tool, Python Tutor works well for class discussions, but is limited to in- person instruction. Guo (2015) brought in-person tutoring to an online setting by developing

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.” Many people

do not have access to in-person tutoring, or may need assistance while not at school. This tool utilizes Python Tutor to help students who need assistance, who might not be able to access it in person.

While Python Tutor was already being widely used to assist students, bringing it to a much larger scale and giving students access to online tutoring vastly improved the usage of this tool. Codechella created opportunities for students to collaborate on code over the web, allows web-based tutoring sessions, and allows users to share visualizations. As a tutoring tool, students can go on Python Tutor and ask for help from anyone using the program, get help in real time, communicate with their tutor using an embedded text chat, and view the tutor’s cursor and typed text. In a study of over 96,000 actions logged on Codechella, the 4 main actions and their frequency were Run (6%), Step (57%), Open Editor (6%), and Chat (31%). This shows how frequently users utilized the stepping visualization tool as well as the text chat.

Using Visualization Tools to Ease the Transition Between Languages

A study transitioning from Python to Java, done by Holvitie, Rajala, Haavisto, Kaila,

Laakso, Salakoski (2012), explored using an interactive tutorial that utilized visualization tools to help ease the transition. The tutorial was designed to “underline the syntactical and structural differences between Python and Java” (2012). They believe the transition should be as effortless as possible, and that providing similarities, as well as differences, between the two languages is useful to ease the transition.

For the tests, a tool called ViLLE was used, which provided a visual and interactive tutorial for students and gathered data about their results. Participants began with a pre-test on

Python knowledge. In the tutorial, participants were briefly explained the similarities and differences between concepts in Python and Java. Then, they were given multiple visualization

exercises using ViLLE about the explained topics. The concepts covered in the tutorial were: variables, output, conditional statements, while- and for-loops, and procedures and functions.

After the tutorial they were given a post-test, similar to the pre-test. The results showed that students improved overall on the post-test, and when asked about the usefulness of the tutorial, their feedback showed that they found ViLLE very useful for transitioning languages.

Through this research, it has been shown that the transition between programming languages, mainly from Python to Java, is widely viewed as a difficult task. Python is widely used as an introductory tool to learn computer science, and more complex languages, like Java, are taught immediately following Python in many curriculums. Many tools exist to help ease this transition, and many researchers are putting work into finding new ways to tackle this issue.

Python Tutor is already a widely used tool to visualize Python concepts, and use that information to help learn Java concepts. It is useful as well to teach the similarities and differences between the two languages, to help students understand how to transition from one to another.

CHAPTER 2

UTILIZING PYTHON TUTOR AND SKULPT

Python Tutor

Python Tutor is an online, interactive environment for programmers to visualize the execution of code in many languages. The research in this thesis focuses on utilizing these tools for the Python language. The core functionality of Python Tutor is the Visualize Execution tool.

This tool allows users to write and run Python code in the browser and provide a visual representation to the user that corresponds with how their code runs. Two features that are important to this research are the stepping tool, and the stack trace visualization.

Stepping Tool

The stepping tool allows users to step line by line through their Python code to visualize the impact each individual line has on the program. This tool is useful for debugging issues, as well as helping users thoroughly understand how a certain portion of their code works. Users may step forward through their code, and also take steps backwards to reverse the impact of certain lines of code on their program. Console output is also displayed in the web browser in correspondence to what step the user is currently on. With this feature, users may visualize how their code directly affects console output and leads to a deeper understanding of their program.

FIGURE 1. Three separate stages of execution for a simple Python program.

This feature is important to the research as it will allow users who are visualizing code using Turtle graphics to step through their program and understand how each line of code affects their Turtle object and its graphics. Viewing the entire Turtle drawing sequence at once may be

overwhelming to someone new to programming, and difficult to follow, depending on the complexity of the program. This assists the user in understanding Turtle graphics by breaking down the drawing process step by step.

Stack Trace Visualization

The stack trace visualization tool allows users to visualize the inner workings of their program in an easy to process manner. Variables from the program are displayed by their given name and value; they are updated alongside the stepping tool to reflect the value of those variables after a given line is executed. Also, structured objects such as lists are represented using arrows to point from variable names to values, to help users visualize the structure of a list and similar data types.

FIGURE 2. A partially executed Python program showing the stack trace visualization at the current point in the program.

This tool benefits users by allowing them to see the values of variables changing in real time in response to the tasks their program is performing.

This feature is important to the research as it will allow users to visualize important attributes of the Turtles as they change in response to the written code. Being able to see these variables change in response to written code will give the user a deeper understanding of how their code works and will help to reinforce important concepts of Object Oriented Programming, like initializing objects, calling methods on objects, and instance variables.

Skulpt

For my research, Skulpt was utilized as a tool to be able to step line-by-line through a

Python program that uses Turtles. Skulpt provides an interactive editor, in which users may enter single lines of Python code that when executed, update a persistent graphical environment. This is useful because, unlike Python Tutor, Skulpt can process code that uses Turtle objects. As a user enters a new line of code, Skulpt changes the drawing in real time whenever the line of code updates the drawing via a Turtle object.

FIGURE 3. Python code being executed line by line in the Skulpt interactive editor to draw Turtle graphics.

FIGURE 4. The graphics that result from executing the Python code in FIGURE 3.

Python Tutor and Skulpt

Skulpt was used to create step-by-step graphical updates for the Turtle graphics on the

Python Tutor webpage. By sending the code to Skulpt as it was stepped through line by line,

Skulpt was able to update the Turtle graphics at the same time the user was visualizing the stack trace in Python Tutor. This not only gives the user a visual representation of the Turtle object in real time, but also a visual representation of the Turtle graphics is real time. Having these two visualizations side by side gives the users a chance to compare their code to the instance variables of their object and the graphics simultaneously.

Modifying Python Tutor

The standard graphical user interface package for Python is called Tkinter. Python Tutor does not currently have support for Tkinter or Turtle graphics, so support had to be added to be able to visualize Turtle graphics. Python Tutor allows developers to whitelist imports, but does not necessarily promise to have the methods to handle them. First, the Tkinter and turtle Python

modules had to be whitelisted in Python Tutor. In addition to whitelisting these modules, python- tk had to be installed on the computer that was used to run the Python Tutor server.

Once the modules were whitelisted, code had to be written to allow Python Tutor to correctly interpret the Python code that included Turtle objects. In Python Tutor, once a user writes Python code, it is sent to the backend for execution using the Python bdb debugger. The backend generates and gathers an execution trace that represents the state of the environment at each step of the code. Finally, this execution trace is sent back to the frontend in JSON format. The frontend parses the execution trace, and using a visualization display, renders the current stack frame, heap objects, and pointers. As the user interacts with the frontend and steps through their code, the frontend renders the data structures using only the original execution trace. This means that after the Python code is initially run, there are no further calls to the backend.

To add Turtle support to the Python Tutor, backend code was written to allow Turtle objects to be added to the execution trace so that it would be properly displayed on the frontend.

The code checks for data that is of the Turtle type, turtle.Vec2D. Once data of that type was found, a new object was created with a unique id. The object is then added to a list of heap objects using the new id and it is also formatted to represent a Turtle using JSON format. Then, the JSON representation of the Turtle is included in the execution trace. Since the Turtle has a

JSON representation in the execution trace, the attributes of the Turtle can be displayed to the user without any frontend modification.

FIGURE 5. Modified Python Tutor execution trace visualization to show the amount of rotation and the xy coordinates for a Turtle object.

Integrating Skulpt into Python Tutor

The frontend of Skulpt’s interactive editor consists of two main parts: a text input area, and a canvas to display the Turtle graphics. Since Python Tutor already has a frontend implementation for text input, only the canvas needed to be embedded to the frontend. The main challenge for the Skulpt implementation was to send the Python code from Python Tutor to the

Skulpt backend, interpret that Python code correctly, then send the proper changes of the graphics to the canvas to be displayed. The Skulpt backend works by taking one or multiple lines of Python code, checking to make sure the lines are balanced, then executing the code and visualizing the Turtle graphics on the canvas.

To send the Python code from Python Tutor to the Skulpt backend, each line is sent individually after it is stepped through by the Visualizer. Once a line is stepped through, the code from that line is captured from Python Tutor, and executed using a modification of Skulpt’s method of displaying Turtle graphics. In the Skulpt implementation, the display function is encapsulated in an infinite loop, and includes a function that waits for the user to input a line of code before it is executed. To integrate Skulpt within Python Tutor, since the code is already available and not entered by the user a line at a time, the display function is called when the user

presses the Next button on the Python Tutor Visualizer, and passes the current line through the parameters so that it may be drawn in the graphical environment.

To configure where the Turtle graphics are sent, the Skulpt environment needs to be configured to direct the graphics to the HTML canvas on the Python Tutor visualizer page. This configuration takes place in the Python Tutor Visualizer page so that when the page loads, the environment is ready. An important element when setting up the graphics environment was to configure Skulpt so that global variables are persistent. That is, when a new line of code is sent to the Skulpt environment, the new drawing should be added to the current graphical environment. Without the environment retaining these global variables, previously executed graphics would be overwritten whenever a new drawing instruction is added; this has the effect of erasing the canvas every time a new graphic is drawn.

FIGURE 6. Python Tutor working with Skulpt to produce an execution trace and Turtle graphics for a simple sequence of Python code.

For Loop Support

Python Tutor and Skulpt have similar, but not identical, methods of executing Python code in a step-wise manner. When Python Tutor encounters a for loop, the stepper will continue to read each line that composes the for loop, including the first line that creates it, every time the loop iterates. This is necessary to accomplish the visualization of the loop. If Skulpt encounters a for loop, it will interpret the entire loop as one statement, and execute it all at once. This presents a conflict when handling loops since Skulpt is to be integrated within Python Tutor.

The solution was to write code to manually handle simple for loops. When a loop of this pattern for x in range(y) is encountered, the program will strip the x and y, and add the incremented variable x into a map to store all of the iterated variables in the case of nested for loops. The program simultaneously runs a line of Python code in the execution environment to declare and initialize the iterated variable. When Python Tutor sends Skulpt the for loop declaration line again, it will check to see if a for loop with that variable already exists. If so, it will ignore that line and will send a line of Python code to the environment to increment the variable. This allows the iterated variable to increase every time the “for” line is read, as it would in any for loop. The lines of code in the body can be executed normally due to the program executing code in the Skulpt environment to create and update the iterated variables manually.

Currently, this only works for simple for loops and nested for loops. Further implementations will add support for more complicated for loops syntax.

FIGURE 7. Stepping through the code has been stopped after the third iteration of the For Loop. After three iterations, the Turtle graphics have been drawn for three sides of a square, and the stack trace visualizes the Turtle’s rotation and position at that instance.

Weakness

To generate the runtime visualization of Python code that includes Turtle graphics,

Python Tutor executes the code server-side to collect stack trace information from the debugger.

To create the Turtle graphics on the web browser window, Skulpt executes the code client-side in the web browser. This introduces a weakness as when code with Turtle graphics executes server- side, a graphics window is created on the machine hosting the Python tutor server. If multiple users are connected to the server, this server-side graphics window will be updated every time

Turtle code is executed. This is an issue as it creates a heavy load for the server and will lead to poor performance. Additional work is needed to eliminate creating this graphics window server- side, while still collecting the trace data needed by Python Tutor.

CHAPTER 3

STUDENT SURVEY

As part of the research of improving students’ transition from Python to Java, a survey was created for students who had recently completed CECS 274 (data structures in Java) and its prerequisite, CECS 174 (introduction to programming in Python). By surveying students who had completed both classes, it can be assumed that they had experience transitioning from

Python to Java. The purpose of this survey is to attempt to ascertain how well students transitioned from Python to Java, and how difficult that transition was for them.

To begin the survey, students are asked introductory questions about when students took

CECS 174 and 274, and how well they did in those classes, as well as inquired about Java knowledge they may have acquired prior to taking CECS 274. Then, students are asked to rate how well their knowledge of certain concepts taught in Python helped them to transition to those same concepts in Java. The data from these questions will be used to evaluate how well these concepts are being taught in Python. Then, students are asked to rate how well their total Python knowledge prepared them to learn certain new concepts in Java. The data from these questions will be used to evaluate how well these concepts are able to give students a solid foundation to learn new concepts in Java.

Currently, the survey is under review from the Institutional Review Board at California

State University Long Beach. This is a review process that all forms of research that use human

test subjects must undergo. Once the survey has been passed through the review board, it will be administered to students in Fall of 2019.

CHAPTER 4

CONCLUSION

There are difficulties presented for students when transitioning between programming languages. The transition from Python to Java can be especially difficult for students who do not understand the core concepts of Python before attempting to learn Java, and for students who do not quickly grasp the concepts of Object Oriented Programming. One way to ease the transition between these two languages is the utilization of visualization tools. By using Skulpt to allow the writing of Python code with Turtle graphics into Python Tutor, students may step though the code to better understand how each individual line of code affects the graphics being drawn. This can be accomplished by examining the stack trace visualization provided by Python Tutor and

Turtle graphics provided by Skulpt as the student’s program is stepped through. Students may gain a better understanding of Object Oriented Programming by understanding how each line of their program affect their Turtle object. This Skulpt and Python Tutor integration will give students a tool to better understand Object Oriented Programming, and ease their transition from

Python and Java.

APPENDIX

PYTHON TO JAVA TRANSITION SURVEY

Python To Java Transition Investigator: Christian Blydt-Hansen Project Contact: [email protected]

You are being asked to participate in a research study.

The purpose of this project is to gather data from students who took CECS 174 in Python, and CECS 274 in Java, to evaluate how well concepts from Python transition to Java, and how difficult it is to transition between languages. The results of this study will be used to evaluate how well this transition between programming languages is being taught at CSULB, and to potentially modify the curriculum to better suit the needs of students and to improve the ease of transitioning. You will be asked to complete a 10 minute survey about your experience with Python and Java in CECS 174 and 274.

The risks to participating in this study include loss of confidentiality. The investigator will make every attempt to reduce these risks by not linking any personal information to any individual responses. In addition, all information will be securely stored and only be accessible by authorized personnel.

You may not directly benefit from participating in this study. However, the results of this study may benefit students at CSULB and other institutions in transitioning between programming languages. Once you complete the survey, you will be provided with a link to another google survey where you will be able to enter the raffle for a $25 CSULB Gift Card. Personal information given to enter the raffle will not be linked to your responses in this survey.

Any information collected from you in this study will be stored in a secure location and will not be shared with anyone who does not have appreciate provisions to access the information.

You may contact the Office of Research and Sponsored Programs at [email protected], or calling (562) 985-8147, if you have questions about your rights as a research participant.

You must be at least 18 years of age to participate in this survey.

By clicking the NEXT button, you are confirming that you are AT LEAST 18 YEARS OF AGE, you are agreeing to voluntarily participating in this study and the survey will begin on the next page.

Python To Java Transition Java Background Questions 1. Which of these classes are you currently taking? • CECS 277 • CECS 282 • CECS 274 • None of the above

2. When did you complete CECS 174? • Fall 2017 • Summer 2017 • Spring 2017 • Fall 2016 • Other:

3. When did you complete CECS 274? • Currently Enrolled • Fall 2017 • Summer 2017 • Spring 2017 • Fall 2016 • Other:

4. Did you use Python in CECS 174? • Yes • No

5. What grade did you earn in CECS 174? • A • B • C

6. What grade did you earn in CECS 274? • A • B • C • Currently Enrolled

7. Besides the courses in question, what other programming experience do you have? • (Short answer)

8. What level of experience in Java did you have PRIOR to starting CECS 274 (1 being the lowest, 5 being the highest)?

Python Concepts Transitioning To Java *Answers range from (1-5), (1) meaning not well and (5) meaning very well.

9. How well did your Python knowledge of DATA TYPES help you transition to Java?

10. How well did your Python knowledge of CONDITIONAL STATEMENTS help you transition to Java?

11. How well did your Python knowledge of LOOPS help you transition to Java?

12. How well did your Python knowledge of LISTS help you transition to Java ARRAYS?

13. How well did your Python knowledge of SYNTAX ERRORS help you transition to Java?

Difficulty In Learning Java Concepts Taught In Python *Answers range from (1-5), (1) meaning not difficult and (5) meaning very difficult.

14. Given your previous Python knowledge, how difficult was it to understand DATA TYPES in Java?

15. Given your previous Python knowledge, how difficult was it to understand CONDITIONAL STATEMENTS in Java?

16. Given your previous Python knowledge, how difficult was it to understand LOOPS in Java?

17. Given your previous Python knowledge, how difficult was it to understand ARRAYS in Java?

18. Given your previous Python knowledge, how difficult was it to understand SYNTAX ERRORS in Java?

Learning Java Concepts Taught In Python *Answers range from (1-5), (1) meaning not well and (5) meaning very well.

19. How well did your Python knowledge assist you in understanding PUBLIC vs. PRIVATE in Java?

20. How well did your Python knowledge assist you in understanding CLASSES, OBJECTS, and METHODS in Java?

21. How well did your Python knowledge assist you in understanding DATA STRUCTURES (E.g.: linked lists, stacks, queues and/or trees) in Java?

22. How well did your Python knowledge assist you in understanding RECURSION in Java?

23. How well did your Python knowledge assist you in understanding SEARCHING and SORTING in Java?

Difficulty In Learning Java Concepts Not Taught In Python *Answers range from (1-5), (1) meaning not difficult and (5) meaning very difficult.

24. Given your previous Python knowledge, how difficult was it to understand PUBLIC vs. PRIVATE in Java?

25. Given your previous Python knowledge, how difficult was it to understand CLASSES, OBJECTS, and METHODS in Java?

26. Given your previous Python knowledge, how difficult was it to understand DATA STRUCTURES (linked lists, stacks, queues and trees) in Java?

27. Given your previous Python knowledge, how difficult was it to understand RECURSION in Java?

28. Given your previous Python knowledge, how difficult was it to understand SEARCHING and SORTING in Java?

REFERENCES

Goldwasser, Michael H., and David Letscher. “Teaching an Object-Oriented CS1 :- with Python” ACM SIGCSE Bulletin, vol. 40, no. 3, 2008, p. 42., doi:10.1145/1597849.1384285.

Guo, Philip J., et al. “Codechella: Multi-User Program Visualizations for Real-Time Tutoring and Collaborative Learning.” 2015 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC), 2015, doi:10.1109/vlhcc.2015.7357201.

Guo, Philip J. “Online Python Tutor.” Proceeding of the 44th ACM Technical Symposium on Computer Science Education - SIGCSE '13, 2013, doi:10.1145/2445196.2445368.

Holvitie, Johannes, et al. “Breaking the Programming Language Barrier: Using Program Visualizations to Transfer Programming Knowledge in One Programming Language to Another.” 2012 IEEE 12th International Conference on Advanced Learning Technologies, 2012, doi:10.1109/icalt.2012.186.

O'Brien, Casey, et al. “Java Tutor.” Proceedings of the First ACM Conference on Learning @ Scale Conference - L@S '14, 2014, doi:10.1145/2556325.2567873.