A Constructivist Instructional Design Introducing Visual Programming To

A Constructivist Instructional Design

Introducing visual programming to

professional designers

A thesis submitted to the Graduate School

of the University of Cincinnati in partial fulfillment

of the requirements for the degree of

Master of Design

in the Myron E. Ullman Jr. School of Design

College of Design, Architecture, Art and Planning by

[Xinyu Qiu]

Previous Degree and Institution

Committee Chair [Seward, Renee]

3/10/20

ABSTRACT

A proliferation of introductory visual programming language raises the question of how to introduce VPLs to more creators and how to improve the usability and learnability of the VPL platform. This paper compares two different teaching methods and visual programming paradigm software to observe the influence of different factors on the use of visual programming software by adult learners in the designer group.

A more constructive teaching style using gamification between participants and a more behaviorist teaching style using small lecture and interaction were exposed to participants in different instruction group.

Different visual programming platforms were also tested in each group.

User experience scores based on performance score and self-reported scores were collected during and after participants operating on the visual programming software. The independent-sample t-tests were used to answer the research question that: is there a mean difference in scores for

v operating and self-rating between different instruction groups and different visual programming platform.

The test result shows that there is a mean difference in the efficiency

(performance score) between the behaviorist instruction approach and the constructivism instruction approach for using visual programming software.

The performing scores in the constructive teaching group are statistically significantly higher than the performing scores in the behaviorist teaching group. In addition, designers who exposed to the imperative visual programming software also perform better than those exposed to declarative visual programming software.

The study of constructive education in teaching visual programming language worth further exploration, in fact, under the trend of digital learning, constructive learning mechanism and the auxiliary of visual programming, a combination of both to learn programming, especially for programming beginners’ introductory courses, has a positive effect.

vii TABLE OF CONTENTS

ABSTRACT v

TABLE OF CONTENTS viii

LIST OF TABLES x

LIST OF FIGURES xi

GLOSSARY, LIST OF SYMBOLS AND ABBREVIATIONS xii

CHAPTER 1. INTRODUCTION 1

CHAPTER 2. LITERATURE REVIEW 2 2.1 Opportunity 2 2.1.1 Proliferation of VPLs 4 2.2 What is VPLs 4 2.2.1 Block-based VPLs 5 2.2.2 Node-based VPLs 8 2.3 Brief summary 11

CHAPTER 3. INSTRUTIONAL DESIGN 12 3.1 Behaviorist instructional design 14 3.2 Constructivist instructional design 16 3.3 Instructional design in experiment 18

CHAPTER 4. THE EXPERIMENT DESIGN 19 4.1 The dependent variables 20 4.1.1 Completion rate 21 4.1.2 Time-on-task 21 4.1.3 Efficiency 22 4.2 The independent variables 22 4.2.1 S4A and XOD 23 4.2.2 Behaviorist and Constructivist 23

viii 4.3 The experiment process 24

CHAPTER 5. RESULTS 26 5.1 Efficiency of instructional groups 26 5.2 Efficiency of software groups 30 5.3 Overall-score of software groups 34

CHAPTER 6. DISCUSSION AND CONCLUSION 38

REFERENCES 41

APPENDIX A 45

APPENDIX B 46

APPENDIX C 48

APPENDIX D 53

APPENDIX E 60

ix LIST OF TABLES

Table 1 Characteristics of two kinds of instructional design 13

Table 2 Instructional groups statistics for efficiency 28

Table 3 Independent samples test for efficiency in instructional groups 28

Table 4 Software groups statistics for efficiency 32

Table 5 Independent samples test for efficiency in software groups 32

Table 6 Software group statistics for overall score 36

Table 7 Independent samples test for overall score in software groups 36

x LIST OF FIGURES

Figure 1 Dependent variable measured 20

Figure 2 Observed efficiency scores in 2 instructional groups 28

Figure 3 Observed efficiency score in 2 software groups 32

Figure 4 Observed overall score in 2 software groups 36

xi GLOSSARY, LIST OF SYMBOLS AND ABBREVIATIONS

xii

xiii CHAPTER 1. INTRODUCTION

The rapid development of information technology has accelerated the pace of innovation while creating new job markets. Visual programming languages (VPLs) has played a major role in the development of low-code platforms that allow ideas to be quickly turned into prototypes. How to introduce VPLs to more creators and how to improve the usability and learnability of low code platforms based on VPLs are the themes of this study.

This study compares the use of block-based imperative VPL and node-based declarative VPL, representative low-code programs among designers. XOD and S4A will be used as representative respectively. The study also focuses on the influence of different teaching methods on learning visual programming. Behaviorist instructional design and constructivist instructional design are the main categories in the test.

1 CHAPTER 2. LITERATURE REVIEW

Willis (1995) compares the differences between traditional behaviorist principles and constructivist principles in the field of teaching. behaviorism emphasizes the order of knowledge transmission, while constructivism focuses on the nonlinear and recursive transmission. Both methods are also widely used in programming education, the research on the practical effect of two teaching methods in visual programming education is also included in this paper.

2.1 Opportunity

According to the CompTIA IT industry outlook (2019), the global information technology industry is on its pace to reach $5 trillion in 2019, it has been keeping a growth rate of 4% for 5 years since 2015. There have been many labels for the most recent waves of technology that are redefining business and society, and one of these labels is the “Fourth

Industrial Revolution.” The effect of the fourth industrial revolution is never

2 elusive but realistic, millions of jobs will be created or destroyed by technological change over the next decade. “Trend in today’s labor market is how technology is mutating jobs into new, unexpected hybrid jobs”

(JosephE.Aoun, 2010). Combining skill sets are always found in the same job, such as marketing, statistical or design and programming. In those skills, programming has been found to be the most important skill in the future (Lydia Dishman, 2016).

The skills were defined as using a computer program to write instructions to a computer as opposed to using established applications. For example, Programming languages including JavaScript and HTML for building websites, statistical programs R and SAS, AutoCAD programs for engineers, and other all-purpose programming languages such as Java,

Python, and C++.

3 2.1.1 A proliferation of VPLs

