Content uploaded by Grégory Bourguin
Author content
All content in this area was uploaded by Grégory Bourguin on Feb 22, 2016
Content may be subject to copyright.
EEE'09
Creating a Global Integrated Environment
to support Software Engineering Teaching
Grégory Bourguin1, Arnaud Lewandowski1, Bénédicte Talon1, Dominique Leclet2
1LIL, Université Lille Nord de France
Maison de la Recherche Blaise Pascal - BP 719 - 62228 CALAIS CEDEX, France
{Gregory.Bourguin, Arnaud.Lewandowski, Benedicte.Talon}@lil.univ-littoral.fr
2UPJV-MIS, 33 rue St Leu 80039 AMIENS CEDEX 1, France
Dominique.Leclet@u-picardie.fr
Keywords : e-learning, integration platform, software engineering, project-based pedagogy, collaboration.
Introduction
Despite of the many effort realized in the recent years, literature shows that there is still a strong issue in creating
tools that better support Software Engineering Teaching (SET). Researchers have demonstrated that learning in
general is better realized when involving cooperative activities [11]. Moreover, it has been shown that learning is
more efficient when realized in conditions that are similar to real activities, thus involving organizational
schemes and tools similar to those that can be found in real situations [3].
Then, the distributed and cooperative dimensions appear to be even more important in learning software
engineering since today software development activities are intrinsically distributed and cooperative [7]:
software is realized by teams that are distributed in time and space while involving actors with eventually
different backgrounds, skills and methodologies. This particular organizational scheme is certainly one of the
main reasons why particular approaches like pedagogy by projects have gained a wide audience across software
engineering teachers. Teaching software engineering with a project pedagogy favors learning by involving real
life conditions because learners will have to work cooperatively and in a distributed fashion, ie. together or at
distance, synchronously and asynchronously. According to this assumption, we have been working on a new
pedagogical method named MAETIC [19] which is designed to organize a cooperative project-based pedagogy.
For these reasons, we strongly believe that e-learning tools and particularly Computer Supported Cooperative
Learning (CSCL) platforms are very promising for teaching software engineering.
However, if software engineering teaching is intrinsically distributed and cooperative and may be organized
around a cooperative project-based pedagogy, we have to remember that software development is realized with
hardly specific and widely used tools like IDEs (Integrated Development Environments). Thus, from our point of
view and as underlined by [12], an adequate environment for SET should not miss to integrate this specificity.
Considering these two important dimensions, it is still hard to find an adequate platform that supports this
activity [12][3].
In the next part of the paper, we will explore how to support SET while considering existing e-learning and
cooperative software development tools and platforms. We will then present our approach in creating a generic
cooperative software development environment named CooLDA and realized as an extension of the widely used
Eclipse IDE. This will lead us to propose an adaptation of CooLDA designed to support scenarios following the
MAETIC project-based pedagogical method, thus proposing a new platform for SET.
Tools and issues to support SET
As underlined before, a good platform for Software Engineering Teaching (SET) should both support the
properties of project-based teaching and Collaborative Software Engineering (CSE). For a long time, researchers
have also shown that CSCW environments, like CSCL and CSE platforms should propose global and integrated
environments taking care of the wider context that is critical for successful collaboration, thus avoiding
unwanted context switching while supporting many different dimensions of the work like team management,
artifacts production and sharing, individual and collaborative work, synchronous and asynchronous
collaboration, awareness, adaptability, etc. The first idea is then to determine how existing e-learning and CSE
tools can support this particular type of activities.
The most used and popular tools for e-learning are Web-based Course Management Systems (CMS) like
Moodle1, Blackboard2 or WebCT. As underlined by Helmick [12], these tools “fulfill the needs of the larger
academic community, but do not address the needs of the computer science curriculum”. The author thus
proposes to fulfill these needs while proposing a new Web-based integrated courseware system for the
management of computer science courses named CSCW (Computer Science CourseWare). This system is
1 http://moodle.org/
2 http://www.blackboard.com/
EEE'09
interesting while organizing project-based pedagogy but students are invited to use IDEs like Eclipse outside
CSCW to perform the programming part of their work. The web has also been identified as an interesting
support for CSE and many tools like SourceForge3, GForge4 or Bugzilla5 have been designed in order to help
programmers performing their work. If it is possible to perform SET while using these tools, we have to notice
that the “teaching” part of the activity is managed outside these platforms. Moreover and as usual with Web-
based systems, even those like “Computer Science CourseWare” described above, all the dimensions (like
organizing and programming) are not completely integrated in a global environment.
However, if these environments do not integrate all the desired dimensions for SET, some efforts have been
realized to create tools focusing on some of them. Moreover, many of these tools can now be integrated in
widely used programming environments like Eclipse. Eclipse is well known to be a powerful programming
environment for programming, debugging or even testing source code in different languages. More focusing on
teaching computer science with Eclipse, we can cite plug-ins like Dr. Java [17], a lightweight development
environment for writing Java programs designed primarily for students. In the same idea, we can cite GILD
(including Dr. Java) [18], Penumbra [15] or even Eclipse IDE for Education6. Some researchers [3] have used
Together7 and MagicDraw8 plug-ins to facilitate UML design for novice users. Boden [2] has shown how
articulation work and informal communication is critical in collaborative work and that it can be well supported
by tools like chat or audio conference systems. Many chat and audio-conference plug-ins have nowadays been
created. Wiki Eclipse plug-ins can also support asynchronous collaborative work. OpenOffice plug-in is now
available to support documentation inside Eclipse. Hartness [11] and Helmick [12] have shown how existing
CVS plug-ins can reveal useful for supporting teaching (organizing, evaluating students) with group projects.
Considering work organization, plug-ins like E-CARGO [21] can help in supporting the Role Based
Collaboration (RBC) paradigm. BugZilla now proposes a plug-in allowing to perform bug tracking inside
Eclipse.
This non-exhaustive and ever growing list of tools that have proven useful in supporting some dimension of SET
let us believe that an IDE like Eclipse may reveal as being the best platform to support it. However, and as
underlined by Tomek [20] and Bouillon [3], if these many plug-ins provide good solutions to single problems,
there is a strong lack of plug-in compatibility. In other words, these plug-ins can be integrated inside Eclipse at
the interface level, but are not aware of each other, thus leading to a poor global integration of tools in the
environment.
Facing this issue, some researchers have started to propose new solutions particularly in trying to provide
support for CSE with Eclipse. Jazz [6] is one of the most famous solutions trying to better integrate awareness
and synchronous communication plug-ins fulfilling the collaboration needs of developer teams into the Eclipse
Java Plug-in. From our point of view, Jazz is a very interesting project but it mainly focuses on synchronous
CSE and does not provide a framework that can intuitively support the teaching dimension of SET. Another
point is that Jazz plug-ins are built to work together thus, in this approach, fine integration between plug-ins is
mainly reserved to the core Eclipse plug-ins and those delivered with jazz. Considering the above mentioned
open list of tools that may be useful for SET, we would prefer not to transform the Eclipse core, but just to
augment it in order to finely integrate any plug-in found over the Web. We can also cite ECF (Eclipse
Communication Framework) and CAISE [7], respectively an Eclipse framework and an architecture for
supporting the development of collaborative plug-ins. If finely integrable collaborative plug-ins have been
created with ECF and CAISE, like Jazz, they do not address the fine integration of existing plug-ins.
The approach that is closer to ours and that we found in the literature is proposed by Bouillon [3] that tries to use
Eclipse in distant Teaching of Software Engineering. The author identifies different existing tools for creating a
SET platform supporting project-based pedagogy. He proposes to “incorporate existing tools into Eclipse and
provide some gluing-code which allows for the plug-ins to work together”. The solution is mainly founded on
the CURE (Collaborative Universal Remote Education) environment. CURE was first a Web-based environment
and the authors developed an Eclipse plug-in view allowing to map the CURE framework based on the room
metaphor over the Eclipse environment.
Our own proposition for fulfilling the above-mentioned issues is named CooLDA (Cooperative Layer supporting
Distributed Activities). Trying to provide a gluing environment to integrate and orchestrate existing tools,
CooLDA develops an approach similar to Bouillon’s solution with CURE. However, it is also radically different
since the environment does not follow the room metaphor but is directly built upon a framework introducing a
generic activity model inspired from the Activity Theory [1]. The following of the paper will present this generic
model and environment, and how we adapted it to fulfill the MAETIC project-based pedagogical method needs
for creating a new SET platform.
3 http://sourceforge.net/
4 http://gforge.org/
5 http://www.bugzilla.org/
6 http://www.eclipse.org/proposals/ide4edu/
7 http://www.borland.com/us/products/together/
8 http://www.nomagic.com/
EEE'09
The CooLDA Platform
CooLDA has been designed as a platform to support Collaborative Software Engineering (SE). We have been
working for many years in the CSCW research domain and we are aware of its main issues like tool acceptance,
strong need for tailorability. Thus, our main idea was not to create a new platform from scratch, but to augment
an already existing and widely used one. Eclipse has been recognized for long as a strongly tailorable IDE
widely used by the developers. Trying to support SD and due to its intrinsic properties, we chose to augment
Eclipse for creating the client part of our CSE environment.
As stated before, a major choice in our reasoning is to consider that many plug-ins already exist, which are
useful in supporting some activities we are interested in. Thus, our main goal is not to create such plug-ins, but
we want to create an environment that finely integrates them. From our point of view, mainly inspired from
Kutti’s work [13] with the Activity Theory [1] and detailed in [4], each tool/plug-in supports one kind of
activity. When several tools are used in parallel by a group of actors, they generally serve a more global activity
than the original activity they were designed for. For example, a group may use in parallel an IRC, a CVS, and a
code editor. Each of these tools supports a particular activity (synchronous discussion for the IRC, etc.) but they
do not know each other. However, they are used in a complementary way by the team since they are used in the
context of a global cooperative activity: software development. In such a case, the coherence of the environment
is mainly mentally managed by the users. Then, our purpose is to provide an environment that can create a
context for the use of the different tools involved in a global cooperative activity (e.g. a CSE activity), managing
the links between its different (sub-)activities. Assuming that each tool supports a specific activity, our
environment is intended to manage what we call the inter-activities.
To achieve this, we have created the CooLDA activity model Figure 1. In this model, each activity is linked to a
resource that proposes operations. A resource corresponds to a software tool (an IRC client for example). A user
is an actor in the activity, as he plays a role in it, role that allows him to do actions that triggers operations on the
resource. An activity can be linked to other ones, when the role of one of its actors implies that this user plays
another role in another activity. This role notion may seem similar to the role notion that can be found in Eclipse
with IBM RAD (Rational Application Developer 6.0) [8]. It is similar in the sense that playing a particular role
has an impact on the configuration of his environment and tools/plug-ins. However, we have to notice that RAD
roles are general purpose and only for configuring Eclipse in a coarse grained customization model [8]. These
are for example “Java Developer” or “Web Developer”. In CooLDA, roles are similar to those found in
traditional CSCW environments and, if they are involved in setting up the environment for their actors, they also
define their place in the group organization while specifying their rights and responsibilities. Finally, an activity
is an instance of a task, which constitutes an activity model, or pattern.
Figure 1. The CooLDA activity model
According to this model, each existing plug-in supports one activity. The architecture of the solution we propose
is presented in Figure 2. We propose to manage the inter-activities thanks to a meta plug-in named CooLDev,
whose role is to articulate the other plug-ins in the context of global cooperative activities. This meta plug-in is
connected to a CooLDA server. The Figure 3 presents an example of such a cooperative global environment for
SD that integrates the mechanisms we will describe now.
Because of our meta plug-in, the user has first to identify himself when he launches Eclipse, in the same way as
classical CSCW tools. Thanks to this, we can retrieve information from our CooLDA server concerning the role
of the user in the appropriate global activity. It allows the meta plug-in to configure the user’s working
environment, loading the Eclipse perspective associated to this role. Once the plug-ins that support the user’s
activities are instantiated by these perspectives, CooLDA executes actions (described in the activity model) that
have to be processed by a role when its user joins the activity. These actions configure the plug-ins for this user.
For example, when a user joins a code reviewing activity, in a development project, CooLDev uses the user’s
EEE'09
role to “instantiate” a CVS plug-in, an IRC plug-in, a code editor and an annotation tool. For the user to avoid
identifying another time in the IRC (he has already identified himself while connecting to our environment), we
have to indicate to this plug-in what is its configuration (pseudo, server, etc.). From our model’s point of view,
the user’s role realizes actions that trigger operations on the linked plug-in. Technically speaking, the operations
are mapped on methods provided by the plug-in and discovered using java introspection mechanisms, thus
without modifying the plug-in.
Figure 2. CooLDev’s architecture
Figure 3. CooLDA for a particular actor
CooLDA was firstly designed to support CSE, as Eclipse was firstly designed to support software development.
However, Eclipse has been built to be as open and extensible as possible. It has resulted in a generic framework
that is mostly used for creating IDEs, but its architecture is so open that it can be used to support many other
activities that are different from “basic” software development. In the previous part, we have shown that many
plug-ins already exist and that they may help in supporting SET activities. In a similar approach, we designed
CooLDA for CSE, but our inspiration comes from Activity Theory that studies human activity in a generic
fashion. The CooLDA activity model and framework are generic in the sense that they have been created to
support many different human activities. CSE is a human activity that can be supported in CooLDA with
Eclipse. SET is a human activity too. Understanding the issues we presented before in creating SET platforms,
and thanks to the generic properties of our approach, we decided to create a CooLDA instance supporting the
MAETIC project-based pedagogical method, thus providing a new global and integrated SET environment.
Tailoring CooLDA with MAETIC to support a SET scenario
MAETIC [19] is a pedagogical method which organizes a project-based pedagogy. MAETIC is independent of
the learning domain and has been built to develop and acquire professional skills. In the project-based approach,
the learner builds its knowledge and know-how thanks to the project [9]. MAETIC describes activities managed
by a group of students and directed towards a concrete production. The teacher activities consist to animate, not
to decide.
We have produced a guide and five technical booklets. These documents offer to students practical information
to manage their project according to the method. The guide presents the project cycle. This latter rests on 5
phases that correspond to traditional activities of project management: initialization, preparation, planning,
monitoring and recipe. During each activity, students have to realize sub-activities and to produce deliverables.
The five technical booklets bring accurate information on the working techniques and propose several document
models. Students are responsible for distributing the roles, planning the tasks, organizing the internal and
external communication of the project, producing the deliverables according to a planning, etc.
Although it is possible to practice MAETIC without Communication and Information Technologies (CIT), we
know by experience that CIT may bring students many advantages [10]: they may propose facilities allowing
people to work at distance, to distribute and to share documentation, to communicate easily. CIT also present
many advantages for the teacher such as centralized and at distance control, communication with students,
regular follow-up, and so on. The CooLDA environment has the abilities to bring an answer to the
implementation needs of MAETIC: an activity-centered model, a collaborative environment integrating useful
tools that can be adapted to the needs of the users.
The Software Testing Learning Scenario
Software testing is an essential discipline in curricula intended to Computer Science (CS) specialists. Indeed, the
management of defective software is one of the major and most expensive activities undertaken by companies. It
CVS
Editor
Annotation
Shared
Perspectives
IRC
CoolDev
EEE'09
is thus a significant challenge for them and consequently for the universities that have to educate the future CS
professionals. However, software testing is a hard discipline to teach. It acts in a world where systems
unceasingly evolve, it calls for various competences and requires a good comprehension of various problems.
In charge of the Software Engineering unit in a 2 years technical degree, one of the authors had to deal with the
challenge of teaching software testing. She began with a traditional teaching technique, presenting concepts and
techniques in lectures and assessing them during exam sessions. Noting that the students did not develop the
necessary competences and were hardly sensitized to the problems of tests, she integrated practical exercises
consisting in testing software using pre-established evaluation grids. These exercises had the advantages for
students to understand test classification, to learn some testing techniques and to understand their aim. However,
these exercises were far from preparing them well with industrial reality. In fact, they would be confronted with
software of bigger scale, group working and project management necessities. Consequently, the students didn’t
efficiently use these techniques when they were in companies. It was essential to put the students in situations
close to reality. These situations had to make them meet the requirements of test during the software production.
Moreover, they had to show them the interest of a good organization in order to ensure the success of the tests.
Thus, it seemed interesting to use MAETIC.
The scenario was conceived in order to respect the various steps of MAETIC, while taking into account the
teaching constraints (8 meetings with one meeting per week) and the targeted competences (practice of various
testing techniques, use and realization of documentation related to the test, organization of the team work). One
significant task was to propose a realistic planning of the work asked to the students.
During the sessions, the teacher does not give lecture. The courses are made available through the platform in a
specific shared folder. A scenario indicates to the students what to read and when. The Teacher’s public logbook
recalls which activities to carry out each week. It also explains which resources must be used or produced.
Models of document are also prepared and given through the platform in order to assist students.
As underlined by Myers [16], one major rule of software testing is that a tester must test programs written by
others. With respect to this rule, the program sources to be tested by our students are programs written in C by
others former students. Students are thus confronted with realistic code, with common errors and bugs. Along
with the source code, software requirements and functional specifications are provided. They allow students to
understand precisely the software specifications and to build a correct test plan.
Evaluation sheets are also provided. These models facilitate the testing process and assist students in reporting
the discovered errors. Students have to produce and deliver test reports, including these test sheets. The reports
are placed on a centralized repository. The teacher can easily access them later thanks to the platform.
Preparing COOLDA for SET in Software Testing Activities
While preparing the environment, the major part of the work consisted in mapping the MAETIC method
organized for software testing on the CooLDA’s activity model (Figure 1). Actually, this has been done by
representing the MAETIC method by five inter-connected activity models (also called tasks) corresponding to
the five steps of the method. Each activity model describes a particular step of the process. In order to be as less
constraining as possible, the five steps have been modeled as being sub-tasks of a main (teaching) task. Inside
this main task, we have identified two roles, namely ‘teacher’ and ‘student’. Playing one of these roles in the
main task may imply another particular role in the sub-tasks (each step of the method). In this kind of platform,
designed to propose integrated tools, the user chooses the activity he wants to join (among the five activities of
the method).
According to MAETIC, we have identified plug-ins that could suit the needs of the activities bound to each
phase of the method. For instance, we choose Office Integration Editor plug-in that integrates OpenOffice.org
tools in Eclipse. We also choose to use Eclipse's integrated CVS client, in order to offer document sharing and
versioning functionalities, along with Eclipse’s CDT (C/C++ Development Tooling), a set of plug-ins dedicated
to the development and test of C/C++ programs. We also used Eclipse’s integrated web browser, and integrated
a chat plug-in allowing users to discuss synchronously. Other tools fostering collaboration were provided by
CooLDev itself (awareness view, perspectives sharing facility, etc.).
These plug-ins have then been inscribed in the different activity models (that correspond to the five MAETIC
steps). The contextualization of a plug-in is realized through the creation of a particular sub-activity (describing
the use of this plug-in) in each MAETIC step it is involved in. Indeed, an activity model actually describes the
use of one plug-in that is mapped by a Resource. In order to finely integrate these plug-ins, we have identified
(using dynamic introspection) the methods that could be use for their integration and piloting. These methods
have been wrapped into operations in the activity models. Finally, specific actions have been defined for each
role, in order to determine how these tools should be configured and piloted. This fine-grained modeling is the
key for being able to create a highly configurable environment able to manage the links of the inter-activities
[14]. A specific test activity has been added. When a student joins this activity, the CooLDA server changes the
user perspective and loads a C/C++ perspective (provided by the CDT) allowing student to execute tests on the
given programs.
EEE'09
The Prototype
When a student connects to the environment and chooses, for example, to join the ‘planning’ activity (Figure 4)
in a particular project, CooLDA automatically retrieves the last versions of the shared documents that are
managed through the CVS, it pilots the Open Office Integration Editor plug-in in order to open the right
document(s), and connects the Chat plug-in to the right server and channel, with the appropriate user name. This
is possible thanks to activity modeling: CooLDA reads the activity model for the ‘planning’ step and its sub-
activities models (one model per integrated plug-in, as explained before), and executes the many start actions
tied to the role of the user in this specific activity. All of this is totally transparent for the user.
Figure 4. Screenshot of a planning Activity
Figure 4 presents a screenshot of a particular perspective for a particular user in the environment. We can
identify several tools: a Teacher’s logbook (first tab labeled “Journal de bord”) automatically opened showing
the last information on the learning unit as asked by MAETIC method, a Group’s logbook as asked by MAETIC
method (second tab labeled “Journal de bord”), a chat in order to communicate with other members of the group
or with the teacher, a project explorer to share different kinds of documents (MAETIC deliverables, project
deliverables, learning unit lectures, software testing documents, C programs sources) etc. Joining an activity in
the activity manager starts the activation of the plug-ins involved in this activity (in the example above, the
spreadsheet is launched for the planning in Open Office). As another example, joining the testing activity would
load the C/C++ perspective allowing the students to execute the main program and analyze the different sources.
The environment is completely integrated. Students don’t need to shift from an environment to another. They
can manage their project, consult the teacher’s logbook, manage their own logbook, discuss, realize reports and
execute tests in the same global environment, according to the (sub-) activity they are performing.
Conclusion
In this paper, we have shown that, despite of the many existing tools and platforms, there is still a strong issue in
creating global and integrated environments that better support Software Engineering Teaching (SET). Our
proposition demonstrates how it is nowadays possible to create such a promising environment while finely
integrating and contextualizing existing tools. For this purpose, we have presented the CooLDA platform that
provides generic activity model and framework, and a client part realized as an extension of the Eclipse IDE.
CooLDA was first designed to support Collaborative Software Engineering (CSE), but its generic properties
associated to Eclipse’s tailorability and the many existing plug-ins helped us to propose an environment for
supporting SET, and particularly teaching software testing, while following the MAETIC project-based
pedagogical method.
It is clear that this environment still has to be deeply evaluated in real situations with end-users. The prototype
we just presented has been used in an experiment according to a protocol consisting of observations during
sessions, collection of the students’ slides realized at the conclusion of their project, collection of “posts” on the
student logbooks and collection of tracks collected on the server. The target population was a promotion of 61
students in first years of 2 years technical degree, distributed in 10 groups of 5 to 7 students. The platform was
installed on each computer of the classroom. A downloadable version was also proposed to the students to allow
them to install the working environment on their own computer or laptop. It is too early to be able to have
complete conclusions resulting from a deep analysis of these data, but the first results are almost promising.
Students seemed to appreciate the project and collaborative environment because they had the feeling they
EEE'09
helped them to learn and understand the test preoccupation. The teacher strongly appreciated the environment:
the availability of documents and logbooks integrated into the same environment offered her an easier follow-up
of the groups’ activities, and consequently, an easier control and assessment.
Finally, we have to underline a main issue that still has to be addressed. In our approach, existing plug-ins can be
finely integrated without modification. The activity supported by a plug-in, like synchronous discussion for an
IRC, can be contextualized in a more global activity like teaching software testing. This is done by dynamically
discovering and calling the methods allowing to pilot this plug-in. As plug-ins are typically software components
thus designed to be integrated in a global environment, this approach seems natural. However, we have to notice
that most of the existing plug-ins propose methods enabling their technical integration in the Eclipse framework,
but poor effort is usually done by plug-ins developers to help their integration at a higher abstraction level. In
other words, the integration environment cannot call methods for automatically configure an IRC plug-in while
opening the right channel for a particular user in a particular activity if these methods do not exist. This issue
reveals even more important if we consider the strong need for tailorability required by CSE and SET
environments. For years, researchers have shown that such a platform should be able to be tailored during
activity while following the users emerging needs. Due to the lack of space, it is not possible to develop this
aspect in this paper but, in our approach that is detailed in [14], a part of the tailorability comes from the fact that
users may integrate and share themselves new existing plug-ins. This is nowadays technically possible, but it
will only be realized if plug-ins propose some open and high abstraction interfaces. We have started to work on
this issue in the context of CooLDA in [5]. A brief conclusion, as stated by Tomek [20] is that “further
development should be a coordinated community effort”.
References
[1] Bedny G., Meister D., The Russian theory of activity, Current Applications to Design and Learning, Lawrence Erlbaum Associates,
Publishers, 1997.
[2] Boden Alexander, Nett Bernhard, Wulf Volker, Articulation work in small-scale offshore software development projects, Proceedings
of the 2008 international workshop on Cooperative and human aspects of software engineering, p.21-24, May 13-13, 2008, Leipzig,
Germany
[3] Bouillon Philipp, Krinke Jens, Using Eclipse in distant teaching of software engineering, Proceedings of the 2004 OOPSLA workshop
on eclipse technology eXchange, p.22-26, October 24-24, 2004, Vancouver, British Columbia, Canada
[4] Bourguin G., Lewandowski A., “Inter-activities management for supporting cooperative software development”, Proceedings of the
Fourteenth International Conference on Information Systems Development (ISD'2005), Karlstad, Sweden, 15-17 August, 2005.
[5] Bourguin G., Lewandowski A., Tarby J.C. (2007), Defining Task Oriented Components, to appear in Proceedings of the 6th
International workshop on TAsk MOdels and DIAgrams TAMODIA’2007, November 7-9, 2007, Toulouse, France.
[6] Cheng L.-T., Hupfer S., Ross S., Patterson J., Jazzing up eclipse with collaborative tools. In Proceedings of the 2003 OOPSLA
Workshop on Eclipse Technology eXchange, pp 45–49, 2003.
[7] Cook Carl, Churcher Neville, Constructing real-time collaborative software engineering tools using CAISE, an architecture for
supporting tool development, Proceedings of the 29th Australasian Computer Science Conference, p.267-276, January 16-19, 2006,
Hobart, Australia
[8] Findlater, L., McGrenere, J., and Modjeska, D. (2008). Evaluation of a role-based approach for customizing a complex development
environment. Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (Florence, Italy, April 5 - 10, 2008).
CHI '08. ACM Press, 1267-1270.
[9] Gibson I. S., “Group Project Work in Engineering Design Learning Goals and their Assessment”, International Journal of Engineering
Education, 17 (3), 261-266, 2001.
[10] Graf S., List B., “An Evaluation of Open Source E-Learning Platforms Stressing Adaptation Issues”, ICA, Proceedings of the Fifth
IEEE International Conference on Advanced Learning Technologies (ICALT 2005), pp 163 – 165, 2005.
[11] Hartness, K. T. N., "Eclipse and CVS for group projects, Journal of Computing Sciences in Small Colleges, vol. 21, no.4, pp. 217-222,
2006.
[12] Helmick Michael T., "Integrated Online Courseware for Computer Science Courses," in The Proceedings of The 12th Annual
Conference on Innovation and Technology in Computer Science Education (ITiCSE 2007), Dundee, Scotland
[13] Kuutti K., “Notes on systems supporting ‘Organisational context’ – An activity theory viewpoint”, COMIC European project, D1.1,
1993, pp. 101-117.
[14] Lewandowski A., Bourguin G., “A New Framework for the Support of Software Development Cooperative Activities”, Proceedings of
the International Conference on Enterprise Information Systems (ICEIS'06), Paphos, Cyprus, May 24-27, 2006, ISBN: 972-8865-43-0,
pp. 36-43.
[15] Muellerand F., Hosking A. L., Penumbra: An eclipse plugin for introductory programming. In Proceedings of the 2003 OOPSLA
Workshop on Eclipse Technology eXchange, pp. 65–68, 2003.
[16] Myers G. J., The art of Software Testing, 2nd Edition, John Wiley & Sons Inc., Hoboken, New Jersey. Revised and Updated by T.
Badgett and T. M.Thomas with C. Sandler, ISBN 0-471-46912-2, 2004.
[17] Reisand C., Cartwright R., A friendly face for eclipse. In Proceedings of the 2003 OOPSLA Workshop on Eclipse Technology
eXchange, pp. 25–29, 2003.
[18] Storey M.-A., Michaud J., Mindel M., Sanseverino M., Damian D., Myers D., German D., Hargreaves E., Improving the usability of
eclipse for novice programmers. In Proceedings of the 2003 OOPSLAWorkshop on Eclipse Technology eXchange, pp. 35–39, 2003
[19] Talon B., Leclet D., Quénu-Joiron C., “Learning Know-How through a Method using Technologies of Information and Communication
and Project-Based Learning : the MAETIC Project”, Proceedings of E-LEARN 2006, AACE/ Springer-Verlag, 13-17 october, 2006,
Hawaï, USA.
[20] Tomek Ivan, et al.: FCVW – Towards an Eclipse-based CSCW framework, workshop Eclipse as a Platform for CSCW Research,
CSCW conference, Chicago, November 6-10, 2004.
[21] Zhu Haibin, Verzijlenberg Bart, An Eclipse Plug-in for Role-Based Collaboration, Proceedings of CSCW '06, November 4-8, 2006,
Banff, Alberta, Canada
