Journal of Software Engineering and Applications, 2012, 5, 816-822
http://dx.doi.org/10.4236/jsea.2012.510094 Published Online October 2012 (http://www.SciRP.org/journal/jsea)
The Effects of Objects-First and Objects-Late Methods on
Achievements of OOP Learners
Murat Pasa Uysal
Rochester Institute of Technology, Saunders College of Business, Department of MIS and Decision Sciences, Rochester, USA.
Received August 15th, 2012; revised September 17th, 2012; accepted September 29th, 2012
ABSTRACT
Our research explored the effects of objects-first and objects-late methods on achievements of object-oriented pro-
gramming (OOP) learners during a graduate course. The course’s scope was virtually identical for two groups, but the
structure of the contents differed in sequence. The objects-first method emphasized the design and discussion of the
object-oriented concepts from the very beginning while the objects-late deferred these concepts to the late lectures. The
objects-first learners used all visual functionalities of BlueJ IDE. However, the objects-late learners started with only
the text-based interfaces of BlueJ and they benefited its visual support in the last lectures. At the end of the study, we
found that there was a statistically sign ificant difference between OOP learner groups.
Keywords: Object-Oriented Programming; Objects-First; Objects-Late
1. Introduction
It is fair to say that object-oriented programming (OOP)
has gained much interest while it is becoming a common
programming paradigm. This is partly because it is simi-
lar to our view of the real world. However, it has been
difficult to introduce OOP to novice programmers [1-4].
The instructional methods, tools and the programming
languages constitute the intrinsic or external factors for
learning programming and they may greatly determine
the complexity of this paradigm [5,6]. Consequ ently, tea-
ching and learning OOP have been sources of many stu-
dies since they are challenging not only for students, but
also for instructors. The studies are continually evolving
in the hope of finding better tools, methods or innovative
strategies. The literature review of teaching OOP suggests
that the research studies conducted on teaching OOP can
be broadly divided into three categories, as 1) Program-
ming or educational tools for OOP learners; 2) Instruc-
tional approaches to teaching OOP; and 3) Learners’ cha-
racteristics, conceptions and attitudes to OOP.
The instructional methods, objects-first and objects- late,
are two of the important topics centering in the research
area of teaching OOP. The primary reason would be the
debates that are continuing whether introducing the ob-
jects and classes to the students at the very beginning is
the right decision [7]. Because, there are many peda-
gogical dimensions involved in the issues, and we need
to classify and clarify these effecting parameters care-
fully [8]. It seems that instructional effectiv eness of these
methods will continue being a subject to many discus-
sions and more empirical evidence is needed to reach
reliable conclusions. In this study, we compared two in-
structional methods for teaching OOP, which are the ob-
jects-first and the objects-late method. The next sections
present this study along with the findings and discussion.
2. Tools and Methods for Teaching OOP
The studies on educational tools of OOP includ e instruc-
tional environments, such as programming micro-worlds,
and the other tools for enhancement of current program-
ming environments. These instructional tools generally
differ in their support for adopted OOP paradigm, user
interface, interactivity and visualization. As students’ readi-
ness and the knowledge level have important effects on
learning, a special notice has to be given to the needs of
novice learners when deciding on instructional environ-
ment [9-11]. Within environment, the ease of use should
be provided by a graphical user interface that enhances
editing, compilation and debugging options. The visuali-
zation can be supplied to aid thinking in terms of classes
and object beha viors whi le allowin g the use of bot h graphical
and textual representations. The fundamental problem of
existing programming environments is that they are not
completely object-oriented, they are complex and they
focus mainly on user interfaces [12]. Therefore, it is ex-
pected from an OOP learning environment that it meets

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners 817
the needs such as ease of use, support for code reuse,
object-support, learning support, and finally group sup-
port [13]. BlueJ, DrJava, JKarelRobot, JCreater LE and
Alice are some of the examples of educational environ-
ments used in the literature [10,13-15].
The other determining factor for teaching OOP is the
instructional approach that has a close relationship with
the programming paradigms. The way of structuring or
organizing the programming tasks performed on a com-
puter determines these paradigms. For example, impera-
tive and declarative programming has found an important
place in a wide range of applications. With the increased
popularity of OOP paradigm, objects-first and objects-
late instructional approaches have been attracting much
interest among OOP researchers. The objects-first meth od
puts emphasis on both design and programming princi-
ples of OOP from the very beginning. However, the ob-
jects-late method initially starts with non-object-oriented
concepts, such as the statements and the control struc-
tures, and it defers the discussion of classes and objects
to later lectures. Additionally, the conceptual approach,
the apprentice approach, the model-first approach and the
hybrid methodologies could be given as the other meth-
ods to teach OOP [16-18].
3. Method
The goal of this study was to find the effects of object s- f ir s t
and objects-late methods on achievements of OOP learn-
ers. The academic performance constitu ted the dependen t
variable of our research design. The hypothesis was:
Hypothesis: The achieve ments of students will not dif-
fer significantly according to the OOP teaching methods.
We carried out the study with two experimental groups.
Both the participants in group-1 and group-2 used BlueJ
IDE. This was to eliminate possible effects of different
instructional tools. The students were pre-tested and post-
tested, and group-2 was administered as the treatment.
The pre-tests and post-tests were given as open-ended aca-
demic achievement tests to determine whether the par-
ticipants (Table 1) acquired the OOP knowledge and
skills.
3.1. Subjects
The twenty male graduate OOP learners participated to
this study. The students previously received a BS degree
in systems engineering. They knew structured program-
ming with Java at an introductory level and they previ-
ously used JCreater LE as a software development tool.
Table 1. The representation of the research design.
Group Pre-test Method Tool
Post-test
Group-1 X Objects-late BlueJ X
Group-2 X Objects-first BlueJ X
3.2. OOP Environments
When designing the OOP instructional environments, it
is important to give a special notice for choosing a pro-
gramming environment. In general, professional software
development tools are not suited for introducing learners
to OOP. They are optimized for rapid application devel-
opment as well as the needs of software professionals.
Therefore, we considered mostly the pedagogical issues
when deciding on the software development tool for this
study. There are specific requirements for a first year
object-oriented teaching. First, the basic concepts of OOP
should be presented with simple and well-defined in-
structional strategies to teach in a consisted and under-
standable environment. Second, programming tool should
display object-orientation by adopting a basic abstraction
approach. Third, it should have an understandable execu-
tion model while avoiding the concepts that would possi-
bly lead to erroneous programs. Finally, development en-
vironment should be easy to use with a debugger so that
students can focus on learning OOP concepts rather than
the environment itself [3].
BlueJ is the programming tool chosen for this study. It
is an IDE especially for introductory teaching of OOP. It
is hypothesized that OOP is not intrinsically complex,
but it is made more complicated by a lack of approp riate
tools [13]. Commercial tools mainly focus on user inter-
faces and they are too complex for the beginners. How-
ever, BlueJ’s environment facilitates the discussion of
object-oriented design by allowing interaction with ob-
jects before implementing them. It helps adopting a true
objects-first approach while introducing the classes, ob-
jects and methods concepts before talking about Java and
its syntax. The direct interactivity with classes and ob-
jects, the mechanisms allowing sophisticated and detailed
testing of classes, and finally the visualization of object-
oriented (OO) concepts could be given as the reason for
preferring it as an objects-first teaching tool. A novice
programmer using BlueJ is not only able to execute a co-
mplete application, but also she can directly interact with
the objects of any classes without writing a complete
application. Furthermore, the simple debugging mecha-
nism showing the internal states of objects allows a quick
and easy understanding of the Java code.
The unique nature of BlueJ is its user interfaces sup-
porting a greater degree of interaction than the other OOP
environments. Most importantly for our study, it allo wed
us to adopt two different OOP instructional approaches
by enabling both conventional text-based and UML like
programming interfaces.
3.3. Procedure
The students participated in a graduate course aiming to
introduce OOP to the students with little prior knowledg e.

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners
818
The fundamentals of OOP concepts were given in this
course. It consisted of two-hour lecture and two-hour lab
per week, with 13 weeks per semester. The same instruct or
taught the students in group-1 and group-2 on different
days. The expected learning outcomes were:
The participants should
 Be able to define the basic concepts of OOP: classes,