As more and more people realize that it becomes important for non- programming-skill practitioners to develop programming skills to take part in the increasingly digital world in the future job market, a proliferation of introductory programming environments designed for novice learners across all age has been observed in these years, also known as the visual programming language.

2.2 What is VPLs

Visual programming language means language for programming with graphical expression. (Chang, S.-K., 1986) A visual programming environment is one that allows the programmer to create programs by manipulating graphical elements rather than typing textual commands. A well-known example is Scratch, a visual programming language from MIT

4 that’s used to teach children. The advantages given are that they make programming more accessible to novices and non-programmers.

Among the many visual programming software for non-programmers or enthusiasts, two popular programming paradigms are widely accepted.

One is imperative visual programming such as scratch, and the other is declarative visual programming such as XOD. Imperative programming is a programming paradigm that uses statements that change a program’s state, while Declarative programming is a programming paradigm that expresses the logic of a computation without describing its control flow (Ian

Mundy, 2017). Both of these paradigms are widely used in the programming world, and their application in visual programming is one of the main topics explored in this study.

2.2.1 Block-based VPLs

Early versions of the block-based programming interfaces include

Logo Blocks (Begel, 1996) and Bridge Talk (Bonar and Liffick, 1987). In

5 addition to being used in more conventional computer science contexts, a growing number of environments have adopted the block-based programming approach to lower the barrier to programming across a variety of domains. These include mobile app development with MIT App Inventor

(Wolber, 2014) and Pocket Code (Slany, 2014); modeling and simulation tools including Star Logo TNG (Begel and Klopfer, 2007), Delta Tick

(Wilkerson-Jerde and Wilensky, 2010), Net Tango (Horn and Wilensky,

2012), and Evo Build (Wagh and Wilensky, 2018); creative and artistic tools like Turtle Art (Bontá, 2010) and Pico Blocks (The Playful Invention

Company 2008); and game-based learning environments like Robo Builder

(Weintrop and Wilensky, 2012), Lightbot (Yaroslavski, 2014), and Google’s

Made with Code initiative. led by the popularity of Scratch (Resnick et al.

2009), Snap! (Harvey and Mönig, 2010), and Blockly (Fraser, 2015), their block-based programming environment have proliferated in K-12 STEM education classes.

Block-based programming environments leverage a programming primitive-as-puzzle-piece metaphor that provides visual cues to the user about how and where commands can be used. Composing programs in

6 these environments take the form of dragging blocks into a canvas and snapping them together to form scripts. If two blocks cannot be joined to form a valid syntactic statement, the environment prevents them from snapping together, thus preventing syntax errors but retaining the practice of assembling programs instruction-by-instruction.

Recent research (David Weintrop and Uri Wilensky, 2017.) supports the claim that block-based programming environment has a direct impact on learners’ experiences with programming and their early computer science classroom learning outcomes, these impact include confidence on learning further coding knowledge, and sense of ease to use of the coding knowledge, students study block-based programming environment also show greater interests in learning more course of coding compares to students learning text-based programming languages.

S4A is a good representative of this kind of language. The main reason for choosing this environment in this study is that it could be easily tested by using the Arduino microcontroller.

7 2.2.2 Node-based VPLs

“Another large group of VPLs is the so-called node-based VPLs, they use flow-charts to represent changes of state, logic, and data.” Said by Ivan

Daniluk, a programming technology reviewer, in one of his well-known blogs named “Rethinking Visual Programming with Go”

“There are a lot attempt to make universal node-based VPls, for example, Raptor (Carlisle, 2005), Flowgorism (Gajewski, 2018) and

DRAKON (Mitkin, 2012), but the biggest popularity was found in those niche field like 3D programming for example Grasshopper, and Unreal Blueprints for game design, music synthesis like MAX/MSP” Ivan went on that “Those tools are actively and heavily used in practice by many people, but they’re still quite narrow-field and highly specialized solutions.”

XOD, as a new open-source visual programming language, well represents the node-based VPLs. “A node would be any type of block that is some sort of a physical operating device (sensor, relay, motor are all types of nodes). So pretty much a node is anything that is a physical

8 representation of many smaller levels of software/hardware working together to create an end, physical object.” Said Steven Larson in 2017.

Asked about the main differences between XOD and scratch, Victor

Nakoryakov, CTO and one of the founders of XOD, replied: “Scratch is an almost 1-to-1 projection of an imperative textual language like C or Python.

But instead of keeping all the function names and syntax nuances in the head users are encouraged to find the necessary item in the palette and drag-n-drop it to the program source code. Although it is a good introduction to the imperative programming which removes some basic fears the whole concept of imperative (Von Neuman architecture) programming is broken in the eyes of many people.”

Said by Victor Nakoryakov: “For many of them, declarative programming is a way to go. They can’t write in Python, but they are OK with HTML, CSS, complex Excel. The node-based VPLs are simply projections of declarative languages. We decided to support this segment of inventors because the other camp is already baked by Scratch”

9 Victor Nakoryakov went on to say that “Also, XOD is about electronics. When one learns electricity, circuits, components he starts thinking about part interaction in a particular way. There’s no such thing in a circuit like an instruction pointer which tells a button “You act”, which then moves to a chip telling “Your turn!”, then “LED, you have a chance to update”. All the processes happen simultaneously. XOD (like any other declarative system) mimics the same: nodes are components (ICs), links are wires. So, a novice investor doesn’t have to learn the laws of two different worlds at once.”

When asking “how would your team envision an ideal approach to educate non-programmer learners to learn your software?” Victor

Nakoryakov replied: “They should want to learn it because XOD is the quickest way to get the result they are striving for. For example, an artist is creating an installation, she is thinking about interactive lighting as one of the required aspects. She wants it, but there are so many things to do besides it… The time is ticking. And the last thing she wants is learning C++ in 21 days to make the little part about lighting. XOD to the rescue! At least, we want to make XOD the quickest and simplest tool at some point.”

10 2.3 Brief summary

