Conference PaperPDF Available

A Scaffolding framework: Supporting the Construction of Programs on a Mobile Device

Authors:

Abstract and Figures

Computer programming is a difficult subject for most novice learners. Providing support that complements classroom learning could contribute to tackling the difficulties. Due to the ubiquity of mobile devices, such support can be provided by scaffolding the construction of programs on a mobile device. In order to design such a mobile intervention, learners' needs and limitations of mobile devices need to be placed at the center of the design process. This paper combines learners' needs and limitations of mobile devices to identify scaffolding strategies. Identification of scaffolding strategies is based on a scaffolding framework. Using specific examples, this paper will then show how the scaffolding strategies have been implemented on a mobile phone.
Content may be subject to copyright.
Supporting the Construction of Programs
on a Mobile Device: A Scaffolding
Framework
Chao MBOGO1, Edwin BLAKE2 , Hussein SULEMAN3
1,2,3Department of Computer Science, University of Cape Town, South Africa
Email: chao.mbogo@uct.ac.za1, edwin@cs.uct.ac.za2, hussein@cs.uct.ac.za3
Abstract: Computer programming is a difficult subject for most novice
learners. Providing support that complements classroom learning could
contribute to tackling the difficulties. Due to the ubiquity of mobile devices,
such support can be provided by scaffolding the construction of programs on a
mobile device. In order to design such a mobile intervention, learners needs
and limitations of mobile devices need to be placed at the center of the design
process. This paper combines learners’ needs and limitations of mobile devices
to identify scaffolding strategies. Identification of scaffolding strategies is based
on a scaffolding framework. Using specific examples, this paper will then show
how the scaffolding strategies have been implemented on a mobile phone.
Introduction
Computer programming is a difficult subject for most novice learners. Research
indicates this to be a universal problem (Apiola et al., 2011) (Maleko et al.,
2012). These difficulties indicate that some programming skills are beyond the
novice learners efforts. Scaffolding refers to support provided so that the
learner can engage in activities that would otherwise be beyond their abilities
(Jackson et al., 1998). Providing such support, in addition to the learners’
classroom learning, could contribute to tackling learning challenges. Supporting
learners outside the classroom recognizes that learning can take place at any
place, in any situation.
The ubiquity of mobile devices provides an opportunity to use them as a
resource to support learning outside the classroom. For example, mobile
phones could be used to support learning in cases where a learner does not own
a personal computer while away from school, or is in a situation where using a
personal computer would be inconvenient. In addition, recent work by
Microsoft on TouchDevelop (Tillmann et al., 2012) indicates that a programing
environment that runs on a mobile device has the potential to dramatically
reduce the technical learning overhead.
In order to design such a mobile intervention, learners’ needs need to be
understood, which helps in informing the design of an intervention that seeks
to support them. In addition to addressing learners’ needs, designing such a
mobile intervention requires that the limitations of mobile devices be
addressed. This is because, in order for handheld devices to become effective
learning tools, the unique design challenges inherent in such a system must be
understood (Luchini et al., 2002). Significant research has been carried out to
propose guidelines for designing on mobile devices for learning (for example
(Luchini et al., 2004) (Churchill & Hedberg, 2008) (Elias, 2011)). This paper
will refer to some of these studies in order to address design issues for
supporting construction of programs on a mobile device.
Having identified learners’ needs and limitations of mobile devices, the
next task is to propose scaffolding strategies that could address them. To
achieve this, this study utilizes a 5-step scaffolding framework that culminates
in implementing the scaffolding strategies on a mobile device.
The rest of the paper is organized as follows: using 3 examples, the
paper first reports on challenges and covers both learner-cited challenges and
mobile limitations; the next part consolidates the learners’ needs and mobile
limitations within a scaffolding framework in order to identify scaffolding
strategies, and illustrates how these scaffolding strategies have been
implemented on a mobile phone; and the last part concludes the paper.
Challenges
Learner-cited challenges
In order to understand the needs of programming learners, an online survey
was conducted among 160 learners of programming from three African
universities: University of Cape Town (UCT) (61 learners); University of
Western Cape (UWC) (37 learners); and Kenya Methodist University (KeMU)
(62 learners). The three universities were chosen because of their convenience
in terms of having established contacts. The survey was conducted by sending
an electronic questionnaire to the learners. The targeted learners were all from
computer related courses because programming is part of their curriculum.
76% of the total respondents indicated one challenge or the other that
they have faced or do face while learning programming. The learners were also
asked if they had used a mobile phone to construct programs, with 99% of the
learners indicating that they have not. For the sake of providing detailed
illustration, the 3 learner-cited challenges below are randomly selected from the
ones cited, and will be used as running examples for the rest of the paper.
i. Difficulty in combining required program parts into a working program and
hence making logic or sense out of a program is challenging. This challenge
is further supported by research pointing to two key problems preventing
success in programming among novice learners (Guzdial et al., 1998):
decomposition problem, where learners have difficulty choosing which of the
available program components are needed for a solution; and composition
problem, in which even when learners identify program components, they
have difficulty assembling the modules into a proposed solution.
ii. Unclear error messages while debugging. A study that looked at common
Java errors made by learners (Hristova et al., 2003) indicates that even
though compilers may flag some of the error messages while programming,
often the error messages are so cryptic to students that they have a hard
time understanding them.
iii. Small screens of mobile phones pose a challenge in using it as a resource to
learn programming. This limitation is described in the next subsection.
Mobile devices limitations
There are certainly several factors that have to be taken into consideration
when it comes to mobile devices since they present usability problems
(Kukulska-Hulme, 2007). However, to define the scope of which mobile
limitations to consider, this paper will look at screen size of mobile phones (as
pointed out by the learners) and their small keypad. Considering these
limitations is crucial because, in writing a program, a learner needs to see (on a
screen display) what they are constructing (through typing).
Small screen and keypad size
The key limitation of handheld technology for the delivery of learning objects is
the small screen that is available for effective display (Churchill & Hedberg,
2008). Research indicates that the following strategies could address the small
screen sizes of mobile devices while designing for learning:
i. Using activity decomposition to structure handheld tools (Luchini et al.,
2004) and package contents in small chunks (Elias, 2011).
ii. Design interface elements to serve a dual role by providing both
functionality and scaffolding (Luchini et al., 2004).
iii. Minimize scrolling as much as possible (Churchill & Hedberg, 2008).
Scrolling can be reduced by placing navigational features near the top of the
pages in a fixed place (Jones et al., 1999).
iv. Provide one step interaction, which can be achieved by immediate update
upon interacting with a widget or a button. (Churchill & Hedberg, 2008).
v. Design to include movable, collapsible, overlapping and semitransparent
interactive panels (Churchill & Hedberg, 2008).
The small keypad of mobile phones also presents a usability challenge.
While typing is needed to write a program, automating some tasks could
minimize the disadvantage of having to type on a small keypad. However, care
should be taken not to have an interface that is too automated such that
students complete the task by rote rather than mindfully engaging and learning
about the task (Luchini et al., 2004).
Mobile phones with touch screens have a soft keypad that pops up
when typing, hence covering up nearly half the screen. Minimizing scrolling by
use of a tabbed screen (such that users can scroll across and not downwards),
could reduce the amount of information that gets covered up by the soft
keypad. In addition, using activity decomposition such that smaller tasks are
presented on the screen could also mean that most, if not all of the task is
visible at the top half of the screen.
Scaffolding framework
Having identified learner challenges and mobile phone limitations, the next step
is to integrate them within a scaffolding framework. The scaffolding framework
comprises a 5-step framework that follows the following steps:
i. Step 1: Identify learner challenges. These have been identified in the
previous section.
ii. Step 2: Categorize each learner challenge into one of three types of
cognitive challenges (Quintana et al., 2009): Sense making, which involves
the basic operations of interpreting data; Process management, which
involves strategic decisions in controlling an inquiry process; and
Articulation and reflection, which is the process of constructing, evaluating
and articulating what has been learnt.
iii. Step 3: Identify what kind of scaffolding type the learner challenge may
need, from three types (Jackson et al., 1998): Supportive scaffolding, which
offers support for doing the task while the task itself remains
unchanged; Reflective scaffolding, which offers support for thinking about
the task; and Intrinsic scaffolding, which offers support that changes the
task itself and reduces complexity.
iv. Step 4: Identity the scaffolding guideline based on which the intended
tool can modify the task to help learners overcome obstacles, depending
on the cognitive type. Seven scaffolding guidelines exist (Quintana et al.,
2009) and are redefined to fit into this study towards a mobile strategy
for supporting learners of programming:
a. Guideline 1: Use representation and language that bridge learners’
understanding of programming.
b. Guideline 2: Organize the mobile strategy around the semantics of
the programming language.
c. Guideline 3: Use representations that learners can inspect in different
ways to reveal important properties about underlying data.
d. Guideline 4: Provide structure for complex tasks and functionality.
e. Guideline 5: Embed expert guidance about programming practices.
f. Guideline 6: Automatically handle routine tasks.
g. Guideline 7: Facilitate ongoing articulation and reflection during
program construction.
v. Step 5: In this step, specific scaffolding strategies are chosen to be
implemented on the mobile device in order to support construction of a
program.
The next subsections discuss how steps 2 to 5 can be applied to the 3
learner challenges, leading to the selection of specific scaffolding strategies as
possible solutions. The strategies identified are implemented on a mobile phone
developed for the Android platform. Android has been selected for
development because it is open source. The implementation targets Android
version 2.2 and later. Java has been selected as the language of program
creation within the application. This is because it is the common language
taught across the 3 universities where the online survey was conducted. In
addition, most, if not all universities offer a first-year programming course
taught using Java.
Learner Challenge 1: Difficulty in connecting program parts into one
Step 2: Categorizing challenge into a cognitive type
This learner challenge is one of sense making because it involves being able to
make sense out of a program and its constituent parts, while it is also one of
process management because it requires scaffolding strategies that can control the
learner’s inquiry process so that the learner can effectively make sense of how
the different program parts connect into one.
Step 3: Identifying the scaffolding types that the learner challenge may
need
A supportive scaffolding type can be provided to provide support while the
learner is attempting to make sense of the different parts and functionality of a
program. At the same time, an intrinsic scaffolding type can be provided to
reduce the complexity while creating the program.
Step 4: Identifying scaffolding guidelines that may address challenge
cognitive type
In order to support sense making, using representation and language that bridge
learners understanding and using representation that learners can inspect in different ways
could be used as scaffolding guidelines. In order to support process
management, providing structure for complex tasks and functionality could be used as a
scaffolding guideline. These three scaffolding guidelines can be met by the
scaffolding strategies described next.
Step 5: Select scaffolding strategies that implement the scaffolding
guidelines
In order to provide representation and language that bridge learners’
understanding, the following two scaffolding strategies have been selected
(Quintana et al., 2009):
a. Provide visual organizers to give access to functionality.
b. Embed expert guidance to help learners use the content.
In order to provide structure for complex task and functionality, the following
scaffolding strategy has been selected (Quintana et al., 2009):
c. Restrict a complex task by setting useful boundaries for learners.
The discussion below addresses each of these three strategies and how they
have been implemented on a mobile phone.
Provide visual organizers in order to give access to functionality
This strategy can be implemented by providing a layout of the parts of a Java
program in order to give the learner an overview of the program. The order of
the parts in the interface is guided by standard Java coding guidelines (Sun-
Microsystems, 1997), where a Java source file has the following ordering:
beginning comments, package and import statements, and class and interface
declarations. Figure 1 shows the designed main interface with program parts
that can support the kind of programs written in a beginner Java class.
Figure 1. Main interface Figure 2. Default code Figure 3. Restricted Figure 4. Unrestricted
Embed expert guidance to help learners use content
This strategy can be implemented by providing some default code. Figure 2
shows implementation of default code in creating the main class declaration,
which the learner can then edit. This default code is revealed when the main
class button has been clicked. Further, in order for the learner to be able to
know which page they are working on or which one to swipe to, the different
pages of the application can be labeled at the top as shown in figures 1 to 4.
Restrict a complex task by setting useful boundaries for learners
This strategy can be implemented by restricting a learner to complete a program
in a certain order. For example, a learner can be guided to first complete the
main class because it is also used as the name of the program; then the header
comment in order to guide the learner to give the description of the program
they are about to write; then the main method as the entry point of the
program; then they can complete methods and import sections if needed.
Figure 1 only shows the main class activated when the program is started, while
Figure 3 shows the main class completed (in green) and the header comment is
activated. After completion of a certain number of programs in this restricted
order, a learner can be presented with an interface where all the parts are
enabled and the learner is able to complete the program in any order (Figure 4).
While the learner can work with the interface in Figure 4, they are able to go
back to the restricted interface if they wish to. This also provides structure to
complete the task using ordered decomposition (restricted) and unordered
decomposition (unrestricted) (Quintana et al., 2009).
Learner Challenge 2: Difficulty in debugging errors in programs
Step 2: Categorizing challenge into a cognitive type
This learner challenge is one of process management because it requires scaffolding
strategies that can contribute to the learner’s inquiry process while debugging a
program. It is also one of articulation and reflection because it contributes to
thinking about and evaluating what has been constructed.
Step 3: Identifying the scaffolding types that the learner challenge may
need
An intrinsic scaffolding type can be provided as error prompts to reduce the
complexity while debugging the program. This also offers a reflective scaffolding
type that enables the learner to think about the program.
Step 4: Identifying scaffolding guidelines that may address challenge
cognitive type
In order to support process management, the intervention should embed expert
guidance about the scientific practice, in this case being Java coding guidelines. In
order to support articulation and reflection, the intervention should provide
ongoing articulation and reflection during completion of the program. These two
scaffolding guidelines can be met by the scaffolding strategies described next.
Step 5: Select scaffolding strategies that implement the scaffolding
guidelines
In order to embed expert guidance and to facilitate a learner to reflect about the
task, the selected scaffolding strategy is one which embeds expert guidance
(Quintana et al., 2009) to clarify characteristics of Java practices.
Embed expert guidance to clarify characteristics of Java practices
While a novice learner constructs a program, they will inevitably make mistakes
that will lead to compile time or run time errors. While it is not possible to
predict all the types of mistakes that learners can make, this study will attempt
to address Java-syntax related errors. This is because learners indicated syntax
to be a difficulty in the subject, and another study indicated Java programming
syntax as among the top 5 difficulties while learning programming (Sivasakthi &
Rajendran, 2011).
Figure 5 shows creation of a main class, albeit using an incorrect syntax
of starting a Java class name in lower case. If the learner proceeds with this
class name creation, then an error message is displayed (Figure 6). If they
choose to not edit the class name, they can exit this window but no changes will
be made to the class name, hence it will be considered as not having been
created. Figure 7 shows creation of a main method. Assume a learner
erroneously writes the return statement here, an error prompt will be displayed
indicating this error (Figure 8).
Figure 5. Main class Figure 6. Prompt Figure 7.Main method Figure 8. Prompt
Learner Challenge 3: Small screen size and small keypad of a mobile
device
Step 2: Categorizing challenge into a cognitive type
This learner challenge is one of process management because it requires scaffolding
strategies that can support the learner’s inquiry process on a mobile device,
which has screen size and input limitations.
Step 3: Identifying the scaffolding types that the learner challenge may
need
A supportive scaffolding type can provide support while the learner is using the
small screen size and small keypad to construct a program.
Step 4: Identifying scaffolding guidelines that may address challenge
cognitive type
In order to support the process management, providing structure for complex tasks,
and automatically handling routine tasks could be used as scaffolding guidelines.
These two scaffolding guidelines can be met by the scaffolding strategies described
next, as possible solutions to support use of mobile devices with small screen
and keypad limitations.
Step 5: Select scaffolding strategies that implement the scaffolding
guidelines
In order to provide structure for complex tasks, the selected scaffolding
strategy is (Quintana et al., 2009): Constraining the space of activities by using
functional modes but enable inspection of multiple views of the same object or
data. In order to automatically handle routine tasks, the selected scaffolding
strategy is (Quintana et al., 2009): Automating non-salient portions of tasks.
Constrain the space of activities by using functional modes but enable inspection of multiple
views of the same object or data
A task can be scaffolded by enabling the program to be completed one part at a
time. Because of the restriction of small screen size, which will remain
unchanged, this scaffold is static and should not fade. Ability to work on a part
of the program at a time uses activity decomposition to package the small
chunks (Luchini et al., 2004) (Elias, 2011). This assists in working with the small
screen. Figures 5 and 7 show how working on one program part at a time could
assist in addressing the soft keypad taking up nearly half the screen, and
minimize scrolling. By placing the task to be edited near the top of the screen,
the soft keypad does not cover much of the task, if at all. In addition, the
interfaces show use of navigation labels at the top of the screen as
recommended (Jones et al., 1999). Navigation tabs constrain the space of
activities by placing information in different segments that can be viewed by
scrolling across and not downwards.
However, for a learner to have a mental image of how the different parts
of the task work together, learners should be able to inspect the task they are
working on in multiple ways. In this case, while working on a program part (for
example editing the main method in Figure 9 to add a call to the method out()),
a learner can swipe to the next tab and view the whole program (Figure 10) at
the state at which it was last saved. This ability to move between a program part
and the whole is one of diving-in and stepping out, and promotes cognitive
growth by keeping the learner connected to the chunks, while at the same time
able to appreciate existence of the whole problem (Ackermann, 1996).
Figure 9. Editing main method Figure 10. Full program as was last saved
Automate non-salient portions of tasks
Because of provision of some default code (for example, Figure 2), the learner
is at least spared from typing from scratch using the small keypad. However,
the learner is still required to complete the program parts and hence they need
to mindfully engage and hence learn the task, as recommended (Luchini et al.,
2004). Further, the learner should be able to exit without completing a program
part, but a message indicating that the task has not been changed could assist in
making sure that a learner actually completes a task for it to be created in the
program (Figure 11).
Figure 11. Prompt for unchanged main class
Discussion
In summary, possible solutions to support a learner to connect different
program parts into one are: provide an overview of the program using standard
coding guidelines; restrict the order of completion of the program; enable
completion of the program in any order after a number of programs but allow
the learner to enable completion in a restricted order; and embed default code
as expert guidance.
Possible solutions to support a learner in debugging a program are:
prompt the learner of a syntax-error as soon as it occurs; and provide some
expert guidance in completion of program parts. Possible solutions to address
the small screen and keypad are: providing default code that minimizes typing;
enable completion of the program one part at a time while able to view the full
program; and use navigation tabs that allow scrolling across, not downward.
Conclusion and future work
This paper has illustrated how a scaffolding framework has been used to select
scaffolding strategies to address learner challenges. More specifically, the paper
has followed a learner-centered methodology where the learners’ needs
influenced the choice of scaffolding strategies. Also, the paper illustrates how
the scaffolding strategies have been implemented on a mobile phone,
considering its screen size and keypad limitations, to scaffold construction of
Java programs. Therefore, this paper has concretely shown a theoretic
derivation of scaffolding strategies, and consequently their implementation on a
mobile device.
The use of the scaffolding framework has resulted in the choice of
specific scaffolding strategies such as: providing a visual representation of a
Java program by showing an overview of the program parts; enabling
interaction with these parts using collapsible and expandable buttons and
clickable parts; providing some default code; providing one step navigation
ability between the pages; enabling completion of the program one part at a
time while being able to view the full program; and providing error prompts as
soon as a learner makes a mistake. These scaffolding strategies address the cited
learners’ needs and also limitations of mobile phones such as small screen size
and small and soft keypad.
Current and future work consists of testing the application with learners
of programming in different African universities. The evaluation of the results
from the experiments seeks to understand two issues: which of the theoretically
derived scaffolding strategies are appropriate, and which are inappropriate, to
support construction of programs on a mobile device; and how learners use the
scaffolds as they construct programs on a mobile device.
Acknowledgement
This work is supported by funding from the Hasso Plattner Institute,
and resources in ICT for Development laboratory at University of Cape Town.
References
Ackermann, E., 1996. Perspective-Taking and Object Construction. In Y..a.R.M. Kafai, ed. In Constuctionism
in Practice: Designing, Thinking, and Learning in a Digital World. Mahwah, New Jersey: Lawrence Erlbaum
Associates. pp.Part 1, Chap.2.
Apiola, M., Tedre, M. & Oroma, J.O., 2011. Improving Programming Education in Tanzania: Teachers'
and Students' Perceptions. In Proceedings 41st ASEE/IEEE Frontiers in Education Conference., 2011.
Churchill, D. & Hedberg, J., 2008. Learning object design considerations for small-screen handheld devices.
Computers and Education , 50, pp.881-93.
Elias, T., 2011. Universal instructional design principles for mobile learning. The International Review of
Research in Open and Distance Learning , 12(2), pp.143-56.
Guzdial, M. et al., 1998. upporting Programming and Learning-to-Program with an Integrated CAD and
Scaffolding Workbench. Interactive Learning Environments, 6(1-2), pp.143-79.
Hristova, M., Misra, A., Rutter, M. & Mercuri, R., 2003. Identifying and correcting Java programming
errors for introductory computer science students. In SIGCSE '03 Proceedings of the 34th SIGCSE technical
symposium on Computer science education., 2003.
Jackson, S., Krajcik, J. & Soloway, E., 1998. The design of guided learner-adaptable scaffolding in
interactive learning environments. In CHI '98 Proceedings of the SIGCHI Conference on Human Factors in
Computing Systems. Los Angeles, CA USA, 1998.
Jones, M. et al., 1999. Improving Web interaction on small displays. Computer Networks, 31(11), pp.1129-37.
Kukulska-Hulme, A., 2007. Mobile Usability in Educational Contexts: What have we learnt? International
Review of Research in Open and Distance Learning, 8(2).
Luchini, K. et al., 2002. Scaffolding in the small: designing educational supports for concept mapping on
handheld computers. In CHI'02 Extended Abstracts on Human Factors in Computing Systems., 2002.
Luchini, K., Quintana, C. & Soloway, E., 2004. Design Guidelines for Learner-Centered Handheld Tools.
In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI '04). New York, 2004.
Maleko, M., Hamilton, M. & D'Souza, D., 2012. Novices' perceptions and experiences of a mobile social
learning environment for learning of programming. In ITiCSE '12 Proceedings of the 17th ACM annual
conference on Innovation and technology in computer science education., 2012.
Quintana, C. et al., 2009. A Scaffolding Design Framework for Software to Support Science Inquiry. Journal
of the Learning Sciences, 13(3), pp.337-86.
Sivasakthi, M. & Rajendran, R., 2011. Learning difficulties of ‘object-oriented programming paradigm using
Java’: students’ perspective. Indian Journal of Science and Technology, 4(8), pp.983-85.
Sun-Microsystems, 1997. Code Conventions for the Java Programming Language. [Online] Available at:
http://www.oracle.com/technetwork/java/codeconventions-150003.pdf [Accessed 19 November
2013].
Tillmann, N. et al., 2012. The Future of Teaching Programming is on Mobile Devices. In ITiCSE’12
Proceedings of the 17th ACM annual conference on Innovation and technology in computer science education. Haifa,
Israel, 2012.
... In order to provide scaffolding techniques in a mobile programming environment, an Android application was designed based on a theoretical scaffolding framework (Quintana et al. 2004), challenges faced by learners of programming, and limitations of mobile phones (Mbogo et al. 2014). The application was designed to support construction of Java programs. ...
Article
Full-text available
The ubiquity of mobile phones provides an opportunity to use them as a resource for the construction of programs beyond the classroom. However, limitations of mobile phones impede their use as typical programming environments. This research proposed that programming environments on mobile phones could include scaffolding techniques specifically designed for mobile phones, and designed based on learners’ needs. Experiments were conducted with 142 learners from three universities in Kenya and South Africa in order to investigate the effect on learners of using the theoretically-derived scaffolding techniques to construct Java programs on a mobile phone. The results provided empirical evidence that scaffolding techniques specifically designed for mobile phones and designed based on learners’ needs could effectively support the construction of programs on a mobile phone.
Article
Full-text available
Piaget defines intelligence as adaptation, or the ability to maintain a balance between stability and change, or, in his own words, between assimilation and accommodation. When people assimilate the world to their current knowledge, they impose their order upon things. This momentary closure is useful to build "invariants" that lend existence to the world, independent of immediate interaction. In accommodation, people become one with the object of attention. This may lead to momentary loss of control, since fusion loosens boundaries, but allows for change. I choose the domain of perspective-taking to illustrate how this alternation between assimilation and accommodation punctuate individuals' interactions with the world. I show that the ability to move away from one's own standpoint, and to take on another person's view, requires the construction of cognitive invariants: a recasting of the world's stabilities that transcends any given viewpoint. I conclude that separation is a necessary step toward the construction of a deeper understanding, and that adopting a "god's eyes view" is by no means contrary to situating one's one stance in the world.
Conference Paper
Full-text available
Programming in Java can be a daunting task for introductory students, one that is only compounded by the cryptic compiler error messages they see when they first start to write actual code. This article details a project conducted by faculty and advanced students in the creation of an educational tool for Java programming, called Expresso. This paper discusses some existing programming tools, explains their drawbacks, and describes why Expresso is different. We also include a detailed list of typical errors made by novice programmers, used in the construction of the Expresso tool.
Article
Java programming is popular both in Academia and IT Industry. Further, it is the maximum usage of programming across the world. There is a wide edge between industry expectations and knowledge of students in Java programming. Teaching and learning of Java programming in academia is the greater responsibility to shrink that edge. The present study has been conducted in this regard to investigate the factors that lead to students' learning difficulties in Object-Oriented Programming Paradigm using Java. The result of this study indicates that the students have learning difficulties on the topics of Java programming. The nature of difficulties, situations and the various factors that lead to poor performance in learning of Java programming were also identified.
Article
From paper to computers, the way we have been writing down thoughts and performing symbolic computations has been constantly evolving. Teaching methods closely follow this trend, leveraging existing technology to make teaching more effective and preparing students for their later careers with available technologies. At present, we are in the middle of another technology shift: instead of using PCs and laptops, mobile devices are becoming more prevalent for most everyday computing tasks. We propose that computer programming, and thus the teaching of programming, can and should be done directly on the mobile devices themselves, without the need for a separate PC to write code. Programming on mobile devices engages students in new ways, allowing them to access and manipulate programmatically their most personal digital data such as pictures, videos, and music in an easy and intuitive way. The poster highlights opportunities and challenges of teaching and learning in the context of TouchDevelop, and writing programs on mobile devices in general. The poster will depict data from surveys conducted before and after class with students learning to program for the very first time. The poster will also introduce teaching and learning resources available to teachers. TouchDevelop is freely available as an app in the Windows Phone Marketplace and is supported by a book, slides, tutorials and many sample programs. See www.touchdevelop.com.
Article
In this paper we report programming novices' perceptions and experiences of a Mobile Social Learning Environment (MSLE) designed to support the learning of programming through enabling increased novice-to-novice interactions. By capturing and analysing such interactions early it is hoped that instructors may identify misunderstandings and misconceptions of novice programmers, and provide timely feedback to alleviate novices' misunderstandings. The MSLE incorporates the use of mobile devices as well as the access to dedicated social networking sites. Novices from three different universities, each with different modes of delivery, participated in this research. Novices' perceived advantages of the MSLE include among other things instant access to discussions, increased interactions, instant feedback in a student-student context, and the ability to share ideas and views anytime, anywhere. Novices have experienced increased interactions among themselves and improved engagement with learning in the MSLE. Novices were able to form learning communities and able to share knowledge and ideas about programming language with each other. Some novices were able to provide assistance to others, hence indirectly, strengthening their own knowledge of programming. The cost of mobile devices and Internet charges on the other hand were perceived as disadvantages of a MSLE. Small screens, lack of programming applications for smart phones, laptops' battery life and distractions from other internet media were some of negative experiences observed by novices who used the MSLE.
Article
Contextualization of curriculum and course contents has been central to development of IT education at Tumaini University in rural Tanzania. However, as the development of the IT program has progressed, pedagogical challenges have become increasingly evident. The pedagogical difficulties materialize most markedly in programming courses. This paper reports an empirical study of students' and teachers' perceptions of challenges of programming education in Tanzania. The results support the anecdotal evidence from various developing countries that programming education is hindered by shallow learning strategies, unfamiliar pedagogical approaches, language problems, extrinsic motivations, free riding in group assignments, and cultural differences.
Article
Programming is a complex cognitive task for students, because of the difficulty of finding the appropriate elements (the “decomposition” problem) and integrating them correctly into a whole (the “composition” problem). Programming is also hard to learn, because so much of the thinking behind a program is implicit and the process of programming is long and complicated. Our approach is to integrate a computer-aided design tool (CAD) with scaffolding to create a single, cohesive, and coherent workbench for the entire process. Our workbench is called the GPCeditor. We have evaluated its use by high-school students. Our results suggest that students program well in the GPCeditor, they learn good programming practices, and that the learning is occurring through use of the GPCeditor.
Article
The key limitation of handheld technology for the delivery of learning objects is the small screen that is available for effective display. The smallness of the screen not only adversely affects the clarity, but it also negatively impacts on the acceptance and integration of this potentially useful technology in education. Handheld devices are likely to change further in size in the future with consumer demand for less bulky but more powerful devices. This exploratory study investigated characteristics of effective design of learning objects on such devices. This paper reports upon user response to learning object design possibilities and provides a set of recommendations to guide improved utility and future research.