objects and methods;
 Develop skills for reading, writin g an d de bugg ing OO
programs;
 Understand statements, iterative and conditional struc-
tures in Java language;
 Be able to write event-based interactive programs;
 Be able to apply the abstraction, inheritance, polymor-
phism and encapsulation concepts to their programs.
The course’s scope was virtually identical for two ex-
perimental groups, but the structure of the contents dif-
fered in their sequence (Tables 2 and 3). The contents
were designed and grouped into the units so that they
were consisted with either of the OOP teaching methods.
The two-hour lecture included necessary programming
topics, OOP concepts and illustration of sample prog-
rams. The weekly exercises and the lab studies were dif-
ferent in both presentations and example applications.
Thus, instructional activities were tailored to each of the
group’s Java programming interfaces.
Table 2. The sequence and structure of the course topics for
objects-late method.
Weeks The objects-late lecture topics (group-1)
1 Introduction of BlueJ IDE, representation of class, methods
and attributes at an introductory level.
2 Data types, variables, constants. Assignment statements.
Referencing to object and cl ass con cept s.
3 The use of operators and conditional statements with sample
applications.
4 Loops and iteration structures with sample applications.
5 Editing and modifying existing classes. Creating new classes
with members & methods, observing object behaviors and
states with sample applications.
6 Event handling in Java applications.
7 Working with graphics (i.e. drawing lines, rectangle, and
circle). Introducing the AWT.
8 The “Shapes” project: creating single classes of circles, squares and triangles which can be moved, resized and
changed in color.
9 Introducing abstraction, inheritance, polymorphism concepts
with basic UML diagrams
10 The design principles of a large project, interaction of
multiple objects to perform a complete programming task.
11 The “Picture” project: creating a picture class combining
various shapes to draw a picture.
12 Introduction to software engineering, object-oriented design
principles, software development processes.
13 The post-test.
Table 3. The sequence and structure of the course topics for
objects-first method.
Weeks The objects-first lecture topics (group-2)
1 Introduction to BlueJ environment,
OOP paradigm, object, class and method concepts.
2 Objects, classes, methods, parameters, fields, object states,
presentation and application of these concepts in BlueJ
environment.
3 Assignment statements, constructors, data types,
presentation and application in BlueJ environment.
4 Programming, debugging and testing principles in BlueJ
environment.
5 Abstraction, inheritance, polym orphism concepts,
applications in BlueJ environment.
6 B as ic ob ject-oriented design principles with UML diagrams.
7 The presentation of operators, conditional statements, loops
and iterations in BlueJ with simple examples.
8 Editing and modifying existing classes. Creating new classes
with members & methods, and observing object behaviors
and states in sample applications.
9 The “Shapes” project: creating single classes of circles, squares and triangles, which can be moved, resized and
changed in color.
10 The design principles of a large project, interaction of
multiple objects to perform a complete programming task.
11 The “Picture” project: creating a picture class combining
various shapes to draw simple pictures.
12 Introduction to software engineering, software development
processes and object-oriented design principles.
13 The post-test.
The objects-late method initially followed the classical
instructional pattern, which was similar to that in most of
the structured Java programming courses (Table 2). The
participants started using BlueJ’s text-based interface.
Their first program was about a class with the “main”
method saying “Hello World” (Figure 1). The instructor
specially noticed that the group-1 learners gave their fo-
cus to the text-based editor rather than graphical repre-
sentations. Therefore, the students directly started devel-
oping stand-alone applications in BlueJ instead of using
the UML like representations of Blu e J.
During the f irst 7 weeks of lectu re and lab hours, grou p -1
participants followed the same sequence when develop-
ing applications. This was: (1st) they opened BlueJ IDE;
(2nd) from the “Edit” menu, they used the “New Class”
or “Add Class From File” menu options for a start of
application; (3rd) they opened the editor window to edit
their code; (4th) they cleaned the existing code added
their “main method” or they exercised the given applica-
tion code added from a file. The instructor initially de-
scribed the Java programming by its syntax rules and
semantics. The arrangements of the words and punctua-
tions were presented in a framework syntax while the
meaning of these rules given in a form of cause-effect

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners
819
Figure 1. BlueJ interfaces used by objects-late learners.
relationships. The participants formed the basic program-
ming constructs such as variables, data types and state-
ments. Later, the selection and iterative control structures
were given in the next contents. The lectures also cov-
ered the issues of writing clear and understandable cod es
as well as testing and debugging techniques. The students
developed their simple programs during the lab hours.
Since the classes are central for data and behaviors in
Java language, these constructs were illustrated briefly
with in the framework of class definitions. The core OOP
concepts such as inheritance and polymorphism were de-
ferred to the late in weekly lectures. The group-1 stude-
nts benefited BlueJ’s visual support for OO design and
the support for interaction with objects in the last weeks
(8 - 13 weeks).
When teaching programming with the objects-first
method, the classes and objects were introduced without
going into the further details of Java syntax rules. The
participants directly started by creating objects and exe-
cuting methods of the previously developed sample pro-
jects to conceptualize classes, objects and methods (Fig-
ure 2).
The participants were also expected to learn simple
forms of statements, control structures, method imple-
mentations and creation of source codes to define object
behaviors and to observe their states. Later, they experi-
enced editing, compiling and executing processes while
gaining an insight into Java programming. The presenta-
tion of the core OOP concepts, such as inheritance, poly-
morphism, coupling and cohesion concepts were intro-
duced to the group-2 students. Finally, the interaction of
multiple objects was presented to these students when
invoking each other’s methods (Table 3).
3.4. Data Analysis
The pre-tests and the post-tests were given to determine
whether the OOP knowledge and skills were acquired.
Before starting to this study, the experienced OOP in-
structors evaluated these tests for the content and face
validity. The students were required to give the correct
descriptions of OOP concepts and to write a complete
Java application during the achievement tests. This was

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners
820
Figure 2. BlueJ interfaces used by objects-first learners.
for the intention of measuring their understanding and
OOP skills of students whether they met the learning out-
comes. The participants were graded based on the con-
cepts they correctly defined and the Java applications
that they developed. We carried out the statistical analy-
sis with the SPSS v.16 software.
3.5. Findings
Table 4 presents the descriptive statistical data of the
study.
The null hypothesis stated that no sign ificant statistical
difference would exist between the test scores of students
in two different groups. Howeve r, as it is seen in Tabl e 5,
there is a statistically significant difference between these
experimental groups and we reject the null hypothesis
(z = –2.290, p < 0.05). It is possible to say that the learn-
ers instructed with objects-first method achieved higher
learning outcomes.
4. Discussion and Conclusions
The objects-first instructional design emphasized the
design and discussion of the OO concepts from the very
beginning while the objects-late deferred these concepts
to the late lectures. The comp lex notion s of OOP, such as
the inheritance, class & object, data & behavior and the
relationships among the concepts were presented with the
visual interfaces of BlueJ. As having different forms of
visualization, the representations of OOP concepts possi-
bly helped participants learn and retain the knowledge in
the long-term memory. The learners were easily able to
derive more semantic knowledge from visual displays
than text-based representations. We observed that com-
prehensible visual representations in the lectures directed
the learners’ attention to the relevant information rather
than confusing programming details. Thus, this method
guided the learners of group-2 while they were identify-
ing the perceptual cues associated with the OOP concepts.
The objects-first method had a dual nature that depicted
OOP concepts while at the same time relyin g on the fun-
damental instructional abstractions. The concrete elements
of Java programming were expressed with these general
and abstract terms, which enabled learners to move away
from a conventional environment to a pictorial and functional

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners 821
Table 4. The descriptive data of the participants.
Pre-test Post-test
Learner
No. Group No. Concepts
60% Program 40% Total 100% Concepts 60% Program 40% Total 100%
1 2 23 8 31 53 27 80
2 2 53 26 69 55 39 94
3 2 29 20 49 41 30 71
4 1 43 19 62 43 33 76
5 1 41 11 52 53 38 91
6 2 38 16 54 49 34 83
7 1 31 13 44 47 30 77
8 2 45 15 60 50 40 90
9 2 49 25 74 52 40 92
10 1 43 19 62 50 40 90
11 1 41 4 45 45 33 78
12 1 53 30 83 56 31 87
13 2 58 25 73 50 30 80
14 1 50 15 65 60 30 90
15 1 44 26 70 55 40 95
16 2 55 20 75 54 39 93
17 2 45 10 55 53 40 93
18 1 32 28 60 40 37 87
19 2 49 11 60 60 30 90
20 1 32 20 52 49 25 74
Table 5. The Mann-Whitney test results of the academic
achievements.
Group n Mean
rank Sum of ranks z p
Group-1
(objects-late) 10 6.89 62.00
Group-2
(object-first) 10 12.80 128.00
–2.290 0.022
environment. This eased the application of basic pro-
gramming skills. Therefore, high achievements of the
learners in group-2 could be attributed to instructional ap-
propriateness of the objects-first method.
Initially allowing the group-2 students to interact with
objects and methods possibility formed the concrete un-
derstanding of the inner workings of OOP paradigm.
Therefore, objects-first strategy, which is supplemented
wi th visual interfaces, made the information apprehensible,
apparent and visible to the learners [19,20]. We observed
that the learners in group-2 could easily find, design or
interpret the relevant information pertaining to program-
ming tasks. Any visual software development environ-
ment should provide necessary abstractions. Therefore,
the objects-first strategy is thought have provided the
learners with appropriate conceptual models, and it en-
abled them to incorporate abstraction details with con-
crete programming facts and rules. This strategy also
reflected the state, behavior and existing attributes of an
entity that an object encapsulated. We observed that the
students in group-2 were easily able to explore the OOP
concepts and to carry out programming tasks in visual
and text-based environments, which also directly support-
ed the objects-first strategy.
During the stud y, the na ture of the obj ects-fir st method
supported visual design of programs while maintaining
access to the text editor. This gave different perspectives
to the learners of group-2. Software development requires
fundamental skills i.e. analysis, design and coding. In
terms visualization, different tasks would require differ-
ent types of representations suited for the learners’ pref-
erences. While visual environments could be suitable for
the analysis and design tasks of software development
phases, text-based environments would be more appeal-
ing to traditional programmers. The learners in group-2
felt comfortable in this two-dimensional visual environ-
ment through out programming. Therefore, the two-mode
of objects-first method (visual and text) enabled the func-
tionalities that the learners needed. As a result, learners
were able to switch among representations while course
topics were presented with the objects-first strategies.
The learners in group-2 found objects-first method enjo y-
able since it allowed more freedo m and layout opportuni-
ties in terms of instructional activities. Fro m experienced
to novice ones, the majority of the programmers find a
number of advantages of graphical representations over
the text-based ones. While the overview of programming
context is provided, software structures are made more
visible and clearer in objects-first environments. We k no w
that these environments have a higher level of abstrac-
tions, they are easier and faster to understand, and they
provide closer mapping of programming domain. In our
study, the objects-first strategy helped the learners un-
derstand what the class or object mean and grasp the re-
lated OOP concepts. It is possible to say that the ob-
jects-first instructional method, which was rich in visu-
alization and instructional activities, played an important
role in high-level achievements of learners in group-2.
Learning OOP is a difficult task, especially for the be-
ginners. It requires internalization of OOP paradigm and
adapting the basic skills to the programming tasks. We
believe that, interacting with objects from the beginning
helped the learners build their concrete understanding
and it provided appropriate conceptual models. The ob-
jects-first learners could easily put a mental emphasis on
the concepts of class and object relationships instead of
concentrating on structural programming facts. We are of
the opinion that the debates on the OOP teaching meth-
ods will continue in the fu ture. Therefore, our paper con-
cludes with an invitation of more studies on instructional
methods for OOP.