Although visual programming is, to varying degrees, no complete substitute for textual programming, the emergence of such software still opens another window for beginners. In an era when more people complete self-improvement through self-learning, visual programming language lowers the threshold for learning programming. Furthermore, simply lowering the threshold for learning in preparation for a more digital age is by no means pointless in fact, improving and promoting products in this direction becomes more important.

The two representative visual programming environments XOD and

S4A (Scratch for Arduino) will be tested as independent factors in experiments introduced to creators who have relatively low programming experience.

11 CHAPTER 3. INSTRUCTIONAL DESIGN

Among the numerous studies on teaching models and learning theories, Willis (1995) compares the differences between traditional behaviorist principles and constructivist principles in the field of teaching.

In the teaching process, behaviorist emphasizes the order of knowledge transmission, while constructivist focuses on the nonlinear and recursive transmission. In terms of the definition of learning goals, behaviorist emphasizes established guided goals, while constructivist encourages students to discover goals while developing projects.

Summative evaluation is critical in behaviorism and formative evaluation is critical in constructivism. Objective data are valuable in behaviorism, but subjective data are most valuable in constructivism (Willis, 1995).

12 Table 1 Characteristics of two kinds of instructional design

The behaviorists plan instructions systematically in a top-down manner. Constructivists’ planning involves collaboration and reflection and is developmental and organic. The objective of behaviorists has guided development whereas the objective emerges from the constructivist’s

13 design and development work. In behaviorism, there need to be experts who have special knowledge, but there are no experts in constructivism.

Careful teaching of sub skills in a sequential manner is important in behaviorism. In constructivism, learning meaningful contexts is emphasized by the instructions. The aim of behavioral instructional design is the delivery of preselected knowledge. Personal understanding within meaningful contexts is expected from constructivist instructional design model.

3.1 Behaviorist instructional design

Behaviorists believe that meaning as objective existence is independent of individual experience, so individual behavior as subject is used for observation and the purpose of teaching is based on this. In real world education, instructors focus on how to present or output knowledge properly, and provide interaction and support to students when they need.

14 Structured knowledge and assignments become the exercise and assessment for students.

Structured knowledge and assignments become the exercise and assessment for students.

With the development of technology, the development of behaviorist instructional design has also led to a series of education revolutions, for example, the online education platforms that are relevant to ordinary learners. In many online education platforms such as Lynda, practice sets are used to assess eligibility for the next level of study. Behaviorist education believes that students can achieve higher levels of knowledge by learning and memorizing structured and chunked knowledge. In the early days of online education, the Internet model of behaviorism education

15 undoubtedly occupied most of the online education market, and it is no exception today.

3.2 Constructivist instructional design

Constructivist is the opposite of behaviorist in general. Constructivist scholars Dewey, and Piaget believe that meaning is generated by learners based on their own experience and cognition, rather than passively accepted. Therefore, constructivist emphasizes the types of problems students need to solve, the teaching environment students are in, what activities lead students to take the initiative to learn, and how students reflect on the learning process.

Constructivist developed diverse teaching form, the famous example is the Knowles’ papers on the study of the adult learners in the use of constructivist instructional design model, adult learners care more about the learning motivation, adult learners understand more through practice, adult learners learning in problem solving process, and finally, when the learning content has the practical value, adult learners learn better, in Knowles’ opinion, this type of learner suitable for the constructivism teaching method.

16 Online learning platforms of all ages are growing at an accelerating pace, forecast to grow to $325 billion by 2025, triple the $107 billion in 2015.

Constructivism will also benefit from more support from technology and markets. Cloud computing platforms give people control over the flexibility of information. 5G speeds up the frequency and speed of human interaction.

Ubiquitous IOT technology promises wider access to user data, while unprecedented advances in computing power make more forms of human interaction possible. These technologies make ideal online constructivism programming learning possible.

The R2D2 learning model extends the online application of constructivism teaching, where students learn through recursive and reflective learning methods (Willis, 1995), was extended for online learning environment, (Bonk and Zhang, 2008).) The recursive and reflective phases are extended to become 4 phrases which are reading, reflecting, displaying and doing.

Reading stage students understand the problem and obtain knowledge, reflecting phase students’ clear problems and construct the

17 knowledge, displaying stage students will find the method to solve the problem and presenting the knowledge, doing stage student evaluate the solution and finally internalized knowledge.

3.3 Instructional design in experiment

overall, education in the future will no doubt remain an arena in which the two approaches to teaching compete and merge, as measured by curriculum, assessment and resource use.

This study selects designers as target population to explore the application of behaviorism and constructivism in visual programming teaching for code beginners. Different programming platforms are also considered as independent factor in this study.

18 CHAPTER 4. THE EXPERIMENT DESIGN

Based on Willis’ (1995) behaviorist and constructivist instructional principles in teaching field, the study interest in if there was a mean difference in subjects’ user experience score based on the tutorial method utilized (traditional linear behaviorist method or recursive constructive instruction.) and type of VPLs (S4A imperative block-based VPL and XOD declarative node-based VPL) that subjects’ were exposed to. The independent-sample t-tests were used to answer the research question that: is there a mean difference in scores for operating and self-rating between different instruction groups and different visual programming platform.

In this experiment, user experience data was used as the dependent variable for studying visual programming environments, User experience matrix was used to express the overall performance scores of visual programming software, the overall scores is an average of 3 factors of user experience data, they are completion rate, efficiency (completion per minutes) and self-reported data of the software.

19 4.1 Dependent variables

There are three parameters to describe the subject’s user experience data, the task completion rate, the task completion per-minutes, and the self-reported data.

Figure 1 Dependent variable measured

20 4.1.1 Completion rate

The completion rate data describe the fact that how well a subject is successful in using their new application to complete the introductory tasks.

Six situations are set before the task to evaluate the task success percentage. Fully task completion without assistant is considered as the top score 4 point. Then fully task completion with assistant and partial completion without assistant is considered as score 3. The partial completion with assistant and failure without assistant are considered as score 2. Complete failure with assistant is considered as lowest score which is 1. The scores were then translated to percentage score (i.e. ¾ considered as 75% completion.)

4.1.2 Time-on-task

