Abstract
This paper presents a comprehensive literature review on tangible programming languages which are designed to program real robots and robotic mechanisms. Tangible programming interfaces appear to be more accessible to novice programmers and possibly reduce the age threshold for participation, making this way robot programming an educational toy even for preschool and elementary students. Moreover, this paper makes a short examination on the resent research findings on the field of tangible robot programming and argues that the combination of tangible programming and robot construction may offer unique opportunities for educational robotics.
1 Introduction
Educational robotics (ER) is a new innovative tool for education and learning introduced in many schools with the scope to enhance higher level thinking skills and abilities and thus help students solve complex problems in other domain of knowledge [1]. With ER children build robotic entities and program by means of a simple programming language. These two procedures appear to be an ideal platform to motivate, collaborate and finally create new knowledge [2]. Several studies indicate that the ER activities have positive effects on the level of cooperation between the students, the development of critical thinking skills and problem solving [3]. An important pedagogical aspect in ER is that knowledge is established through play within a context that reinforces the reasoning of students about the decisions they make in problem solving challenges [4, 5].
To design and program a robot to do even a simple task, can prove to be extensively demanding for students, not only because of the construction of the robot itself, but also for the effort needed to develop the corresponding programming code. Focusing on programming, studies report the beneficial impact of ER on learning [6, 7] and conceptualize the increased interest of students during the learning activities toward the completion of the educational goals.
Tangible user interfaces (TUIs) for programming on the other hand appear to be a field that offers unique opportunities for learning. In many cases researchers tried to teach either simple programming concepts by guiding graphical representations on a computer screen (e.g. Algoblock [8]) or simulate and program advanced concepts, like physical motion using TUIs (e.g. Topobo [9]). In almost all cases researchers took advantage of the fact that TUIs convert physical object into programming elements and that may reduce the age threshold for participation in activities [10]. Moreover, similarly to the construction of the robot, tangible interfaces may offer equal opportunities for participation and active learning [11]. Consequently, the combination of robot construction and programming through tangible interfaces might be an attractive, easier, collaborative way to lead young student and novice adults to the world of ER.
Therefore, this paper makes a review on the field of tangible programing languages that are dedicated to program real robotic constructions. Moreover, it provides a short research review on the field providing insight to the possible benefits of this kind of tools.
2 Tangible Languages for Robot Programing
All systems are presented according to the chronological order of their development and at the end a table summaries their features.
2.1 Tortis – Slot Machine
The Slot machine [12, 13] is the first system constructed by Radia Perlman. It introduced plastic cards that could be piled into three colored stacks (red, green and blue). On the left side of each stack there is a “Do it” button. When someone presses that button, a turtle robot carries out an action, which is visible on the picture of each card of the first stack. When an action is carried out a lamp turns on below this card. The Slot machine offered the direct ability of handling the program either by adding or by rearranging and even by taking out tangible cards. Perlman also introduced special colored cards in order to “call” the program from the other stacks and so, she addressed the procedure “call” [13].
2.2 Tangible Programming for Trains
Tangible Programming for trains is a programming language for trains which created in 1998 by Genee Lyn Colobong and Martin [14]. This language became commercial product by LEGO on 2003 as the “Lego intelli – train”. Children were able to program the train’s behavior using placing cubic – commands in line. For example, if the train passes the “reverse”, then “toot sound” and then “stop” bricks. As a result will go backwards, will make the corresponding sound and it will stop until children press the “go” button. Even when the train is in motion children are able to add and rearrange the bricks and this way alter the program and the behavior of the train. Evaluating the system with real users, it was observed that the construction of the line and the placement of commands was not an instinctive process for a 4 year-old child because, in order to realize what exactly the bricks do, children used to place the bricks in front of the train triggering derailments.
2.3 Tangible Programming Using “Strings”
With this system, users can create simple programs that control robotic games [15]. The system itself consists of two separate surfaces. The first surface represents events and the second actions. The program is formed by relating events with actions, which are carried out in correspondence to events. The connection between events and action are represented with physical strings which are actually cables looking like strings.
After making the appropriate connections – relations between events (which are created by the robot’s sensors) with the actions (which are carried out in correspondence to the events) the program is ready to be uploaded to a remote robot’s memory. As a result, the robot operates according to the way described by the connections of the “strings”.
2.4 Tangible Programming Brick
McNerney’s [13] research on tangible user interfaces began in 2000 with the creation of the system “Tangible Programming Brick” that was another environment for tangible programming. The designers decided to create a one-dimension system through which users would make a sequence of commands by putting one Lego brick on top of another. In order to make the system more powerful the bricks were manufactured in a way that it was feasible to get a SIM card from the one side. Initially, this method aimed to give the potential to acquire parameters but in the process the designers realized that they could also include some other features in the slots, such as switches, sensors etc.
Finally, the results of a limited research have shown that the system was too complex for users under the age of 6.
2.5 Electronic Blocks - roBlocks
The Electronic blocks [16] is a system that lets very young children to develop programmable robotic constructions and machineries. Stacking the electronic blocks one on top of the other children are able to create programmable little robotic vehicles and simple constructions. The idea behind electronic blocks is based on three types of blocks (action, sensor and logic blocks). The action blocks make an action like move, light on etc. Sensor blocks detect events like sound, light. Finally, logic blocks play an intermediate role in the middle of action (on the bottom) and logic blocks (on the top) handling and transmitting the signals between them. Consequently, children can easily make a small robot that moves when concurrently light and sound is sensed. The pilot research conducted showed that even very young children are able to use the electronic blocks.
The roBlocks [17] is a later version similar to Electronic blocks with more functions. The evolution of roBlocks is also known today as Cubelets.
2.6 GameBlocks
This system [18] has three parts: cubes, rails, and a humanoid robot. The program is formed on a specific surface (the rails) using cubic command blocks. The relative position of the cubes describes a logical sequence, which is the program itself. The system totally has six commands (without separate parameters) to control a humanoid robot. The offered commands are: ahead, back, body to the left, body to the right, head to the left and head to the right. An interesting feature of this system is that no kind of incorporated electronics is required within the blocks as long as the identification process take place on the rails with external circuitry. Consequently, the computational power is reduced and so no computer is required since the necessary calculations might be easily supplied by microcomputers, which are incorporated in the base of the system.
2.7 Tern – Tangicons
Tern [19] is other educational tangible programming tool that consists of compact physical objects without incorporated electronic circuits and feeds. The programming elements resemble puzzle pieces and are able to control a Lego Mindstorms RCX or the iRobot Create. For the program identification users use a portable scanning system on the top of the construction. After scanning and identification of the commands topology the program is uploaded to the robot for execution. Tangicons [20] system is based on the same principles as Tern.
2.8 The PROTEAS Kit
PROTEAS (PROgramming TangiblE Activity System) kit, is an assembly of tangible and graphical tools for robot programming. It contains two tangible (T-ProRob and T_Butterfly) [21] and one graphical (V-ProRob) [22] interface. The T-ProRob (Fig. 1) subsystem may program the behavior of a NXT Lego robot and consists of 44 cubic shaped commands and parameters. 28 of these cubes represent commands and 16 smaller cubes represent parameters. Users may program the robot by snapping together the desired commands and parameters. To execute the program user has to press the “run button” on the top of the basis (“master box”). T_ProRob supports loops and conditional statements in any form and simultaneously permit users to save their code on dedicated for this purpose cubes.
2.9 Algorithmic Bricks
This is a tangible programming language, based on electronic circuits, that programs a line - tracer robot [23]. Each brick has USB connectors to ensure connectivity among the bricks and microcontrollers for the necessary computational power. The program may be extended in multiple horizontal rows instead of making one long row of commands. Finally, the bricks’ hardware, facilitate stacking to simulate the use of parameters. After the program completion, the robot must be connected to the bricks to download the program for execution.
2.10 Dr. Wagon
Dr. Wagon [24] is a quite new tangible programming toy that includes a base block, a series of wooden programming bricks and a wagon-shaped robot. The robot is accompanied with accessories to facilitate customizable appearance. The system supports commands like move forward, turn right/left, light on, make sound. Also users may use advanced programming structures like repeat and conditional statements. The system has magnets on the command blocks thus (a) it may give haptic feedback that the connection between the blocks has been made and (b) reinforces the electrical connectivity among the cubes. To better visualize the use of repeat and conditional statements the system uses stretchable blocks that may encapsulate the desired commands.
2.11 Robo-Blocks
Robo Blocks [25] is an example of active programming with embedded electronic circuits like, T-ProRob and Algorithmic Bricks. The system controls the behavior of a floor robot by snapping and adjusting the available commands blocks. Each command block has magnets and so can easily snap together.
The available commands offer movement control like, move forward/backwards, turn right/left. Some commands are also equipped with a knob and seven segment display to adjust for example for how long the robot will move forward. The robot is also equipped with a pen that may leave a trail on the floor much like the Logo turtle. Consequently, many shapes may be created by the users like rectangles, squares, polygons and of course letters.
2.12 KIBO
KIWI is the ancestor of KIBO [26] which started at Tufts University. The system is based on a robot with accessories to support personalization and a collection of wooden bricks that represent the available commands. Each wooden brick has a separate barcode sticker and for the program creation, users need to assembly the bricks in a logical sequence. For the program recognition, users need to scan each wooden block using the scanning system which is embedded on the robot. With this system users may explore concepts like parameters, loops and conditions.
2.13 T-Maze, E-Blocks, TanProRobot
These three systems were designed by the same researchers [27, 28]. T-Maze is a tangible - graphical game where children try to guide a virtual character to escape form a virtual maze. Initially, the system was based on image recognition like Quetzal and Kibo. Later researchers illustrated E-Blocks. In this case, instead of wooden blocks and visual recognition, researchers used active cubes with embedded electronics as the carriers of the programming language. Finally, their latest release is TanProRobot an active programming language with a real robot. This particular language aims to introduce children to the concepts of event handling using the robot sensors.
2.14 Primo
Primo [29] is a tangible toy which consists of a robot (cubetto), a programming board and a set of wooden instruction blocks. The system support simple commands like turn right/left, go forward and function. After snapping the wooden blocks on the programming board, children by pressing the run button, instruct the base board to recognize the blocks and transmit the program for execution to the robot.
2.15 Code-a-Pillar
Code-a-pillar [30] is a new toy by Fisher-Price for preschoolers. The system consists of a motorized head and 8 command segments that can be connected to the head. The combination of the connected segments is simultaneously the robot and the program itself. The head segment features lights, sounds and blinking eyes to make the construction attractive for children. The available command segments light up as the corresponding action happens and are “move forward” (3), “turn left” 90° (2), “turn 90 right” degrees (2) and “make sound” (1).
2.16 Development of Tangible Programming Languages
Table 1 compiles the system characteristics of the aforementioned tangible programming languages.
Although a lot of work appears to have been done in the field of construction current development efforts on tangible robot programming seam to focuses on: (a) the way these systems may effectively represent programming concepts (b) to make systems robust, autonomous and “user-friendly” (c) make constructions simple and effective (d) to reduce the cost of development and (e) to give teachers the opportunities to create a positive learning atmosphere in the classroom using accessories and new features for the robots.
2.17 Research on Tangible Programming
Recently, a number of scientists tried to study the impact of tangible programming languages in relation to traditional graphical. These studies frequently performed usability evaluations comparing tangible and isomorphic graphical languages. The main purpose was to clarify the circumstance under which tangible interfaces offer more benefits in the field of robot programming. In detail Horn et al. [11] compared a tangible programming language against a similar graphical. The study performed in informal learning setting at the Boston Museum of Science. Researchers concluded that the tangible programming language had some advantages in relation to the graphical. In particular it appeared to be more attractive and supportive for active collaboration.
Subsequently, Horn et al. [31] conducted a second study in a kindergarten using the same tangible and graphical language. Implementing qualitative analysis, it was concluded that if 5–6 year old children are given access to the appropriate technology they can create simple programs and may acquire understanding on concepts related with domain of robot programming.
Kwon et al. [23] performed a comparison between Algorithmic Bricks (tangible) and Scratch with the scope to realize whether the tangible tool was appropriate to perform ER activities. The results showed that although there were no significant differences at the domain of usability and performance, the tangible programming language was effective for early stages of learning robot programming.
Sapounidis and Demetriadis [32] explored children’s opinions regarding tangible and graphical programming. The results showed that the tangible interface was considered more attractive especially for girls, more enjoyable and finally easier to use for younger children.
Finally, using the same tools Sapounidis et al. [33] measured three variables associated with children performance upon tasks and four variables related with performance during free interaction. Data analysis showed that children produced fewer errors, made more effective debugging and younger children in particular needed less time to accomplish the robot programming tasks with the tangible subsystem. Moreover, during free interaction, elder children were more engaged, created more complicated programs and explored different commands and parameters more actively in the tangible case.
3 Conclusion
In this article, we made a review on the field of tangible programing languages for robot programming. Moreover, we offered a short research review on the field providing insight to the possible benefits of tangible languages. We argue that the combination of tangible interfaces and robots opens new avenues in the field of ER.
Undoubtedly educational robotics is a new innovative instrument for education and learning which is already present in many schools. The scope of ER is definitely to enhance higher level thinking skills and abilities through robot development and programming. The programming languages used for ER at the moment are based mostly on graphical user interfaces. Simultaneously the field of tangible programming appears to by continuously evolved and might offer a new way of interaction between robots and students.
Although, TUIs designers developed a series of systems, there are a lot of things to be done, not only at the domain of development, by also at the domain of research. On the one hand we need more tools to be available in schools and on the other hand we needed to provide empirical evidences that may clarify the circumstance under which robotics and tangibles languages offers more benefits in a real class context. Even though tangibles are believed to be more efficient (easier for younger children etc.) than graphical user interfaces, there is limited research that systematically explores the cognitive and social advantages of TUIs compared to traditional GUI solutions.
References
Blanchard, S., Freiman, V., Lirrete-Pitre, N.: Strategies used by elementary schoolchildren solving robotics-based complex tasks: innovative potential of technology. Procedia Soc. Behav. Sci. 2(2), 2851–2857 (2010)
Barell, J.: Problem-based learning: an inquiry approach. Corwin Press, Thousand Oaks (2007)
Atmatzidou, S., Demetriadis, S.: Evaluating the role of collaboration scripts as group guiding tools in activities of educational robotics: conclusions from three case studies. In: 2012 IEEE 12th International Conference on Advanced Learning Technologies, pp. 298–302 (2012)
Castledine, A., Chalmers, C.: LEGO Robotics: an authentic problem solving tool? Des. Technol. Educ. 16, 19–27 (2011)
Hussain, S., Lindh, J., Shukur, G.: The effect of LEGO training on pupils’ school performance in mathematics, problem solving ability and attitude: Swedish data. Educ. Technol. Soc. 9(3), 182–194 (2006)
Atmatzidou, S., Markelis, I., Demetriadis, S.: The use of LEGO Mindstorms in elementary and secondary education: game as a way of triggering learning. In: Workshop Proceedings of International Conference on Simulation, Modeling and Programming for Autonomous Robots, pp. 22–30 (2008)
Nourbakhsh, I., Crowley, K., Bhave, A., Hamner, E., Hsiu, T., Perez-Bergquist, A., Richards, S., Wilkinson, K.: The robotic autonomy mobile robotics course: robot design, curriculum design and educational assessment. Auton. Robots 18(1), 103–127 (2005)
Suzuki, H., Kato, H.: AlgoBlock: a tangible programming language, a tool for collaborative learning. In: Proceedings of 4th European Logo Conference, pp. 297–303 (1993)
Raffle, H. S., Parkes, A. J., Ishii, H.: Topobo: a constructive assembly system with kinetic memory. In: Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, pp. 647–654 (2004)
Marshall, P.: Do tangible interfaces enhance learning? In: Proceedings of the 1st International Conference on Tangible and Embedded Interaction, pp. 163–170 (2007)
Horn, M., Solovey, S., Crouser, R., Jacob, R.: Comparing the use of tangible and graphical programming languages for informal science education. In: Proceedings of the 27th International Conference on Human Factors in Computing Systems, pp. 975–984 (2009)
Kelleher, C., Pausch, R.: Lowering the barriers to programming. ACM Comput. Surv. 37(2), 83–137 (2005)
McNerney, T.: Tangible computation bricks: building-blocks for physical microworlds. In: Proceedings of CHI 2001 (2001)
McNerney, T.: From turtles to tangible programming bricks: explorations in physical language design. Pers. Ubiquitous Comput. 8(5), 326–337 (2004)
Patten, J., Griffith, L., Ishii, H.: A tangible interface for controlling robotic toys. In: Proceedings of CHI 2000 Conference on Human Factors in Computing Systems, pp. 277–278 (2000)
Wyeth, P., Purchase, H.: Using developmental theories to inform the design of technology for children. In: Proceedings of the Conference on Interaction Design and Children, pp. 93–100 (2003)
Schweikardt, E., Gross, M.: roBlocks: a robotic construction kit for mathematics and science education. In: Proceedings of the 8th International Conference on Multimodal Interfaces, pp. 72–75 (2006)
Smith, A.: Using magnets in physical blocks that behave as programming objects. In: Proceedings of the 1st International Conference on Tangible and Embedded Interaction, pp. 147–150 (2007)
Horn, M., Jacob, R.: Designing tangible programming languages for classroom use. In: Proceedings of the 1st International Conference on Tangible and Embedded Interaction, pp. 159–162 (2007)
Scharf, F., Winkler, T., Herczeg, M.: Tangicons: algorithmic reasoning in a collaborative game for children in kindergarten and first class. In: Proceedings of the 7th International Conference on Interaction Design and Children, pp. 242–249 (2008)
Sapounidis, T., Demetriadis, S.: Touch your program with hands: qualities in tangible programming tools for novice. In: 15th Panhellenic Conference on Informatics (PCI), pp. 363–367 (2011)
Sapounidis, T., Demetriadis, S.: Exploring children preferences regarding tangible and graphical tools for introductory programming: evaluating the PROTEAS kit. In: IEEE 12th International Conference on Advanced Learning Technologies (ICALT), pp. 316–320 (2012)
Kwon, D.-Y., Kim, H.-S., Shim, J.-K., Lee, W.-G.: Algorithmic bricks: a tangible robot programming tool for elementary school students. Educ. IEEE Trans. 55(4), 474–479 (2012)
Chawla, K., Chiou, M., Sandes, A., Blikstein, P.: Dr. Wagon: a ‘Stretchable’ toolkit for tangible computer programming. In: Proceedings of the 12th International Conference on Interaction Design and Children, pp. 561–564 (2013)
Sipitakiat, A., Nusen, N.: Robo-Blocks: designing debugging abilities in a tangible programming system for early primary school children, pp. 98–105 (2012)
Sullivan, A., Elkin, M., Bers, M.U.: KIBO robot demo: engaging young children in programming and engineering. In: Proceedings of the 14th International Conference on Interaction Design and Children, pp. 418–421 (2015)
Wang, D., Zhang, C., Wang, H.: T-Maze: a tangible programming tool for children. In: Proceedings of the 10th International Conference on Interaction Design and Children, pp. 127–135. ACM, Ann Arbor (2011)
Wang, D., Zhang, L., Xu, C., Hu, H., Qi, Y.: A tangible embedded programming system to convey event-handling concept. In: Proceedings of the TEI 2016: Tenth International Conference on Tangible, Embedded, and Embodied Interaction, pp. 133–140 (2016)
Primo toys. https://www.primotoys.com/
Fisher-price Code-a-pillar. http://www.fisher-price.com/en_US/brands/think-and-learn/index.html
Horn, M., Crouser, R., Bers, M.: Tangible interaction and learning: the case for a hybrid approach. Pers. Ubiquit. Comput. 16(4), 379–389 (2012)
Sapounidis, T., Demetriadis, S.: Tangible versus graphical user interfaces for robot programming: exploring cross-age children’s preferences. Pers. Ubiquit. Comput. 17(8), 1775–1786 (2013)
Sapounidis, T., Demetriadis, S., Stamelos, I.: Evaluating children performance with graphical and tangible robot programming tools. Pers. Ubiquit. Comput. 19(1), 225–237 (2015)
Author information
Authors and Affiliations
Corresponding author
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2017 Springer International Publishing AG
About this paper
Cite this paper
Sapounidis, T., Demetriadis, S. (2017). Educational Robots Driven by Tangible Programming Languages: A Review on the Field. In: Alimisis, D., Moro, M., Menegatti, E. (eds) Educational Robotics in the Makers Era. Edurobotics 2016 2016. Advances in Intelligent Systems and Computing, vol 560. Springer, Cham. https://doi.org/10.1007/978-3-319-55553-9_16
Download citation
DOI: https://doi.org/10.1007/978-3-319-55553-9_16
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-319-55552-2
Online ISBN: 978-3-319-55553-9
eBook Packages: EngineeringEngineering (R0)