A motivating approach to introduce object-oriented programming to engineering students

Abstract

This article describes experiences of teaching object-oriented programming to undergraduate Electrical Engineering students. The proposed project-based methodology increased the interest of students in programming. The project focuses on the development of a small C++ class that allows students to build geometric models by manipulating a three-dimensional matrix. The class methods (C++ member functions) can draw complex scenes by using combinations of them. Students can improve their programming skills according to the points of view of a class developer and a class user. In addition, students try to create beautiful models to present to each other, making the learning experience pleasant and motivating.

Keywords

Object-oriented programming C++self-motivating project-based learning

Introduction

Computer programming is usually a mandatory subject in the first year of most engineering courses. Current curricula suggest object-oriented programming (OOP) as one of the primary paradigms in teaching programming.¹ Many programmable devices support OOP for software development and interfacing. Applications for cell phones running operating systems such as Android or iOS, for example, are made with object-oriented (OO) languages.^2,3

In computer programming, game development is the most common choice to motivate students with different profiles to a common subject of interest.⁴

However, an alternative project-based learning (PBL)^a approach is presented in this article, mixing introductory concepts of computer graphics, C++ programming, and geometric modeling that can be easily learned by freshmen. They are expected to develop, with a reduced number of lines of code, a C++ class and a main() using this class to create their preferred three-dimensional (3D) model (odel-dimensio Only a C++ compiler and a 3D visualization software are necessary for the project. Since both tools are available as free software, there is no cost for the institution nor the students.

The learning goal is to know the fundamentals of the C++ programming language through a project that stimulates the student through art.

The general idea is to develop a C++ class, called Sculptor, whose methods^b can add basic geometric forms (cubes, spheres, etc.) to an initially empty volume. Using this class, students are required to build a computer-generated sculpture. To ensure that all students will follow a common model, the starting point of the project is a class prototype written in C++ whose methods shall be implemented.

Within the Sculptor class, a 3D matrix of voxels represents the volume. A voxel is the 3D equivalent of a pixel. The unified modeling language (UML) class diagram in Figure 1 shows the system’s classes, their attributes, methods, and the composition relationship between the Sculptor and Voxel classes, which will be detailed later.

Figure 1.

UML class diagram.

To create a sculpture using the Sculptor class, the user must initially mentally decompose the desired object into a set of basic forms. The next step is to write a C++ program with an object of the Sculptor class and call the appropriate class methods to include the required forms. Finally, a specific class method (write) is used to generate a file that contains the representation of the object in a standard format (the object file format (OFF), described later) that can be read by a 3D visualization software. The full process is illustrated in Figure 2.

Figure 2.

Dataflow showing the sculpture construction and visualization process.

Each voxel in the 3D matrix has a Boolean attribute isOn that indicates whether or not it belongs to the 3D object: if isOn is true, other attributes (r,g,b,a) store the voxel color. For example, when the user calls the method for adding a sphere to the sculpture (putSphere), each voxel whose distance from its center to the center of the sphere is less than or equal to the radius of the sphere has its isOn attribute set to true.

When all forms are included, the 3D matrix of voxels can be saved to a file, following the specification of a standard format for defining geometry in files. Each voxel is a small cube and is represented in the file by its six faces. The result is an ASCII file that can be visualized using any software that recognizes the adopted file format.

The PBL approach presented in this article was applied for two and a half years with five instances of an OOP course offered for Electrical Engineering (EE) students at the Federal University of Rio Grande do Norte (UFRN), Brazil, making a total of 135 students within this period.

Next section “Related work” describes previous successful projects on teaching OOP using different curricula. The sections “Description of the project” and “Programming aspects” present the proposed framework and some programming aspects of the approach. The results, including grade assessment, are presented in the “Results” section. Finally, the sections “Qualitative discussion” and “Concluding remarks” qualitatively discuss and conclusively summarize the proposal.

Related work

PBL approaches have been successfully used to teach computer languages, even for freshmen.⁶ An interesting approach proposed by Goulding⁷ was to implement the ENIGMA encryption system in C. The motivation was provided by the history of the ENIGMA machine in Second World War and by the challenge of replicating its operation with software.

After searching the current literature on teaching OOP, two main aspects were noticeable: OO languages have been preferred for developing practical and large-scale software,⁸ and using computer games or graphics has been successfully applied to several curricula.⁹

Overmars,¹⁰ for example, introduces GameMaker as an interactive tool for creating games. Jordine et al.¹¹ propose a tower defense game in which the programmer has to define Java classes to create towers and solve a level. Sung and Snyder¹² describe another game-based PBL approach in which students are required to develop games using the C# language and XNA. Yan¹³ explores the Greenfoot¹⁴ environment for teaching OO programming with Java, by building games, simulations, and other graphical programs using a mix of graphic design and text programming.

Creating computer games is a fun way to learn and practice programming, object modeling, and design patterns.⁹ However, in many non-computer-oriented engineering curricula, there are few or even only one mandatory course on OOP. So, considering those time constraints, it is difficult to present students even a simple game development framework and demand the creation of a fully functional game. On the other hand, text-based games are not impressive and are usually considered boring by students.

The adopted PBL approach to address time limitations while maintaining motivation is a mix of console programming with some computer graphics to generate 3D objects.

The main difference between this approach and others found in the literature lies in the ability to prompt a first-year EE student to learn OOP through self-motivation, exploiting concepts that are easy to understand. Youngsters usually like experimenting with games and graphics applications. Allowing them to create their own computer graphics models from scratch without using any other auxiliary software besides the compiler itself makes the difference.

Description of the project

The EE curriculum at UFRN has three mandatory courses focused on computer programming: Algorithms and Programming Logic, Advanced Programming, and Numerical Methods. These courses adopt C++ as the default programming language, since C and C++ occupy first place in the ranking of programming languages for industrial and embedded applications.¹⁵

The project described in this article is applied in the Advanced Programming course, which mainly explores OOP. It is taught in the second semester of the five-year engineering formation. It has a total of 60 h over 18 weeks, with two weekly meetings (each lasting 100 min) in a laboratory. About 70% of the meetings are dedicated to presenting subjects that are assigned to this course (pointers, C++ fundamentals, OOP, data structures, etc.). The other 30% of the meetings are dedicated to tracking project development with students in the lab.

Considering these time constraints, a project-based OOP learning methodology that could achieve the following objectives is sought:

Students should be presented with the main fundamentals of OOP using a self-motivating strategy.

Students should practice OOP from both the point of view of a class developer and a user of a class.

Time restrictions should be considered.

Students should experience challenges that are common in software development for engineering.

Students should be able to propose new functionalities that are beyond the minimum project requirements.

The first step was to find a common subject that could increase interest among students. While searching for game approaches, Minecraft¹⁶ drew special attention. In short, the game inserts the user into a virtual world where they are able to build complex structures simply by inserting or deleting blocks into a 3D matrix-like style. Following the Minecraft approach, the idea was to conceive a project that allows students to use simple functions to build complex structures placed in a 3D virtual environment.

The simplest way to address this problem was to create a 3D matrix allocated into the computer memory and set up some properties for each matrix element, hereinafter called voxel. This kind of model representation (using a matrix) is usually called exhaustive enumeration, or discrete cell enumeration.¹⁷ The discrete cell model was adopted because it is very easy to understand, considering the profile of the target students.

Voxel representation

Five fields (or attributes) represent each voxel, as described by the UML representation in Figure 1:

red a float value [0:minimum, 1:maximum] to represent the red color.

green a float value [0, 1] to represent the green color.

blue a float value [0, 1] to represent the blue color.

alpha a float value [0:full transparency, 1:full opacity] to represent the opacity of the matrix element.

isOn a Boolean value to represent the visibility of the matrix element in the model. It is used to mark if the voxel representation has to be included (true) or not (false) into the file that will store the computer generated model.

The size of the 3D matrix is defined by the user according to the width, height, and depth properties of the model. The spatial coordinates of each voxel (x, y, and z) are the same integer values used to index the three dimensions of the matrix elements. Therefore, the so-called sculpture is “painted” into this matrix by changing its voxel properties.

To better illustrate the idea, consider a very small 3D matrix of $2 \times 2 \times 2$ voxels ( $width = height = depth = 2$ ) whose elements have the properties presented in Table 1.

Table 1.

Example of 3D voxel matrix and its properties.

Coordinates			Attributes
X	y	z	red	green	blue	alpha	isOn
0	0	0	0	1	0	1.0	True
1	0	0	1	0	0	0.8	True
0	1	0	0	0	1	1.0	True
0	0	1	1	1	0	0.5	True
1	1	0	^a	^a	^a	^a	False
1	0	1	^a	^a	^a	^a	False
0	1	1	^a	^a	^a	^a	False
1	1	1	^a	^a	^a	^a	False

Irrelevant value.

The sculpture associated with the matrix in Table 1 is presented in Figure 3. Each voxel that belongs to the sculpture is represented as a cube centered at the corresponding voxel coordinates and filled with its color. For this example, the voxels that do not belong to the sculpture (isOn is false) are displayed using wireframes with dashed lines.

Figure 3.

Simple sculpture enclosed in a matrix of size $2 \times 2 \times 2$ .

Once the voxel properties of a given matrix are defined, its corresponding 3D model should be generated. The simplest approach is to create a polyhedral model consisting of several cubes such as the ones presented in Figure 3.

Several alternatives for representing 3D models are available in the literature such as VRML, 3Ds, PLY, Wavefront OBJ, and X3D. Perhaps the simplest method is the Object Oriented Graphics Library,¹⁸ a set of file formats that are supported by Geomview¹⁸ and other visualization software.

The OFF file format

OFF files represent collections of planar polygons with possibly shared vertices¹⁹ and it is well suited to represent a sculpture entirely represented by cubes facets. The OFF file is based on an American Standard Code for Information Interchange (ASCII) format,¹⁹ so it is easy to be understood by the students.

Moreover, numerous free software such as Geomview¹⁸ or Meshlab^20,21 are able to display OFF files on Windows, Linux, and Mac. Once the students build models using the class methods proposed in this article, they store the models into OFF files using a class method and visualize the files using their preferred tool.

An OFF file is usually written in ASCII format^c which allows storing polyhedra data whose faces have some properties, such as normals, colors, and texture coordinates. The syntax of an OFF file¹⁸ is presented in Figure 4.

Figure 4.

OFF file format syntax.

An OFF file starts with the mandatory OFF keyword. The second line of the file must have three integers: NVertices, NFaces, and NEdges. The first two are the model number of vertices and faces. The third integer is the number of edges. Since it is not used or checked (but has to be present in the file), it may be set equal to zero without consequences.

The following NVertices lines store the x, y, and z coordinates for all vertices used to compose a face.

The list of faces follows the list of vertices. Each line defines a face that is composed of a sequence of Nv vertices, indexed from $v [0]$ to $v [Nv - 1]$ . The face color is placed after the vertex indices, specified with three or four floats (red, green, and blue color components and possibly an alpha value for transparency), all ranging from 0.0 to 1.0.

The simple structure of the OFF file format allows a student to create a class method that evaluates the matrix of voxels and writes the corresponding OFF file.

Once the OFF file concepts have been presented to students, a set of resources are required to be implemented in C++. Such resources will allow the user to draw into the 3D matrix using a small set of simple methods.

Methods for drawing into the matrix

To build their digital sculpture, students have to implement a class for drawing into the matrix of voxels. This class is called Sculptor, the digital sculptor. The user of the Sculptor class interacts with class objects using methods that modify an internal matrix of voxels, dynamically allocated according to the established size. The proposed minimal set of methods the student must implement is described in this section, according to the UML class diagram shown in Figure 1:

setColor() stores the current drawing color. The method receives four parameters: red, green, blue, and alpha. Once a color is defined, the sculptor current drawing color is changed into this new color.

putVoxel() adds a single voxel to the model. It receives a set of three parameters that are the coordinates of a voxel whose color properties have to be changed to the current drawing color. Moreover, the isOn property must be set to true, marking the voxel to be represented in the sculpture.

cutVoxel() is similar to the putVoxel() method, but it removes a voxel from the model, instead of adding one. It functions by setting the voxel isOn property to false.

putBox() draws a box. It receives six parameters, x0, x1, y0, y1, z0 and z1, that define the border voxels in each axis direction. All voxels that fit within these ranges of matrix indices have their isOn property set to true and the color changed to the current drawing color.

cutBox() erases a box. It receives the same six parameters of the putBox() method and functions by setting the isOn property to false.

putSphere() draws a sphere. It receives four parameters, x_center, y_center, z_center and radius, representing the center and radius of the sphere. All voxels whose coordinates fit within the sphere, according to the sphere equation, have their isOn property set to true and the color changed to the current drawing color.

cutSphere() erases a sphere. It receives the same four parameters of the putSphere() method and functions by setting the isOn property to false.

putEllipsoid() draws a ellipsoids. It receives six parameters: x_center, y_center, z_center, x_radius, y_radius and z_radius, representing the center and lengths of the semi-principal axes of the ellipsoid. All voxels whose coordinates fit within the ellipsoid, according to the ellipsoid equation, are marked with the current drawing color and have their isOn property set to true.

cutEllipsoid() erases a ellipsoid. It receives the same six parameters as putEllipsoid() and functions by setting the isOn property to false.

The proposed class and its use are discussed in the following section.

Programming aspects

Class description

The C++ header file contains common prototypes for a structure named Voxel and a class named Sculptor. The students are free to choose their coding style or standard.

The Voxel structure (Listing 1) defines properties of each element of a 3D matrix contained in the Sculptor class. Each one of the five Voxel variables represents one of the attributes described in the “Voxel representation” section.

Listing 1: Source code of the Voxel structure

1 struct Voxel {

2 float r,g,b;//Colors

3 float a;//Transparency

4 bool isOn;//Included or not

};

The Sculptor class (Listing 2) contains protected variables and public methods (member functions). The 3D matrix to be processed is stored on the variable v. It is a pointer to a dynamic allocated structure to store voxels into the memory. Matrix dimensions depend on the values attributed to nx, ny, and nz. Variables r, g, b, and a store the current drawing color, the same way as described for the Voxel structure. Those variables are protected to allow direct access if students decide to create new functionalities by inheritance. The public members allow the user of the Sculptor class to make use of methods such as those described in the “Methods for drawing into the matrix” section.

Listing 2: Partial source code of the Sculptor class

1 class Sculptor {

2 protected:

3 Voxel ***v;//3D matrix

4 int nx,ny,nz;//Dimensions

5 float r,g,b,a;//Current drawing color

6 public:

7…

};

Programming issues explored in the project

Some of the Sculptor’s methods are specially crafted to explore interesting aspects of computer programming for engineering applications. For instance, the implementation of its constructor and destructor methods deals with dynamic memory allocation. Since a 3D matrix is required, students’ skills on pointer manipulation are improved when implementing these methods. Indeed, matrices are used in many engineering computer programs. Developing these methods is an opportunity to better understand how matrices must be placed in the computer memory from the low-level point of view of a programmer.

The putVoxel(), cutVoxel(), putBox(), and cutBox() methods explore simple C++ concepts. The main requirement is to be careful when testing if the parameters are valid (indices out of range, for example).

The other methods, putSphere(), cutSphere(), putEllipsoid(), and cutEllipsoid(), require students to implement the sphere and ellipsoid equations to determine if a given voxel coordinate fits within a sphere or an ellipsoid to change it or not. These methods are interesting because they are easy to understand, but their naive implementation can lead to some common programming mistakes. In such cases, once the errors are detected and understood by the students, they solve the problem by correcting their code, developing in the process good skills for not to repeat them.

One of the mistakes frequently made by students occurs when the coordinates are generated and the required tests are not included in the code. Students usually create sets of loops to generate matrix indices, as in lines 1–3, Listing 3. These loops can create indices outside the valid range of the volumetric matrix. Bad indices are a very dangerous source of errors in engineering software and they can be easily prevented by proper range checking (lines 4–5).

Listing 3: Preventing errors in putEllipsoid

1 for (int x = x_c-r_x; x <= x_c + r_x; x++)

2 for (int y = y_c-r_y; y <= y_c + r_y; y++)

3 for (int z = z_c-r_z; z <= z_c + r_z; z++) {

4 if (x>=0 && x<nx && y>=0 && y<ny &&

5 z>=0 && z<nz) {

6 float d = pow(float(x-x_c)/r_x, 2)+

7 pow(float(y-y_c)/r_y, 2)+

8 pow(float(z-z_c)/r_z, 2);

9 if (d <= 1.0) {

10 v[x][y][z].isOn = true;

11 v[x][y][z].r = r;

12…

Other common mistakes come from integer divisions. For example, to decide whether or not a voxel belongs to an ellipsoid, the program must test if

{(\frac{x - x_{c}}{r_{x}})}^{2} + {(\frac{y - y_{c}}{r_{y}})}^{2} + {(\frac{z - z_{c}}{r_{z}})}^{2} \leq 1

Incorrect handling of data types when implementing this equation can create errors, such as integer divisions expected to produce float results, but actually generating values equal to zero. These mistakes can be easily avoided by simple type castings, as in lines 6–8 of Listing 3.

The write() method creates an OFF file for writing the sculpture model. Its implementation allows students to develop skills on file manipulation and I/O operations.

The cleanVoxels() method is an optimization method for cleaning voxels whose isOn property is true and that are fully surrounded by other voxels also with isOn = true. These surrounded voxels may be excluded from the OFF model by making isOn = false, since they represent extra load for display purposes. Students usually discover that they need a simple data structure, like a queue or a list, to store the surrounded voxels for further processing.^d This is a good opportunity to improve their programming skills in using the generic C++ Standard Template Library.²²

Using the Sculptor class

The functionalities of the Sculptor class are better explained with an example. Consider a sculpture consisting of a red box with a blue sphere inside it (Figure 5). A source code to produce such a model is presented in Listing 4:

Listing 4: Source code for drawing are dbox with a blue sphere inside of it.

1 #include “sculptor.h”

3 int main(void) {

4 Sculptor s(30,30,30);

5 s.setColor(1.0,0.0,0.0,1.0);

6 s.putBox(0,29,0,29,0,29);

7 s.cutBox(1,28,1,28,0,28);

8 s.setColor(0.0,0.0,1.0,1.0);

9 s.putSphere(15,15,11,11);

10 s.write(“box-ball.off”);

}

Line 4 creates a sculptor object “s” with dimensions equal to $30 \times 30 \times 30$ voxels.

Line 5 sets the current color to fully opaque red, i.e. $(r, g, b, a)$ $= (1.0, 0.0, 0.0, 1.0)$ .

Line 6 draws a box spanning the entire available space in the sculptor matrix. This will set all voxels to red.

In line 7, a box that is two voxels thinner than the previous one is removed, hollowing the red box.

Line 8 sets the current color to fully opaque blue, i.e. $(r, g, b, a) = (0.0, 0.0, 1.0, 1.0)$ .

In line 9, a sphere centered at $(x, y, z) = (15, 15, 11)$ with radius 11 is drawn.

Finally, line 10 saves the model to file box-ball.off.

Figure 5.

Model of a red box with a blue sphere inside of it.

As shown in Figure 5, more complex solids can be constructed using a combination of simpler methods.

Results

This project has been presented to 135 students over five semesters. The project is expected to be fulfilled within approximately five weeks, including the development of class methods and the production of a 3D sculpture. Students usually take two weeks to develop the class and another two weeks to finish the model.

Evaluation

Grades are assigned according to two criteria:

Technical (50%): The student’s Sculptor class is used to compile several small programs, created by the instructor, each one using some of the required functionalities described in the “Methods for drawing into the matrix” section to create a simple specific sculpture.

The technical grade is the average of the scores assigned to the result of using the student’s class to compile each of the predefined programs:

○ 100% if the expected sculpture is produced, with the correct number of voxels to represent it.

○ 50% if the expected sculpture is produced but with a larger number of voxels than necessary.

○ 0% if the produced sculpture is incorrect or if there are compilation or execution errors.

Artistic (50%): Students must present the creation process and the final result of their sculptures to the colleagues.

They also subjectively group all other sculptures into three sets of equal size, according to the artistic quality and the degree of difficulty: the best (value 3), intermediate (2) and worst (1) sculptures. The average of all values attributed to each sculpture is calculated and used to assign the artistic grade.

Even the artistic grade being based on subjective impressions, the classification of the sculptures into three groups is relatively consistent in an inter-rater reliability test using Krippendorff’s alpha coefficient.^23,24 For example, grades from the last three semesters generate statistical measures of agreement of 0.514, 0.564, and 0.856 on a scale of 0 to 1, where 0–0.20 indicates no/poor agreement; 0.21–0.40, fair agreement; 0.41–0.60, moderate agreement; 0.61–0.80, substantial agreement; and 0.81–1.00 indicates near perfect/perfect agreement.²⁵

Grades were evaluated over the course of four years for eight instances of the OOP course, within the range [0,10]. The mean and standard variation for these eight instances are presented in Figure 6. The red marks are the grades before this approach was started. The blue marks are the grades when this project was adopted, with a noticeable increase over the previous approach.

Figure 6.

Students’ grade evolution.

Produced sculptures

Another way to illustrate the results of the digital sculptor project is by presenting a representative set of the produced 3D sculptures. Most students try to model objects that are meaningful to them: characters and objects of games, comics and cartoons, technological gadgets, hobbies, and so on.

The iPhone 5 was one of the first models developed in this project. It is presented in Figure 7, and it was designed by a group of two students using only the methods presented in the “Methods for drawing into the matrix” section. The model is composed of 56,224 vertices and 42,168 faces, featuring only two shades of gray.

Figure 7.

iPhone5.

Less skilled students sometimes create sculptures using only a few instances of the predefined required methods, such as the Pokémon Luxury Ball in Figure 8. Even these students, however, acquire a reasonable understanding of the fundamental OOP concepts and are proud of producing a 3D “object” they were not capable of before the course.

Figure 8.

Pokémon Luxury Ball.

The Guitar sculpture presented in Figure 9 was constructed using additional methods other than those required. Since they are not allowed to modify the Sculptor class, they decided to subclass it to implement methods to place and cut cylinders.

Figure 9.

Guitar.

The snow effect in Figure 10 was modeled by changing the color of random voxels to white. Although simple, the effect is beautiful when visualized with Geomview.

Figure 10.

Snow.

Figure 11 is an attempt to recreate the “Arena das Dunas” Stadium.^e It was the most complex sculpture submitted in this project. It depicts the stadium with a large amount of details and a “creeper” Minecraft character watching it. The students decided to subclass the Sculptor class to include methods for drawing staircases with specific orientations.

Figure 11.

Arena das Dunas Stadium.

Qualitative discussion

An examination of the literature used in this article^5,26–30 reveals that some non-traditional educational approaches can have a significant impact on increasing student performance.²⁶ Much of the research indicates that passive learning modes are much less effective than modes where students are involved in active learning.²⁶ Also, peer interaction is particularly effective for promoting learning.²⁶

The main objective of this proposal is to increase the interest and motivation of freshmen students in learning OOP. For that, a project-based methodology was chosen, since it has been reported that students prefer to learn through carrying out a real project because they feel it provides them with more motivation to learn.²⁷ Also, previous analyses suggest that a problem-based learning methodology offers significant benefits when compared to a more traditional didactic method.²⁸

Our approach is strongly influenced by problem-based learning, defined as “a learner-centered approach that empowers learners to conduct research, integrate theory and practice, and apply knowledge and skills to develop a viable solution to a defined problem”.⁵ However, we adopt a hybrid form of PBL, which combines learning through projects with delivering essential knowledge via lectures and assignments. Previous works report that this mixed strategy is more effective at delivering all expected learning outcomes in an advanced technical course than pure PBL.²⁹

Some general characteristics are commonly associated with the use of active learning strategies in the classroom³⁰:

Students are involved in more than listening.

Less emphasis is placed on transmission of information and more on developing students’ skills.

Students are involved in higher order thinking (analysis, synthesis, evaluation).

Students are engaged in activities (e.g. reading, discussing, writing).

Greater emphasis is placed on students’ exploration of their own attitudes and values.

This proposal attempts to incorporate these characteristics in the following ways:

During the development of the project, there are no classical lectures.

Students remain in pairs throughout the class time, working on the development of their Sculptor. The pairs are chosen by the students themselves, and they must discuss between them and even teach each other to finish their project.

The teacher has the role of an itinerant consultant, circulating among the groups to answer questions and provide suggestions.

Technical OOP knowledge has to be combined with the ability to mentally visualize abstractly described 3D objects with artistic considerations.

In the end, students have to orally present their work and emphasize its qualities to the colleagues, in order to achieve a good peer-assigned “artistic” grade.

To assess if the goal of increasing student motivation in learning OOP was achieved, it is difficult to calculate a quantitative measure. However, a qualitative evaluation can be achieved, based on previous experience of the teachers and student feedback. Feedback was obtained using an anonymous faculty student feedback survey, which is applied by UFRN to all students at the end of each semester as a mandatory procedure of their academic life.

The acceptance by students has been very good. They are usually grateful for the opportunity to learn C++ programming using this method. There is no need to encourage students to develop their projects. They develop the class methods to start building their sculptures as soon as possible. Once these methods are created, they focus on model building, improving their spatial referencing capabilities to insert structures in the 3D sculptor.

The instructors^f observed some interesting aspects:

Students improved their understanding of the fundamental concepts of OOP. The choice of this programming paradigm is well accepted by students, since it is easy to realize the difference between the overall sculptor (the class), the piece of software that endows the sculptor with another skill (a method) and the combination of class methods (the main program) that creates a specific sculpture.

Students are so focused on creating methods and sculptures that they learn C++ almost without realizing it, associating learning with fun.

Students’ spatial orientation capabilities are improved since they must position 3D objects into the sculpture.

Most of the programming issues presented in the “Methods for drawing into the matrix” section are experienced by all of the students. They learn from these issues just by observing the effects on their 3D models.

Some students do not feel satisfied using only the mandatory class methods. In addition to the mandatory methods, students develop their own subclasses to perform specific tasks.

Students always suggest that the project should be included in the following semesters of the C++ programming course.

Nice sculptures that are produced by students from one semester serve as a stimulus for the next students.

Concluding remarks

This article describes a PBL approach for teaching OOP for students in the early years of an engineering course. Its main characteristics and differences in relation to other proposals are as follows:

Few requirements. This educational tool can be used with freshmen, with only introductory previous knowledge of computer programming. The proposal can be adopted for different engineering curricula, not only in computer-oriented courses. The project does not require any specific software or dedicated development environment, and can be completed using only any C++ compiler. Finally, the project does not require a significant amount of time to be executed, in such a way that it can be included within a larger course.

Motivation. Students usually report to instructors that they enrolled in the course for the opportunity to create a 3D sculptor project. This is an interesting aspect, since the project itself is not mentioned in the course syllabus. Students tell each other about the project and show their 3D models to colleagues.

Personalized learning. A common issue in programming courses for engineers is that students are not equally previously prepared for the course. With this project, even the less prepared students are able to achieve the minimum requirements. Students with deeper previous knowledge are free to create more advanced structures.

Sculpture exposition. At the end of the course, students are required to present their sculptures and discuss their creation process. It is a very important moment since students have the opportunity to express how the project helped them learn OOP and the tricks used to create their model.

Limitations. This learning tool was specially conceived to increase motivation in freshman engineering students during their first or only course on OOP. Due to this characteristic, it does not address so thoroughly all aspects of OOP. Thus, if other concepts (polymorphism, for instance) should also be deeply covered, perhaps another approach would be more suitable, replacing or complementing this project.

Footnotes

Acknowledgements

The authors would like to thank all the students who helped to create and improve this project.

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) received no financial support for the research, authorship, and/or publication of this article.

ORCID iDs

Agostinho de Medeiros Brito Jr

Adelardo Adelino Dantas de Medeiros

Notes

References

Joint Task Force on Computing Curricula AfCMA and Society IC. Computer science curricula 2013: curriculum guidelines for undergraduate degree programs in computer science. New York, NY, USA: ACM, 2013.

Rogers

Lombardo

Mednieks

, et al. Android application development: programming with the google SDK. 1st ed. USA: OSA: mmi Media, Inc., 2009.

Conway

Hillegass

IOS programming: the big nerd ranch guide. Boston: Addison-Wesley, 2012.

Heininger

Prifti

Seifert

, et al. Teaching how to program with a playful approach: a review of success factors. In: 2017 IEEE global engineering education conference (EDUCON), 2017, pp.189–198.

Savery

JR.

Overview of problem-based learning: definitions and distinctions. Interdiscip J Problem-Based Learn 2006; 1: 9–21.

Ferreira

Nascimento

Assis

, et al. Teaching object oriented programming computer languages: learning based on projects. In: International conference on software engineering advances, 2007 (ICSEA 2007), 2007, pp.81–81.

Goulding

A first semester freshman project: The Enigma encryption system in C. ACM Inroads 2013; 4: 43–46.

Chen

Chiang

Huang

, et al. A project-based curriculum for teaching C++ object-oriented programming. In: 2012 9th international conference on ubiquitous intelligence computing and autonomic trusted computing (UIC/ATC), 2012, pp.667–672.

Kae Chen

Cheng

YC.

Teaching object-oriented programming laboratory with computer game programming. IEEE Trans Educ 2007; 50: 197–203.

10.

Overmars

Teaching computer science through game design. Computer 2004; 37: 81–83.

11.

Jordine

Liang

Ihler

A mobile-device based serious gaming approach for teaching and learning Java programming. In: Frontiers in education conference (FIE), 2014, pp.1–5. USA: IEEE.

12.

Sung

Snyder

A case of computer science principles with traditional text-based programming languages. J Comput Sci Coll 2014; 30: 161–172.

13.

Yan

Teaching object-oriented programming with games. In: Proceedings of the 2009 sixth international conference on information technology: new generations (ITNG’TN), 2009, pp. 969–974. Washington, DC, USA: IEEE Computer Society.

14.

Kölling

Greenfoot: introduction to Java with games and simulations. J Comput Sci Coll 2010; 25: 117.

15.

Cass

The 2015 top ten programming languages. IEEE Spectrum, http://spectrum.ieee.org/computing/software/the-2015-top-ten-programming-languages (2015, accessed 11 June 2019).

16.

AB MS. Minecraft, https://minecraft.net (2015, accessed 11 June 2019).

17.

Kaufman

Shimony

3D scan-conversion algorithms for voxel-based graphics. In: Proceedings of the 1986 workshop on interactive 3D graphics (I3D’3D), 1986, pp.45.979 New York, NY, USA: ACM.

18.

GeomView. Object file formats – geomview manual, www.geomview.org/docs/html/Object-File-Formats.html (2015, accessed 11 June 2019).

19.

GeomView. Off files – geomview manual, www.geomview.org/docs/html/OFF.html (2015, accessed 11 June 2019).

20.

Cignoni

Callieri

Corsini

, et al. Meshlab, www.meshlab.net/ (2015, accessed 11 June 2019).

21.

Cignoni

Callieri

Corsini

, et al. MeshLab: an open-source mesh processing tool. In: Eurographics Italian chapter conference (eds V Scarano, RD Chiara and U Erra). Italy: The Eurographics Association, 2008, pp. 129–136.

22.

Josuttis

NM.

The C++ standard library: a tutorial and reference. Boston, MA, USA: Addison-Wesley Longman Publishing Co., Inc., 1999.

23.

Hayes

Krippendorff

Answering the call for a standard reliability measure for coding data. Commun Methods Meas 2007; 8: 77–89.

24.

Freelon

ReCal OIR: ordinal, interval, and ratio intercoder reliability as a web service. Int J Internet Sci 2013; 1: 10–16.

25.

Landis

Koch

GG.

The measurement of observer agreement for categorical data. Biometrics 1977; 33: 159–174.

26.

O6.2307

Bigdan

The biggest loser competition. IEEE Trans Educ 2008; 51: 123–130.

27.

Arbelaitz

Martín

Muguerza

Analysis of introducing active learning methodologies in a basic computer architecture course. IEEE Trans Educ 2015; 58: 110–116. DOI:10.1109/TE.2014.2332448.

28.

Johnson

Hayes

MJ.

A comparison of problem-based and didactic learning pedagogies on an electronics engineering course. Int J Electr Eng Educ 2015; 53: 3–22.

29.

Hosseinzadeh

Hesamzadeh

MR.

Application of project-based learning (PBL) to the teaching of electrical power systems engineering. IEEE Trans Educ 2012; 55: 495–501.

30.

Bonwell

Eison

JA.

Active learning: creating excitement in the classroom. Washington, DC, USA: George Washington University Press, 1991.