The time on task data indicate that how long does it take for users to complete tasks.

21 4.1.3 Efficiency

The efficiency refers to the success rate per minute of a task.

4.1.4 Self-reported scores

The post-task self-reported metrics was used as to collect users rating about the software, they used to complete the task. the visual appealing level of the environment, the confidence level when they are using the software, the usefulness of the software by their own opinion, joyfulness after complete the task by using each software, the difficulty of understand the terms used in each environment, the ease of navigation and the overall difficulty of complete a task. The final self-reported data was calculated by averaging the above-mentioned scores.

4.2 Independent variables

There are two independent variables in the experiment, they are different kinds of instructional design model, constructivist and behaviorist, exposed to subjects and different types of visual programming software, XOD and

S4A, used by subjects.

22 4.2.1 S4A and XOD

Independent variables Imperative programming based VPL software

Scratch for Arduino and declarative programming based VPL software XOD was recorded as categorical or nominal measurement scale data.

4.2.2 Behaviorist and Constructivist

Although both types of instruction model have been set to the same task goals, the ways to conduct the instruction are different.

The behaviorist instructional model is more like a guided development, with a step-by-step guide brochure and expert’s assistant by side.

The constructivist instructional model takes Bonk and Zhang’s

(2008) R2D2 model as a reference, the four stages of instruction based on the participatory and ideation game design method. The reading phase was changed to recognize cards with VPLs components; the reaction phase was changed to using cards to play a poker-like game within the group to understand the structure of the program. And then the displaying phase

23 represents by showing the card sorting within the group and talk about how their program works. Finally, as the behaviorist instructional group did, the subjects in the constructivist instructional group also need to build the program in real VPL environment and user experience data will be collected as the same as the contrast group.

4.3 The experimental process

At the beginning of each task, pre-experience with programming was asked to a subject as well as their self-deemed learning type of themselves.

In the pretest survey, subjects’ age, major and gender are also collected for further analysis.

After the pre-survey, an instruction was given to the participants by researchers. In the introduction, the main concept of different types of VPLs introduced to the subjects, and then two different types of instruction based on Willis’ (1995) behaviorist and constructivist instructional teaching methods were exposed to the subjects.

Then the subjects started the task process and researchers start to calculate the starting time and the ending time, the steps the user take to

24 complete and how many errors happened during the process. The independent variable with or with not assistant will also be measured in the process. Task completion standard was defined by making the circuits work, subjects may abandon the task or if it took too long, the researcher may stop the process and the task success score will be recorded as fail, otherwise, task success score is recorded as a success.

After the subjects complete the tasks, a post-task self-reported- survey will be given to subjects, an over-all view about the software will be collected which include the visual appealing rate, perceived efficiency rate, confidence of operation, usefulness they think, enjoyment, easy or hard to understand terminology rate, the ease of navigation rate and overall observed difficulty rate.

25 CHAPTER 5. RESULTS

5.1 Efficiency of instructional groups

There is a mean difference in the efficiency (performance score) of using the two visual programming software between the behaviorist instruction way and the constructivist instruction way.

An independent sample t-test was conducted to determine if the efficiency score of participants received the constructivist teaching method and participants received the behaviorist teaching method.

The assumption of normality was tested and met for the dependent variable efficiency scores in each instruction group. The skewness statistic for the efficiency score in the constructivist group is .320 and kurtosis is -

1.676—both within the range of an absolute value of 2.0, suggesting one form of evidence of normality of the efficiency in the constructivist group.

The skewness statistic for the efficiency score in the behaviorist group is -

.393 and kurtosis is -.567—both within the range of an absolute value of

2.0, suggesting one form of evidence of normality of the efficiency in the

26 behaviorist group. Our formal test of normality, the S-W (SW) test (Shapiro

& Wilk, 1965), suggests that our sample distribution for efficiency in the constructivist group is not statistically significantly different than what would be expected from a normal distribution (SW = .883, df = 8, Sig. = .201). Our formal test of normality, the S-W (SW) test (Shapiro & Wilk, 1965), suggests that our sample distribution for efficiency in the behaviorist group is not statistically significantly different than what would be expected from a normal distribution (SW = .955, df = 8, Sig. = .757). consider that we have a small sample size (16), we decided to conclude that we have met the assumption of normality of the efficiency scores in each of the two instructional groups.

Although Levene’s test of homogeneity produces a significant result

(p is less .05) we use the test of result when equal variances are not assumed. In this case, the result is based on a correction for a lack of homogeneity of variance.

The independence was met with each group, for participants performing on their test independently.

27 Table 2 Instructional groups statistics for efficiency

Figure 2 Observed efficiency scores in 2 instructional group s

Table 3 Independent samples test for efficiency in instructional groups

28 As shown in Table 2, efficiency refers to participants’ performance data were generated from samples of 16 designers, 8 of them were randomly assigned to the behaviorist group (SD = 10.23%) and 8 of them were randomly assigned to the constructivist group (SD = 23.18%). The independent t-test, as shown in Table 3, indicated that the means for efficiency scores were significantly different for people participate in the behaviorist group and people participate in the constructivist group (t = -

2.316, df = 9.628, p = 0.044). Thus, the null hypothesis that the efficiency means in the two groups is the same was rejected at .05 level of significance.

The effect size d (Cohen’s d) (calculated using the pooled standard deviation) was 1.158. Using Cohen’s (1988) guidelines, this is interpreted as a large effect. The results provide evidence to support the conclusion that the behaviorist group and the constructivist group differ in efficiency data, on average. More specifically, participants in the constructivist group were observed to have better efficiency in complete the task, on average, than participants in the behaviorist group.

5.2 Efficiency of software groups

There is a mean difference in the efficiency (performance score) between using Scratch for Arduino and XOD. An independent sample t-test was conducted to determine if the efficiency score of participants using S4A and participants using XOD. The assumption of normality was tested and met for the dependent variable efficiency scores in each software. The skewness statistic for the efficiency score in S4A is .449 and kurtosis is -

1.364—both within the range of an absolute value of 2.0, suggesting one form of evidence of normality of the efficiency in S4A group. The skewness statistic for the efficiency score in the XOD group is -.688 and kurtosis is

