Introduction
In the field of informatics, programming is the activity that basically consists of translating from human language to the language understood by a computer McCracken (1957).
In addition to its inherent importance in the computational sciences, learning to program provides powerful strategies for thinking, designing and solving problems Booth (1958), Howe et al. (1981), Soloway (1993). In fact, these authors describe a two-phase process, consisting of finding the problem solution and then rewriting this solution in an alternative and precise language that can be understood by the computer.
The nature of programming provides certain advantages to the user that very few mental activities can offer. For example, it allows the programmer to explore thinking processes, improve logical reasoning and increase capacity to correct mistakes Papert (1980). Moreover, the practice of programming is highly correlated with the development of a good linguistic capacity and, consequently, with a better academic performance Lehrer and DeBernard (1987), Palumbo (1990).
There are multiple studies that have confirmed the benefits of programming on young students. For example, already in the early 1970s, it was concluded in a survey conducted by Feurzeig et al. 2011 that the use of LOGO programming language could enhance the reading ability of some students, as well as increasing the interest in learning and the level of self-confidence of many of them.
At the same time, there is little disagreement about the declaration of programming as a complex activity Govender (2009). More precisely, Du Boulay (1986) identified five kinds of difficulties: lack of orientation, ignorance about the machine being employed (usually a computer), inadaptation to the language, problems of comprehension and absence of method. Although these five frequent difficulties are interconnected, students specially tend to have problems with the programming language itself. Language's syntax, that is, the collection of words and symbols that allow a human to communicate with a machine, can be excessively rigid to a novel user of a programming language. In connection with the syntax, the meaning of each of its elements forces the students to carry out processes of abstraction and reasoning that they are not always able to assume, deriving sometimes in misconceptions and wrong analogies Spohrer et al. (1985). Furthermore, it is really difficult to teach students to systematize their programming practices in order to be more efficient and make less mistakes. In this regard, the common stages recommended when programming could be summarized as follows: problem approach, language development, testing and correction/improvement.
In view of all these difficulties, what strategies should be followed for the correct teaching of programming? While being aware that each student learns in a different way, there are some accepted strategies in order to reduce, at least to a certain extent, the difficulties that arise when programming. In the first place, the choice of the programming language is key. The basic operating rules and the rigid syntax are common to all programming languages, but not all of them are equally accessible, especially from the point of view of a totally inexperienced user. The wide variety of languages available today, the majority of which are free software, render this task much easier.
Once the language has been conveniently chosen, different strategies can be carried out. Some methodological examples of successful programming teaching approaches include: simplifying and dividing problems into simpler sub-problems, defining and explaining a model based on the machine-language environment in which the student is working Statz and Miller (1978), slightly modifying sets of instructions to solve similar problems Linn and Dalbey (1985), or constantly addressing applied problems.
Learning through the use of a programming language can result more interesting and exciting for a student, and explains somehow why it has been used to teach and study mathematics during the last decades, with overall successful results, as described by Wang et al. (2015). In addition, the use of programming as a learning vehicle favours collaboration between students and the development of competencies related to autonomous learning Falloon (2016).
Currently, there are already some languages and programs focused on mathematics learning and teaching at undergraduate level, being Scratch Resnick et al. (2009) and GeoGebra Hohenwarter (2002) two of the most important by far.
Scratch possesses most of the common features that are associated to a programming language. However, its style is predominantly graphical, which differs to the vast majority of programming languages. This graphical orientation clearly reduces the initial difficulty of learning to program, but also avoids the development of some other programming skills usually acquired in the classical educational way.
The ScratchMaths project Benton et al. (2016) was developed in four schools located in London with students aged 9 to 11 years to learn mathematics through Scratch programming on four basic objectives: to explore, explain, predict and share. This project is still in progress and has recently shown that the correct design and sequencing of activities around a mathematical concept, together with the continuous help of specialized teachers, allows students to learn with interest and in a meaningful way Benton et al. (2018).
In addition, researchers such as Foerster (2016) and Akpinar and Aslan (2015) proved that the application of the Scratch language to teaching mathematics can be very successful. Thus, Foerster (2016) applied this Scratch programming methodology in a class of about 11-year-old students while developing mathematical concepts related to polygon congruence and tessellation construction. The results of this study showed that the learning process run very smoothly and pleasantly for the students, and after about two years, the students achieved an excellent knowledge of geometry in comparison with the other students who did not follow this pedagogical methodology. These results clearly demonstrate the possible long-term positive effects that this learning methodology can produce. In the same line of research, Akpinar and Aslan (2015) applied Scratch language to create a learning environment that allowed the study of probability. Although Scratch does not have specific elements for dealing with probabilistic concepts, the implementation of experimental and simulated situations was really helpful to improve students' proficiency in this branch of mathematics. The tests carried out before and after the sessions showed that the students significantly increased their knowledge of probability. At the same time, the sessions allowed students to exploit their creative facets by designing multiple games associated with random experiments.
On the other hand, GeoGebra is dynamic mathematics software, which brings together geometry, algebra, spreadsheets, graphing, statistics and calculus in one easy-to-use package. Several works confirm the advantages of using GeoGebra at undergraduate level. Zengin et al. (2012) designed an assisted instruction of trigonometry with GeoGebra that resulted more effective than the classical approach, based on constructionist theory. In the same way, Priatna (2017) showed that students being taught with the aid of GeoGebra significantly outperformed students subject to classical education in terms of mathematical representation ability. Other researchers such as Akkaya et al. (2011) proposed the learning of symmetry with GeoGebra, facilitating students to visualize, generalize and share with their classmates, producing an active and collaborative learning environment. Very recently, Masri et al. (2017) tested GeoGebra with some degree of success with a group of Malaysian students, whose mathematical level was later compared to students of the same year that had followed traditional teaching techniques. Despite there were not found significant differences between the two groups of students regarding the mathematical level acquired, students that were taught with GeoGebra clearly appreciated the use of this program during the development of the lessons. Finally, a very interesting finding was achieved by Saha et al. (2010). The use of GeoGebra to teach plane geometry did not appear as significantly better for students already possessing a high visual-spatial ability, when compared to students being taught without the help of the program. However, these differences were clearly revealed when considering students with a low visual-spatial ability, confirming the positive effects of using this software.
Another programming language, which is currently very popular is R Team (2018). This language, even though it has always been conceived as an environment for performing statistical analysis, is also endowed with a wide range of capabilities that allow its use to learn different kind of concepts while programming. Therefore, complex subjects such as mathematics could be learnt with the help of this powerful programming language.
For example, Pruim et al. (2017) have recently developed the Mosaic project, which integrates a set of functions to facilitate the introduction of basic statistics and data science concepts such as visualization, modelling and simulation. Other authors such as Mascaró et al. (2014) and Mascaró et al. (2016) have shown how beneficial can be for a university student to be taught statistics with the aid of the R language, in terms of understanding and engagement to the subject matter.
In addition, since the R language provides numerous graphical functions, it can be very useful to simultaneously acquire basic plane geometry and R programming knowledge at the undergraduate level.
Therefore, in this work we present a novel pedagogical tool to simultaneously learn plane geometry and programming based on R, which we have denominated LearnGeom. This tool is available for secondary school teachers, which may be interested in teaching plane geometry and R programming skills at the same time, and may desire to complement the use of other languages and software with this R package. It can be downloaded once the R programming language is installed in your computer (https://www.r-project.org) and after typing install.packages(LearnGeom) in the program console to install the developed LearnGeom R package. The LearnGeom R-package can also be found as a github repository in Briz-Redón and Serrano-Aroca (2018).
Basic functions of the package
The LearnGeom R package provides basic functions to treat plane geometry. Therefore, the user is expected to work on a coordinate plane in order to manipulate different geometric objects and constructions. Thus, the function CoordinatePlane allows the user to plot an empty coordinate plane with customizable limits for the X and Y axis. For example, CoordinatePlane(-5, 5, -5, 5) can be typed to set a coordinate plane in the range [-5,5] x [-5,5], which is the one used for most of the examples included in the paper. Once a coordinate plane is started, different geometric objects can be created and plotted on it. The basic geometric objects that can be utilised in this version of the package are five: points, segments, arcs, lines and polygons.
All of them can be plotted in the coordinate plane with function Draw, and the appropriate use of the methods that R offers can lead to different mathematical concepts and many kind of geometric problems. A point can be created by simply defining a two-dimensional vector in R, e.g., P = c(0,0) for the usual origin of coordinates. This definition is also used for the creation of a geometric vector to determine a direction in the plane. The coincidence of both definitions also exists if classical mathematical notations are followed. Therefore, it should not be a source of confusion for the user.
The first method to define a segment in the plane, which is the most basic one, consists of the choice of two points of the plane, P and Q, and applying the shortest path (in euclidean distance) to connect them. There is another common method to define a segment in the plane: from a starting point, choosing an angle and a length for the segment. Both possibilities can be achieved with the CreateSegmentPoints and CreateSegmentAngle functions of the package. A line, as a segment, can be defined from two points, or from a point and an angle. Moreover, there is a standard combination of parameters to characterize every line in the plane: the slope and the intercept. For this reason, CreateLinePoints and CreateLineAngle functions return a two-dimensional vector that contains the slope and intercept of the line, regardless of the way it is defined. The use of the pair slope-intercept has a problem with vertical lines, which are parallel to Y axis. In the case that the user defines a line of this kind, with any of the two available functions, the returning object will be a string two-dimensional vector. It will include the word "Inf" for the first position (infinite slope) and the constant X-value for the line in the second (as a character).
An arc is simply a part of a circumference, or even the circumference itself. The CreateArcAngle function allows the user to make an arc from a circumference with four parameters to choose: the center of the circumference, the radius of the circumference and the two angles, from 0 to 360 degrees that determine the part of the circumference to be plotted. Another possibility to create an arc in the plane consists of connecting two points. The CreateArcPointsDist function allows the user to connect any two given points in the plane by an arc. Of course, there are many (infinite) arcs that pass through every two points in a plane. The parameter radius fixes a radius for the arc to be built. If the selected radius is smaller than half the distance between the points, the problem has no solution and no arc is produced (a message is shown on the screen to inform the user).
Polygons are closed figures made of a finite number of points (there must be 3 points at least). The segments that join the points of a polygon are called the sides of the polygon, and each of the sides must intersect only at the two points that connects (auto-intersections are not allowed in a polygon). It is usual to represent a polygon by an ordered list of points, which indicates the way the points are connected. For example, if a polygon is represented by a list of points [P1, P2,P3], it means that the three segments of this polygon (a triangle) join P1 with P2, P2 with P3 and P3 with P1. The CreatePolygon function admits any finite number of points to produce a polygon, which corresponds to the definition of a polygon as a list of points. It is important to introduce the points in a certain order to get the desired output because the same combination of points can lead to different figures. In order to make a polygon without self-intersections, the points must be passed to the function following a clockwise (or counterclockwise) direction. Moreover, this function includes a procedure to detect collinearity between the points, which makes the function to show the message "Some of the inserted points are collinear. This could lead to a defective polygon" when this occurs. If the user is interested in building a regular polygon given its center, number of sides and side length, the CreateRegularPolygon function can do it.
It is quite simple to make these objects with basic graphical R functions. However, the goal was to create a homogeneous group of functions with a minimal number of parameters. Although the already existing functions in the R language are simple for a programmer, they may contain too many parameters for a novice user. Moreover, it is essential to define the functions with a little number of parameters in order to highlight the different existing methods to define the same geometric object.
Finally, the Draw function is programmed to be able to accept all kind of geometric objects as a parameter. This fact seems to be essential to understand geometric ideas because of providing the user a quick and intuitive tool to easily visualize while programming. The only visible difference among the different geometric objects and Draw function occurs with polygons. This function adds, only for polygons, the option of using two colours and the possibility of inserting labels at each of the points of the object.
As a summary, Table 1 describes the eight basic functions included in the package to create geometric objects.
A brief explanation of the parameters which are associated to each of these functions can be found in Table 2.
Table 3 clarifies the structure of the outputs produced by each of the functions and the information which they provide about the geometric object that they represent.
Fig. 1 contains examples of use of several functions of the LearnGeom R package, including some of the R instructions needed to use them and their graphical outputs. Fig. 1a shows three polygons of 3, 4 and 5 sides that can be freely defined with the CreatePolygon function. Fig. 1b includes the first nine regular polygons as can created by the function CreateRegularPolygon with lengthside l = 1 and varying center. Fig. 1c, d also contains examples of removing and adding points with the RemovePointPoly and AddPointPoly functions, along with the lines of code required to obtain these polygons after a regular pentagon (Penta) is defined. Fig. 1e, f show examples of use of the CreateArcAngles and CreateArcPointsDist functions, which attempt to clarify the use of each oftheir parameters.
Fig. 2 contains a couple of examples of use of the specific functions available for creating lines and segments, including the required R code. This figure shows that both lines and segments are the same because the introduced parameters are equivalent. Depending on the situation and the available information, users may find one or the other one as the most suitable tool.
Moreover, if a more experienced user of the language aims to create a line by specifying its slope and intercept, even though there is no function in the package to perform this, it can be achieved by simply defining a two-dimensional vector containing these basic parameters of the line and appending the class Line to it. This also applies to the other three geometric objects. However, this is not the use of the package we would expect for a new user of it. The rest of this paper contains multiple examples of use of some functions of the package that have not been mentioned yet and several applications which are possible to perform by combining classical geometric problems, different programming techniques and all the functions included in the package. These applications are thus classified into three categories according to their level of difficulty: basic, intermediate and advanced.
Advanced level
Recursive programming
Recursive programming is one of the most efficient strategies to find the solution of some problems. However, it is also a difficult task for novice programmers. For quite advanced students, recursive programming could be treated to build a well-known mathematical structure: a fractal Mandelbrot (1977). Fractals are geometric objects which satisfy the property of self-similarity, which basically means that each of their parts satisfy the same properties and internal relationships as the complete object does.
As an illustration, this definition can be easily imagined with the help of one of the most famous fractals: the Sierpinski triangle Knaster and Kuratowski (1927). The process of building this triangle consists of the following steps:
Start from an equilateral triangle.
Find the middle points of each side of this triangle.
Connect the three points obtained in step 2 to obtain a new triangle. This triangle is also equilateral and rotated 180º with respect to the initial position.
Remove the triangle built in step 2 from the initial triangle. Now you have three little triangles inside the initial one. This is the first iteration to build the Sierpinski triangle.
If the steps 1-4 are repeated in each of these three triangles, nine smaller triangles will be obtained, which are similar to the previous ones. This is already the second iteration of the construction and a constant repetition of the steps leads to any iteration of the triangle. The Sierpinski triangle is theoretically defined as the infinite repetition of the steps 1-4. However, from a practical point of view, we consider interesting only the building of the first iterations. This process can be implemented in R with a few lines of code due to the efficiency of recursive programming and some of the functions contained in the LearnGeom R package. For example, the code available in the following lines (in italics) is a possible approach to produce the first six iterations of the Sierpinski triangle. It is necessary to create a function Sierpinski to call it recursively during the triangle construction:
> x_min <- -6; x_max <- 6; y_min <- -6; y_max <- 6
> CoordinatePlane(x_min, x_max, y_min, y_max)
> n <- 3; C <- c(0,0); l <- 5
> Tri <- CreateRegularPolygon(n, C, l)
> it <- 6
> Sierpinski <- function(Tri, it){
if (it==1){
Draw(Tri,"black")
}
if (it>1){
Sierpinski(CreatePolygon(Tri[1,], MidPoint(Tri[1,],Tri[2,]), MidPoint(Tri[1,],Tri[3,])), it-1)
Sierpinski(CreatePolygon(Tri[2,] ,MidPoint(Tri[1,],Tri[2,]), MidPoint(Tri[2,],Tri[3,])), it-1)
Sierpinski(CreatePolygon(Tri[3,] ,MidPoint(Tri[1,],Tri[3,]), MidPoint(Tri[2,],Tri[3,])), it-1)
}
}
> Sierpinski(Tri, it)
The R code included just displayed is basically the same one that contains the function Sierpinski of the package. This function allows users to visualize the first iterations of the fractal avoiding the difficulty of building it (see Fig. 6a). However, for users ready to learn recursive programming, the best option would be to propose the construction on their own. The package also contains a function related to the Koch curve, another very well-known fractal Koch (1904). The most famous version of this fractal is called Koch's snowflake, which can be obtained by following the next three steps, starting from a segment in the plane (see Fig. 6b):
Divide the segment into three equal segments.
Replace the middle segment by the two sides of an equilateral triangle whose side length is the same as for the segment being removed. Now, there are four segments of the same length.
Build an equilateral triangle by using the middle segment as its base. Remove this segment to leave four different segments in the picture.
The continuous application of these steps to each of the new segments that are created after each iteration produces every state of the fractal. The FractalSegment function, available in this package, allows the user to create an infinity number of curves whose construction is based on these steps. The user can experiment with cut, angle and f parameters to achieve all kind of fractals (starting from iteration it = 0). The cut parameter allows a non-equal division of the segments at step 1, however, the angle parameter allows the user to build more than an equilateral triangle at step 2. Finally, the f parameter, which is a positive number, produces a length enlargement or a reduction for the new segments at each iteration. Users are free to try these parameters and produce some fractals like those shown in figures Fig. 6c, d, e, f. As it can be observed in these figures, the fractal complexities and diversities are enormous, including auto-intersections. For this reason, to display fractals for the first iterations is really helpful to better understand the underlying process of construction.
Generation of curves
A trochoid is a closed curve that can be obtained by the conjunction of three geometric figures: two circles, from which one of them is fixed and the other mobile, and a mobile point, which is connected to the mobile circle. There are three parameters to characterize each trochoid: the fixed circle radius, the mobile circle radius and the distance from the mobile point to the center of the mobile circle Armon (1996).
The presence of these parameters can be used to define a trochoid as a set of parametrical equations, involving trigonometry functions. However, as it was first proposed by Abelson and DiSessa (1986) with the aid of the LOGO turtle, these curves can be approximated by iteratively drawing segments of certain lengths and angles. The LOGO turtle, which originally was a real robot developed at Massachusetts Institute of Technology at the end of the 60s, refers to an on-screen cursor implemented in the LOGO language that was capable of responding to easy instructions from the user (basic direction setting of the turtle and rectilinear movements). This turtle is also available in R in the package TurtleGraphics. As it is shown in the publication of Abelson and DiSessa (1986), the procedure to obtain any trochoid needs a pair of angles and a pair of lengths (and an initial point to start the curve). An iterative process is then defined based on these angles and lengths, which makes possible the continuous generation of every kind of trochoid.
This package also includes a function called Star, which can be utilised to represent very different star-like objects as another application of the LOGO turtle also taken from Abelson and DiSessa (1986). This function is based on the generation of the object by drawing segments iteratively as Duopoly. The variation of the parameters included in the function render possible to understand the basis of the process and can incite the user to achieve many kinds of star-like shapes. Thus, Fig. 7 represents some examples of use of the functions Duopoly (Fig. 7a, b, c) and Star (Fig. 7d, e, f). The parameters color and time available in the function let the user to appreciate all the points that are drawn in the generation of the curve and the order at which they are drawn.