The Effects of Objects-First and Objects-Late Methods on Achievements of OOP Learners
822
REFERENCES
[1] M. Ben-Ari, “Constructivism in Computer Science Edu-
cation,” Proceedings of the 29th Technical Symposium on
Computer Science Education, New York, 26 February-1
March 1998, pp. 257-261.
[2] A. E. Fleury, “Student Conceptions of Object-Oriented
Programming in Java,” The Journal of Computing in
Small Colleges, Vol. 15, No. 1, 1999, pp. 69-78.
[3] M. Kolling, “The Problem of Teaching Object-Oriented
Programming, Part 1: Languages,” Journal of Object-
Oriented Programming, Vol. 11, No. 8, 1999, pp. 8-15.
[4] A. Eckerdal, “Novice Students’ Learning of Object-Oriented
Programming,” Unpublished Doctoral Dissertation, The
Uppsala University, Uppsala, 2006.
[5] M. Kolling and J. Rosenberg, “Guidelines for Teaching
Object Orientation with Java,” Proceedings of the 6th
Annual Conference on Innovation and Technology in
Computer Science Education, Canterbury , 25-27 Ju ne 2001,
pp. 33-36.
[6] H. Zhu and M. Zhou, “Methodology First and Language
Second: A Way to Teach Object-Oriented Programming,”
OOPSLA 2003: Companion of the 18th Annual ACM
Conference on Object-Oriented Programming, Systems,
Languages, and Applications, New York, 26-30 October
2003, pp. 140-147.
[7] K. B. Bruce, “Controversy on How to Teach CS 1: A
Discussion on the SIGCSE-Members Mailing List,” In-
roads—The SIGCSE Bulletin, Vol. 37, No. 2, 2005, pp.
111-117.
[8] A. Ehlert and C. Schulte, “Empirical Comparison of Ob-
jects-First and Objects-Later,” Proceedings of the 5th In-
ternational Workshop on Computing Education Research
Workshop, Berkeley, 10-11 August 2009, pp. 15-26.
doi:10.1145/1584322.1584326
[9] R. B. Findler, C. Flanagan, M. Flatt, S. Krishnamurthi
and M. Felleisen, “Drscheme: A Pedagogic Programming
Environment for Scheme,” Programming Languages:
Implementations, Logics, and Programs, Vol. 12, No. 2,
2002, pp. 159-182. doi:10.1007/BFb0033856
[10] E. Allen, R. Cartwright and B. Stoler, “DrJava: A Light-
Weight Pedagogic Environment for Java,” Proceedings of
the 33rd Technical Symposium on Computer Science
Education, New York, 26 February-2 March 2002, pp.
137-141.
[11] S. Georgantaki and S. Retalis, “Using Educational Tools
for Teaching Object Oriented Design and Programming,”
Journal of Information Technology Impact, Vol. 7, No. 2,
2007, pp. 111-130.
[12] A. Patterson, M. Kölling, B. Quig and J. Rosenberg, “The
BlueJ System and Its Pedagogy,” Journal of Computer
Science Education, Vol. 13, No. 4, 2003, pp. 13-24.
[13] M. Kolling, “The Problem of Teaching Object-Oriented
Programming, Part 2: Environments,” Journal of Object-
Oriented Programming, Vol. 11, No. 9, 1999, pp. 6-12.
[14] D. Buck and D. J. Stucki, “JKarel Robot: A Case Study in
Supporting Levels of Cognitive Development in Com-
puter Science Curriculum,” ACM SICGSE Bulletin, Vol.
33, No. 1, 2000, pp. 16-20.
[15] S. Cooper, W. Dann and R. Paush, “Alice: A 3-D Tool
for Introductory Programming Concepts,” Journal of
Computing in Small Colleges, Vol. 15, No. 5, 2000, pp.
108-117.
[16] D. J. Barnes and M. Kölling, “Objects First with Java: A
Practical Introduction Using BlueJ,” 2nd Edition, Prentice
Hall, New Jersey, 2005.
[17] M. Torgersen, H. R. Kresten and K. Thorup, “A Concep-
tual Approach to Teaching Object-Orientation to C Pro-
grammers,” The Proceedings of Educators’ Symposium:
Conference on Object-Oriented Programming Systems,
Languages and Applications, Vancouver, 18-22 October
1998, pp. 3-10.
[18] J. Bennedsen and M. Caspersen, “Programming in Con-
text: A Model-First Approach to CS1,” Proceedings of
the 35th SIGCSE Technical Symposium on Computer Sci-
ence Education, Norfolk, 3-7 March 2004, pp. 477-481.
[19] S. Xinogalos, “Guidelines for Designing and Teaching an
Effective Object-Oriented Design and Programming C our se,”
Advance Learning, 2010, pp. 397-422.
[20] M. Petre, “Mental Imagery and Software Visualization in
High-Performance Software Development Teams,” Jour-
nal of Visual Languages and Computing, Vol. 21, No. 3,
2010, pp. 171-183. doi:10.1016/j.jvlc.2009.11.001