.084—both within the range of an absolute value of 2.0, suggesting one form of evidence of normality of the efficiency in XOD group. Our formal test of normality, the S-W (SW) test (Shapiro & Wilk, 1965), suggests that our sample distribution for efficiency in S4A group is not statistically significantly different than what would be expected from a normal distribution (SW =

.894, df = 8, Sig. = .253). Our formal test of normality, the S-W (SW) test

30 (Shapiro & Wilk, 1965), suggests that our sample distribution for efficiency in XOD group is not statistically significantly different than what would be expected from a normal distribution (SW = .936, df = 8, Sig. = .572). consider that we have a small sample size, we decided to conclude that we have met the assumption of normality of the efficiency scores in each of the software groups.

Although Levene’s test of homogeneity produces a significant result

(p is less .05) we use the test of result when equal variances are not assumed. In this case, the result is based on a correction for a lack of homogeneity of variance.

The independence was met with each group, for participants performing on their test independently.

31 Table 4 Software group statistics for efficiency

Figure 3 Observed efficiency score in 2 software groups

Table 5 Independent samples test for efficiency in software groups

32 As shown in Table 4, efficiency refers to participants’ performance data were generated from samples of 16 designers, 8 of them were randomly assigned to S4A group (SD = 19.65%) and 8 of them were randomly assigned to activity group (SD = 7.53%). The independent t-test, as shown in Table 5, indicated that the means for efficiency scores were significantly different for people participate in the S4A group and people participate in the XOD group (t = 3.749, df = 9.012, p = 0.005). Thus, the null hypothesis that the efficiency means in the two groups is the same was rejected at .05 level of significance.

The effect size d (calculated using the pooled standard deviation) was 1.875. Using Cohen’s (1988) guidelines, this is interpreted as a large effect. The results provide evidence to support the conclusion that the S4A group and XOD group differ in efficiency data, on average. More specifically, participants in the S4A group were observed to have better efficiency in complete the task, on average, than participants in the XOD group.

33 5.3 Overall-score of software groups

There is a mean difference in the overall score (averaged performance and rating) between using Scratch for Arduino and XOD. An independent sample t-test was conducted to determine if the overall score of participants using S4A and participants using XOD. The assumption of normality was tested and met for the dependent variable overall scores in each software.

The skewness statistic for the overall score in S4A is .308 and kurtosis is -

1.169—both within the range of an absolute value of 2.0, suggesting one form of evidence of normality of the overall scores in S4A group. The skewness statistic for the overall score in the XOD group is .834 and kurtosis is .399—both within the range of an absolute value of 2.0, suggesting one form of evidence of normality of the overall scores in XOD group. Our formal test of normality, the S-W (SW) test (Shapiro & Wilk,

1965), suggests that our sample distribution for overall scores in S4A group is not statistically significantly different than what would be expected from a normal distribution (SW = .932, df = 8, Sig. = .531). Our formal test of normality, the S-W (SW) test (Shapiro & Wilk, 1965), suggests that our sample distribution for overall scores in XOD is not statistically significantly

34 different than what would be expected from a normal distribution (SW =

.912, df = 8, Sig. = .368). consider that we have a small sample size, we decided to conclude that we have met the assumption of normality of the overall scores in each of the software groups.

Levene’s test of homogeneity produces a non-significant result (p larger than .05) suggest that we have met the assumption of homogeneity.

The independence was met with each group, for participants performing on their test independently.

35 Table 6 Software group statistics for overall score

Figure 4 Observed overall score in 2 software groups

Table 7 Independent samples test for overall score in software groups

36 As shown in Table 6, overall score refers to participants’ performance data and rating data were generated from samples of 16 designers, 8 of them were randomly assigned to S4A group (SD = 11.31%) and 8 of them were randomly assigned to activity group (SD = 7.31%). The independent t-test, as shown in Table 7, indicated that the means for overall scores were significantly different for people participate in the S4A group and people participate in the XOD group (t = 2.090, df = 14, p = 0.055). Thus, the null hypothesis that the efficiency means in the two groups is the same was rejected at .1 level of significance.

The effect size d (calculated using the pooled standard deviation) was

1.045. Using Cohen’s (1988) guidelines, this is interpreted as a large effect.

The results provide evidence to support the conclusion that the S4A group and XOD group differ in overall data, on average. More specifically, participants in the S4A group were observed to have a better overall score in using the software, on average, than participants in the XOD group.

37 CHAPTER 6. DISCUSSION AND CONCLUSION

The study of constructivist instructional design in teaching visual programming language worth further exploration, in fact, under the trend of digital learning, constructive learning mechanism and the auxiliary of visual programming, a combination of both to learn programming, especially for programming beginners’ introductory courses, has a positive effect.

Comparing two types of VPLs, imperative and declarative, the subjects are more likely to accept the imperative programming way, in this case, the S4A, considering the widespread of Scratch using in introductory courses, designers may be exposed to more or less similar programming in different situations, thus to be more familiar with S4A, and for the newcomers declarative programming environment XOD unfamiliar. The loop system of building a program in XOD is also more difficult than using

S4A, to increase the cognitive load in using XOD. Further experiments may be needed to test differences in the efficiency of using different software at higher task complexity.

38 Interestingly, the subjects also showed significant differences in how aesthetically pleasing the XOD was compared to S4A, with a much higher aesthetically pleasing XOD than S4A. The possible reason is that XOD has relatively constant color used and consistency to other software, while S4A is more teenager oriented, with more vivid and rich colors, and relatively lower consistency relates to other software used by adults. Adult designers tend to prefer the XOD user interface.

Besides, doing a two-way ANOVA, we found that the constructive way shows significant improvement in the S4A group than in the XOD group. It is also possible that different levels of familiarity and complexity affect the efficiency of using the two software.

In general, the experiment by comparing different programming methods and different teaching methods, to a certain extent, given the adult designers, the constructive education mode can help to learn programming, the future of online education should also consider using constructive way of teaching which would lead to more self-serviced and more efficiency in

39 learning situation. The value of visual programming will also be more widely recognized by learners through the constructive teaching method.

40 REFERENCES

Willis, J. (1995). A Recursive, Reflective Instructional Design Model Based on Constructivist-Interpretivist (Vol. 35).

Anne Weegar Dina Pacis, M. (2012). A Comparison of Two Theories of

Learning-Behaviorism and Constructivism as applied to Face-to-Face and

Online Learning.

Weintrop, D., & Wilensky, U. (2017). Comparing block-based and text- based programming in high school computer science classrooms. ACM

Transactions on Computing Education, 18(1), 1–25.

Malcolm Knowles. (1973). The Adult Learner: A Neglected Species.

Bonk, C. J., & Zhang, K. (2006). Introducing the R2D2 model: Online learning for the diverse learners of this world. Distance Education, 27(2),

249–264.

Tom Tullis & Bill Albert. (2013). Measuring the User Experience: Collecting,

Analyzing, and Presenting Usability Metrics.

41 Lomax, R. G., & Hahs-Vaughn, D. L. (2012). An introduction to statistical concepts (3rd ed.). New York: Routledge.

IT Industry Outlook 2019. (2019).

Chang, S.-K. (1986). Visual Languages: A Tutorial and Survey.

Department, A. B.-E. and C. S., MIT (1996). LogoBlocks: A graphical programming language for interacting with the world.

Bonar, Jeffrey G; Liffick, Blaise W. (1987). A Visual Programming Language for Novices.

Turbak, F., Sherman, M., Martin, F., Wolber, D., & Pokress, S. C. (2014).

EVENTS-FIRST PROGRAMMING IN APP INVENTOR.

Slany, W. (2014). TINKERING WITH POCKET CODE, A SCRATCH-LIKE

PROGRAMMING APP FOR YOUR SMARTPHONE.

Begel, A., & Klopfer, E. (2004). StarLogo TNG: An Introduction to Game

Development.

42 Hoda Wilkerson-Jerde, M., & Wilensky, U. (2007). Wilensky, 2003), representational infrastructure shift

Horn, M. 2012). NetTango: A mash-up of NetLogo and Tern.

Wagh, A., & Wilensky, U. (2018). EvoBuild: A Quickstart Toolkit for

Programming Agent-Based Models of Evolutionary Processes. Journal of

Science Education and Technology, 27(2), 131–146.

Bontá, P., & Silverman, B. (2010). Turtle, Art, TurtleArt Artemis Papert,

Weintrop, D., & Wilensky, U. (2012). RoboBuilder: A Program-to-Play Constructionist Video Game.

Danny Yaroslavski (2014). How does Lightbot teach programming?

John Dewey. (2009). Between Pragmatism and Constructivism

Von Glasersfeld, E. (1982). AN INTERPRETATION OF PIAGETS

CONSTRUCTIVISME.

Carlisle, M. C., Wilson, T. A., Humphries, J. W., & Hadfield, S. M. (2005).

RAPTOR. ACM SIGCSE Bulletin, 37(1), 176.

43 Gajewski, R. R. (2018). ALGORITHMS, PROGRAMMING, FLOWCHARTS

AND FLOWGORITHM.

Mitkin, S. (2012). DRAKON-Erlang: Visual Functional Programming.

Charles, J.-F. O. (2008). A Tutorial on Spectral Sound Processing Using

Max/MSP and Jitter.

SS Shapiro, MB Wilk – Biometrika. (1965). An analysis of variance test for normality (complete samples)

44 APPENDIX A RAW DATA

Instruction environmen pre- time on way t date major experience completion task efficiency lecture XOD 2/12/20 ID 50% 75% 5.8 12.90% lecture S4A 2/12/20 Mdes 0% 75% 2.38 31.50% lecture XOD 2/3/20 Mdes 50% 75% 3.75 20.20% lecture S4A 1/29/20 ID 50% 100% 3 33.30% lecture XOD 1/28/20 ID 25% 75% 5.03 14.90% activity S4A 2/7/20 Mdes 100% 100% 1.39 71.90% activity S4A 2/7/20 Mdes 0% 75% 1.47 51% activity S4A 2/7/20 Mdes 0% 100% 1.38 72.40% activity S4A 2/7/20 Mdes 25% 75% 1.48 50.60% activity XOD 2/13/20 Mdes 25% 75% 3.35 22.38% activity XOD 2/13/20 Mdes 25% 75% 3.1 24.20% activity XOD 2/13/20 ID 0% 100% 3.83 26.10% activity XOD 2/13/20 ID 25% 75% 5.71 13.10% lecture S4A 2/13/20 Mdes 0% 75% 2.63 28.50% lecture S4A 2/13/20 Mdes 25% 75% 3.55 21.10% lecture XOD 2/12/20 Mdes 50% 50% 15 3.33%

visual perceived overall overall appeal efficiency confidence usefulness enjoyment term navigation difficulty rating score 100% 75% 75% 75% 50% 25% 75% 100% 71.80% 53.20% 75% 75% 100% 100% 75% 50% 100% 100% 84.30% 63.60% 75% 100% 50% 50% 75% 25% 100% 75% 68.70% 54.60% 0% 25% 50% 50% 50% 75% 25% 25% 37.50% 56.90% 100% 25% 75% 75% 50% 75% 100% 75% 71.80% 63.90% 75% 75% 100% 75% 100% 0% 75% 75% 71.80% 81.20% 50% 25% 25% 50% 50% 25% 50% 25% 37.50% 54.50% 75% 75% 100% 75% 100% 25% 50% 50% 68.70% 80.30% 50% 100% 100% 100% 75% 75% 100% 50% 81.20% 68.90% 75% 50% 50% 50% 75% 100% 100% 25% 65.60% 54.30% 75% 50% 25% 25% 100% 50% 50% 50% 53.10% 50.70% 75% 100% 100% 100% 100% 50% 75% 50% 81.20% 69.10% 75% 75% 50% 75% 75% 50% 75% 50% 65.60% 51.20% 75% 100% 100% 100% 100% 100% 100% 100% 96.80% 66.70% 25% 75% 50% 25% 25% 100% 75% 75% 56.20% 50.70% 100% 75% 75% 100% 75% 75% 100% 50% 81.20% 44.80%

45 APPENDIX B EVALUATION SHEET

47 APPENDIX C GUIDE BOOK FOR BEHAVIORIST GROUP

Task 1: Create a trafic-light with LED

A traffic light is a good example of a device which does its job sequentially and repeatedly. In its simplest form a traffic light has three states:

Green — go Yellow — stop if you can Red — stop!

Each state is active for some time interval and when done everything starts from the beginning and repeats again and again.

Program overview

Cells make up tissues, tissues make up organs, organs make up systems, programs in XOD can have structural relation- ships just like the human body. This kind of joined relationship creates infinite possibilities for programming, often referred to as object-oriented programming.

In task1, the main program is responsible for boot up the operation, lighting up in sequence and playing in loop, and the sub-program is responsible for the lighting process of each LED

1. Start build the program

Create a new project in XOD and name it something like my-traffic-light. Now you have a program with a single patch main. What’s next?

48 Task 1: Create a trafic-light with LED

2. Set up

We have a state machine that we’re going to implement. There are several ways to do the job. Let’s consider one of them. The basic idea is to have one patch node per state and a joining patch that will wire the state patch nodes together. In our case: state-green state-yellow state-red main — the joining patch We plan to (a) create drafts for all state patches, (b) craft the main patch, and (с) after that complete the state patches. You can do things in reverse if it makes more sense to you.

We already got the main, so create the state patches. Hit “File / New Patch” (or Ctrl+N) and enter the new patch name. Repeat three times.

3. Make the paches talk to each other

Now we need a mechanism allowing patch nodes to talk to each other. A common idiom is to make a pulse input on a state patch to enter that state and add pulse outputs to notify about state completion.

Add a pair of xod/patch-nodes/input-pulse and xod/- patch-nodes/output-pulse to each state patch:

49 Task 1: Create a trafic-light with LED

4. How about the main program

Now each of our states has an input and output. We can wire them in a daisy chain so that when one state completes its job, it gives the control to the next state. Let’s do it on main:

We gave shorter labels “Green,” “Yellow,” and “Red” to our nodes so the text could fit the width.

Nice, isn’t it? You see how the device should work graphically.

5. Implementing state patches

OK, we’ve got a basic state patch skeleton, let’s fill it up. You’re going to answer few questions before doing that.

What should a state do once entered? When should it exit? What should it do right before exit? In our case, when we enter a state it should turn on the corresponding LED. Then it should wait few seconds, turn the LED off and then exit. Pretty simple. Do it for the state-green

Set proper values for led’s port (port 2) and T of the delay (3 seconds is fine for the experiment).

We have done with the green. Are yellow and red differ anyhow? Not in our case. Just replicate the patch on state-yellow and state-red. Do not forget to adjust PORT and T values. Use copy/paste to do it quickly.

50 Task 1: Create a trafic-light with LED

6. Running the sequence

We are almost done. The only thing left is triggering the execution. Look at the main again:

Although the states are correctly chained, nothing would trigger entering the first state (i.e. the state-green). We want our traffic light to start its job right when the device is pow- ered up. So a pulse from the boot node is the best choice:

Finally, upload the program to your board and see how they behave.

Whoa, it works! Almost. Once the red state completes the traffic light does nothing. Let’s fix it

7. Making a cycle

The device suspends after the last state because nothing returns it back to the first state. We could link the last state DONE pulse to the first state SET pulse to complete the loop, but unfortunately, XOD does not allow to do so.

XOD forbids cycles in a program graph to avoid possible deadlocks. No deadlocks are possible in our particular scenario because we use delay nodes but XOD is not smart enough to figure it out.

Luckily so-called “defer nodes” are here to help us. They can break any cycle and tell XOD: “Hey, I’m the point where you can take a breath if a deadlock happens”.

We deal with pulses, so we will use the defer-pulse node to break the cycle.

51 Task 1: Create a trafic-light with LED

8. Making a cycle

XOD forbids cycles in a program graph to avoid possible deadlocks. No deadlocks are possible in our particular scenario because we use delay nodes but XOD is not smart enough to figure it out.

Luckily so-called “defer nodes” are here to help us. They can break any cycle and tell XOD: “Hey, I’m the point where you can take a breath if a deadlock happens”.

We deal with pulses, so we will use the defer-pulse node to break the cycle.

Oops. The first state-green node input is not allowed to have links from the boot and defer-pulse at the same time. We can easily solve it by adding an any node:

Whew! Well done. Upload the program and see how it works. Play with timeout values, try to start the sequence from another state, add three more LEDs to form a complementing traffic light. Have fun!

52 APPENDIX D CARD GAME TOOL FOR CONSTRUCTIVIST

XOD GROUP

Figure 5 Rule of the constructive game

Goal How to How to get points? play?

Build your own program to win, the Build a whole At the beginning of more components the program. the game, each program used the player receives five more points you get, Add as many points cards. the first who build the as there are useful program win the components; Select one player to game. subtract as many start the game. points as there are useless components. 1 2 3

How to How to How to How to play? play? play? play?

A player receives a If true, he will show The next player The next player card from the top of his program and has the option of has the option of the deck each round. describe it to picking up picking up everyone the card thrown away the card thrown away Then he checks to see by by if his cards can fit into If not, one can choose the previous player the previous player a complete program. whether to throw or or away a useless card getting it from the getting it from the and the next player deck. deck. continues 4 5 6 7

Figure 6 Introduction to the node

How to What makes How to use calculate a complete a joker? The joker can be points program? anything you want it to be! One point for each A program that orange card. make sense. Two points for each yellow card. Three points for each blue card. Four points for each green card. 9 8

node What is node? How to use a joker? The joker can be anything you want it to be! The dark gray boxes are called nodes.

A node is a visual representation of some physical device or some function.

Figure 7 Introduction to the system

input-pins

node What is How do boot pin? I trigger a program? output-pins

The small colored The “boot” node circles on the nodes outputs a single pulse are called pins. when the program starts. They are used to transfer data between nodes.

Pins are divided into CORE inputs and outputs.

imagine something like a flash. Itʼs basically a message pulse to trigger something else. data What is How do boot

number data can be integer data? I trigger number or floating-point number decimal. a program? data

boolean data have only who The “boot” node possible values: True (aka logic boolean one, high signal)and False outputs a single pulse data (aka logic zero, low signal). when the program

port data represents the actual starts. pin number on the board port (i.e. D1-13, A0-5). data

generic data can be any generic data-type you want it to be. data CORE

Figure 8 Core components to build a program

How do any How do any I create I create a loop? a loop?

Pulses on output when Pulses on output when any input recieves a any input recieves a pulse pulse

CORE CORE

How do select How do select I create I create a conditional a conditional statement? statement? Outputs `Xn` value Outputs `Xn` value based on which `Sn` based on which `Sn` pulse came last. By pulse came last. By default outputs the default outputs the value of the latest value of the latest `Xn` input. `Xn` input.

CORE CORE

Figure 9 Common hardware to build a program

PORT VAL ACT PORT VAL ACT

How servo How servo about a about a ACK ACK servo motor? servo motor?

Quickstart hardware Quickstart hardware control node for control node for hobby RC servos. hobby RC servos.

PORT The pin controls servo-motor PORT The pin controls servo-motor

VAL Triger pulse VAL Triger pulse

ACT Makes the servo react to ACT Makes the servo react to incoming values incoming values while `ACT` is true while `ACT` is true

HARDWARE ACK Outputs true when delay is in progress HARDWARE ACK Outputs true when delay is in progress

TRIG ECHO UPD TRIG ECHO UPD

How range-meter How range-meter about a about a Dm OK Dm OK Sonar? Sonar?

Quickstart hardware Quickstart hardware control node for control node for Ultrasonic Ultrasonic rangefinder. rangefinder.

TRIG Board port to which sensorʼs `trig` pin is connected. TRIG Board port to which sensorʼs `trig` pin is connected.

ECHO Board port to which sensorʼs `echo` pin is connected. ECHO Board port to which sensorʼs `echo` pin is connected.

UPD Triggers a new ultrasonic ping. UPD Triggers a new ultrasonic ping.

OK Fires when ping is done. OK Fires when ping is done.

HARDWARE DM Last measured distance in meters HARDWARE DM Last measured distance in meters

Figure 10 Variables to build a program

How do 0 NUMBER How do 0 NUMBER

I create VAL I create VAL a constant a constant number? number? “constant number” “constant number” allows you to allows you to create a constant create a constant number, a integer, number, a integer, or a floating number. or a floating number.

PATCH PATCH

How do 0 NUMBER How do 0 NUMBER

PATCH PATCH

Figure 11 Math functions to build a program

How to and How to and do “and” do “and” logical logical operation? operation? Outputs true if and Outputs true if and only if all inputs are only if all inputs are true. true.

MATH MATH

How to or How to or do “or” do “or” logical logical operation? operation? Outputs false if and Outputs false if and only if all inputs are only if all inputs are false. false.

MATH MATH

59 APPENDIX E CARD GAME TOOL FOR CONSTRUCTIVIST

S4A GROUP

Figure 12 Rules for S4A game

Welcome Goal How to How to to get points? play? Blocky Build your own Combat!!! program to win, the Build a whole At the beginning of more components the program. the game, each program used the player receives five more points you get, Add as many points cards. the first who build the as there are useful program win the components; Select one player to game. subtract as many start the game. points as there are useless components. 1 2 3

How to How to How to How to play? play? play? play?

Figure 13 Rules for how to calculate points

What makes How to a complete calculate program? points

A complete program One point for each that make sense. orange card. Two points for each yellow card. Three points for each blue card. Four points for each green card. 8 9

How to use a joker? The joker can be The joker can be anything you anything you want it to be! How to use want it to be! a joker?

Figure 14 Variables to build a program

How do Make a variable How do Make a variable I create I create a variable? a variable? “Make a variable” “Make a variable” button button allows you to allows you to create a new variable create a new variable which can which can store values store values

VARIABLE VARIABLE

set variable to set variable to How do I name How do I name assign assign values values The “set to” The “set to” to variables? component to variables? component allows you to allows you to set your variables to set your variables to a specific value, a specific value, another variable another variable or the results of or the results of any operation. any operation.

VARIABLE VARIABLE

Figure 15 Structure to build a program

How do forever How do forever I create I create a loop? a loop?

The “forever” The “forever” component component allow you to insert allow you to insert statments and the statments and the programm will programm will execute execute the statements the statements again and again. again and again.

CONTROL CONTROL

How do when this clicked How do when this clicked I trigger I trigger a program? The “when clicked” a program? The “when clicked” component component allow you to start the allow you to start the program when click program when click and click the second and click the second time to stop it. time to stop it.

CONTROL CONTROL

Figure 16 Commands to build a program

How do digital 13 on How do digital 13 on I let a digital I let a digital pin output pin output The “digital on” The “digital on” high voltage? component high voltage? component allows you to allows you to write a high voltage write a high voltage on pin 10 to 13. on pin 10 to 13.

MOTION MOTION

How do digital 13 oﬀ How do digital 13 oﬀ I let a digital I let a digital pin output pin output The “digital off” The “digital off” 0 voltage? component 0 voltage? component allows you to allows you to write a 0 voltage write a 0 voltage on pin 10 to 13. on pin 10 to 13.

MOTION MOTION

Figure 17 Math operators to build a program

How do < How do < I compare? I compare?

The “less than” The “less than” component component allows you to allows you to compare compare two variables or two variables or the result of the result of any operation, any operation, then return true or then return true or false judgments. false judgments.

OPERATORS OPERATORS

How do > How do > I compare? I compare?

The “bigger than” The “bigger than” component component allows you to allows you to compare compare two variables or two variables or the result of the result of any operation, any operation, then return true or then return true or false judgments. false judgments.

OPERATORS OPERATORS