text:
The Greenfoot Programming Environment
- Cecily Berry
- 3 years ago
- Views:
1 The Greenfoot Programming Environment MICHAEL KÖLLING University of Kent Greenfoot is an educational integrated development environment aimed at learning and teaching programming. It is aimed at a target audience of students from about 14 years old upwards, and is also suitable for college- and university-level education. Greenfoot combines graphical, interactive output with programming in Java, a standard, text-based object-oriented programming language. This article first describes Greenfoot and then goes on to discuss design goals and motivations, strengths and weaknesses of the system, and its relation to two environments with similar goals, Scratch and Alice. Categories and Subject Descriptors: K.3.2 [Computers and Education]: Computer and Information Science Education Computer science education General Terms: Design, Human Factors, Languages Additional Key Words and Phrases: Greenfoot, programming environment, programming education ACM Reference Format: Kölling, M The greenfoot programming environment. ACM Trans. Comput. Educ. 10, 4, Article 14 (November 2010), 21 pages. DOI = / INTRODUCTION Greenfoot is an integrated educational software development environment aimed at learning and teaching programming to young novices. The target user group starts at pupils from about 14 years of age, and also includes introductory university education. Figure 1 shows Greenfoot s main window, with a scenario Greenfoot s term for a project open in the environment. The main part of the window shows the Greenfoot world, the area where the program executes. The world is of variable, user-defined size, and holds the scenario s objects. On the right we see a class diagram that visualizes the classes used in this scenario and their inheritance relations. The two superclasses visible here (World and Actor) are part of the Greenfoot system and are always present. Author s address: M. Kölling, School of Computing, University of Kent, Canterbury, UK; Permission to make digital or hard copies part or all of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies show this notice on the first page or initial screen of a display along with the full citation. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, to republish, to post on servers, to redistribute to lists, or to use any component of this work in other works requires prior specific permission and/or a fee. Permission may be requested from Publications Dept., ACM, Inc., 2 Penn Plaza, Suite 701, New York, NY , USA, fax +1 (212) , or c 2010 ACM /2010/11-ART14 $10.00 DOI: /
2 14: 2 M. Kölling Fig. 1. The Greenfoot main window. Fig. 2. The Greenfoot editor. The subclasses (all others classes visible here) are part of this particular example and will vary with different scenarios. A scenario will always have at least one world subclass, representing the actual world (the rectangular execution area) used. It will also have one or more Actor subclasses. Actors are those objects that are present in the world and exhibit behavior to implement the scenario s objective. Below the world view are some execution controls that allow running or single-stepping the scenario. Double-clicking a class in the class diagram (or right-clicking to choose from a popup menu) opens a text editor, showing the class s source code (Figure 2). The language used to program is standard Java Greenfoot internally uses the standard Java compiler and the standard virtual machine (JVM) to ensure full conformance with current Java specifications. However, although the language is Java, the environment supports use of the language in simpler ways
3 The Greenfoot Programming Environment 14: 3 Fig. 3. a) Create object, b) Move to world, c) Place. than normally available. For example, no static main method needs to be written, and programming can start with simple, one-line methods. An example of this is given in Section 3 below. Once some code has been written for a class, the class can be compiled and objects can immediately be interactively created through a context menu on the class. There is no need to first complete a whole project, or even for all classes to compile. As soon as the world class and one of the classes representing an actor in the world compile, objects can be created and the behavior can be tested. There is no need to write test drivers or a main method. All actors in the world have a method called act (inherited from the Actor superclass). Clicking the Act button in the execution controls invokes this act method once on each actor in the world. Using the Run button causes the act method to be called repeatedly, until the user pauses execution again. This is how Greenfoot scenarios are executed. Programmers simply define the behavior of every actor in the act method, and Greenfoot ensures that each actor gets called to act appropriately. Thus, students can concentrate on programming logical behavior of the actors and do not need to write graphics code. Greenfoot does the graphical animation of the actors implicitly. 2. INTRODUCING CONCEPTS One of the goals of Greenfoot is a design that explicitly visualizes important concepts of object-oriented programming. While the source code editor has been mentioned in the previous section, students do not typically start by manipulating source code. A typical first exercise for students might involve presenting them with a scenario that has already been implemented and compiled. Students then start by creating objects, which is achieved by selecting the object s constructor from the class s menu. Once the object has been created, it can be placed into the world (Figure 3). When the object is in the world, a right-click shows all the object s public methods (all available actions it can perform) in a popup menu (Figure 4). Once a method has been selected, it executes and the effect is visible onscreen immediately. If the method expects parameters, a dialogue window pops up prompting users to enter the parameter values. Similarly, possible result values are displayed in a dialogue window.
4 14: 4 M. Kölling Fig. 4. An actor s context menu. Of course, multiple objects can be created from the same class. Users can create several actors (wombats, in our illustration) and place them into the world. Methods can be executed on each of them individually. The state of each actor can be examined by selecting the Inspect option from the actor s menu. This will open an object inspector window showing all internal instance variables and their values. This illustrates the independence of objects (all objects have different values) and their relation to their class (all objects of the same class have the same kinds of fields). Pedagogically, these kinds of interactions are extremely valuable. They allow teachers to introduce some of the most important and fundamental concepts of object orientation in an easily understandable manner. These concepts include the following. A program consists of a set of classes. From classes, we can create objects. Multiple objects can be created from one class. All objects of the same class offer the same methods and have the same fields. Each object holds its own values for its fields (each object has individual state). We communicate with objects by calling one of its methods. Methods may have parameters. They also may return values. Parameters and return values have types. All of these concepts are fundamental to understanding modern object-oriented programming, and they are traditionally very hard to teach. One reason for the difficulty in teaching them is that these concepts are very abstract. Greenfoot makes them concrete by creating tangible experiences, explicitly visualizing them and guiding users through interactions involving concrete manifestations
5 The Greenfoot Programming Environment 14: 5 of these concepts. Students learn from these experiences without the need for much explicit instruction. This enables the introduction of the fundamental concepts first, before the need to deal with syntax and source code. Students do not immediately get distracted from important concepts by having to worry about placement of semicolons and parentheses. Of course, fairly soon (typically in the second lesson) we do get students to manipulate source code, but when they do this, they do so in the context of a conceptual framework of object orientation: They know that what they are doing is modifying or specifying the behavior of an object (or more precisely: a class of objects). 3. CODE EXAMPLES Before discussing underlying design goals in more detail, we give a few short examples of typical Greenfoot source code to provide a feel for the level of complexity involved in writing Greenfoot scenarios. When creating new actor classes, each class is assigned an image to represent it in the world. The image can be chosen from a built-in image library, or it can be specified by the user from their own available images. Objects created from the class start with their class s image as their default image. Each actor in Greenfoot has three elements of state that are automatically visualized on screen: a position (specified in x,y-coordinates), a rotation, and an image. Each of these can be manipulated through method calls to create an animation effect. For example, the call: setrotation(90); rotates the object to 90 degrees. The method: getrotation() is an accessor method that returns the current rotation (in degrees, 0-359). Thus, we can quite easily make the actor rotate around its axis by writing the following code: setrotation( getrotation()+2 ); This code segment reads the current rotation, adds a little bit to it, and sets the result as the new rotation. When this statement is added to the body of the act method, executing the scenario will cause it to be repeatedly called, resulting in continuous rotation of the actor. When creating new actors, a simple but complete class template is automatically provided. This forms the starting point for students work. It looks as follows: import greenfoot.*; /** * Write a description of class MyActor here.
6 14: 6 M. Kölling * (your name) (a version number or a date) */ public class MyActor extends Actor { /** * Act - do whatever the actor wants to do. */ public void act() { // Add your action code here. } } Providing this template follows a philosophy we first formulated during the design of the BlueJ environment [Kölling et al. 2003]: never start with a blank screen. Starting from a blank screen requires design, and is an advanced exercise. It is something students encounter later, but not as the first contact. Students start their work by adding code to the method body of the act method. Adding the one line of code shown above, placing an actor into the world and clicking the Run button, results in an actor that rotates around its center point. Similar effects can be achieved by changing the location. For example, the statement setlocation( getx()+2, gety() ); has the effect of moving the actor across the screen from left to right. Naturally, statements can be combined. The combination: setrotation( getrotation()+2 ); setlocation( getx()+2, gety() ); combines movement and rotation, and results in an actor that rolls over the screen. Thus, students can create visible animated behavior with just one or two lines of code. The Greenfoot API provides methods that make common tasks in programming simple graphical animations and games relatively easy. Following is an example to handle collision detection: a = getoneintersectingobject(car.class); This call will check whether the current actor intersects with another actor of class Car and return the intersecting object if there is one (returning null otherwise). The Greenfoot API is defined in a total of five classes with a relatively modest number of methods. The complete API documentation can be printed on
7 The Greenfoot Programming Environment 14: 7 two pages of standard letter size paper; it is also available from within the Greenfoot environment. Students typically learn quickly to read this documentation and work with it for their projects. 4. DESIGN GOALS A number of important design goals underpin the interaction design of Greenfoot. At the highest level, they can be summarized in two points, from two different perspectives: (1) From the student s perspective, the goal is to make programming engaging, creative and satisfying. (2) From the teacher s perspective, the goal is for the environment to actively help in teaching important, universal programming concepts. When we investigate these design objectives further, each results in a number of more detailed goals that support and enable the top level aims. The first goal, engagement of students, leads to the following sub-goals. 1.1 Ease of use. The system must be easy to use. It must allow students to achieve their goal without them getting stuck in unnecessary, mundane administrative tasks. 1.2 Discoverability. The system must be discoverable. Learners must be able to find out about functionality needed to achieve their goal. 1.3 Support engaging functionality. The system must allow to implement engaging, attractive functionality. This is possible in different ways, but certainly must include the easy use of graphics, animation and sound. 1.4 Flexibility. Since the judgement of what students might find engaging and exciting varies with age and with individual interest, the system must be flexible enough to support a wide variety of possible scenarios. 1.5 Quick feedback loop. The system must allow for quick and frequent success experiences. This means that it must support development in small steps with frequent opportunities at execution, observation, and visual feedback. 1.6 Availability. The system must be easily available (including cost) on a wide range of commonly used systems, on average hardware. Only then can learners play at home an essential part of creative, explorative learning. 1.7 Social interaction/sharing. The system must support sharing and communication between learners. Social interaction is a strong driver for engaging in creativity. 1.8 Extendibility. It would be an advantage if the system can be designed to be extendable, so that it can connect to reasonable existing interests and systems. This may be use of existing hardware (such as standard game controllers) or software (such as connecting to servers on the internet, databases, or other functionality of interest).
8 14: 8 M. Kölling The second high-level goal supporting the teaching leads to the following more specific requirements. 2.1 Visualization. Important concepts of the programming paradigm (in our case: object orientation) should be directly visualized. 2.2 Interaction. Interactions in the environment should illustrate programming concepts (e.g., instantiation, method calls). 2.3 Consistent mental model. All representation of principles in the environment must correctly reflect the underlying programming model. This allows students to draw conclusions from experimentation and observation, and to arrive at correct interpretations. 2.4 Concepts before syntax. Syntax should not be the very first hurdle that students have to cross to achieve their first success. 2.5 Avoid cognitive overload. Interaction in many modern development systems is at a level of complexity that makes learning difficult for beginners. Cognitive load theory tells us that the capacity for mental processing is limited [Miller 1956], and the number of simultaneous cognitive challenges strongly influences the ability to learn. To keep cognitive load at a manageable level, all extraneous complexity (this is: complexity not intrinsic to the task at the focus of the learning) should be avoided, all peripheral tasks automated and hidden. 2.6 Support for teachers. Teachers at secondary schools often do not have much time for the development of material or for off-site professional development and training. Thus, we need infrastructure to support the system that provides explicit support for teachers, such as discussion and sharing of teaching material. These design goals have strongly influenced the interface and interaction design of Greenfoot. Below, we discuss selected characteristics of Greenfoot s functionality that result from our attempt at reaching those goals. 5. EASE OF USE When thinking about ease of use, the most important considerations are not about the design of the elements of functionality that are included, but about what to leave out. Ease of use can only be achieved by restricting the scope of functionality, and design decisions in the ongoing tension between flexibility and simplicity have the highest impact. Greenfoot, even though it makes use of a standard programming language, excludes many tools commonly found in more generic IDEs, such as version control, unit testing, refactoring, etc. The goal is that learners become familiar with the complete user interface within a few days. Another area of leaving things out is in the design of the APIs. Greenfoot attempts to strike a balance between flexibility giving users enough power to implement interesting functionality and simplicity restricting the number of methods in the API to an easily learnable set.
9 The Greenfoot Programming Environment 14: 9 Fig. 5. An asteroids game. 6. FLEXIBILITY At first glance, and looking only at one or two initial examples, Greenfoot appears to be a traditional micro-world (in the tradition of Turtle Graphics [Lukas 1972; Caspersen and Christensen 2000], Karel the Robot [Pattis et al. 1994] or the AP Gridworld Case Study [CollegeBoard 2010], built into an integrated development environment with a tight edit/compile/execute cycle. However, it is much more flexible than that. Greenfoot can be seen as a micro-world meta framework that allows the quick and easy creation of specific micro-worlds. Existing systems, such as Turtle Graphics or Karel the Robot, can easily be implemented in Greenfoot, and Greenfoot goes much beyond the restrictions of those systems. Traditional systems integrate the programming functionality (move, turn, etc.) with a specific scenario (a turtle with a pen, for example, or a robot collecting beepers 1 ). As a result, if students start with robots and beepers, after some weeks of work they are still stuck with robots and beepers. If students get bored with this idea, or are not interested in robots in the first place, there is no easy way out for them. Greenfoot separates these two aspects: The available programmed functionality is separated from a specific scenario, allowing the implementation of a wide variety of examples. This supports the goals of engagement and flexibility (goals number 1.3 and 1.4 above). As a result, many substantially different scenarios can be created, covering many different topics. Examples include games (Figure 5), simulations (Figure 6 and Figure 7), music (Figure 8) and other visualizations (Figure 9). The opportunity to cover widely different contexts with the same framework has a number of advantages. Examples and context can be tailored to different age groups or different interests, either by a teacher or individually by students themselves. If a learner is most interested in games, they can start 1 Beepers are objects for robots to collect in the Karel the Robot micro-world.
10 14: 10 M. Kölling Fig. 6. A simulation of ants collecting food. by building a game. If another student looks for a more useful application of computing, they can work on simulations with an environmental theme, for example. More scientifically minded users can work with biological, physics or chemistry-inspired simulations, and teachers can easily adapt examples to their context. Some of the technical aspects that make this flexibility possible is a framework, embodied in the Greenfoot API, that does not specialize too strongly in a specific small subclass of simulation, and a world model with flexible resolution of the world cells. As a result, many programs that use two-dimensional, animated graphics as their main user interface can easily be implemented in Greenfoot. 7. COMPLEXITY OF DEVELOPMENT A typical method of using Greenfoot initially, with complete novices, is to provide students with a partially implemented scenario that they then modify. Student activities often start with executing and experimenting with the provided material, followed by implementing extensions of the existing functionality. We have argued above that scenarios can easily be adapted to match the interests of students. For this to work, it must be feasible for teachers to develop these teaching scenarios themselves. Teachers at secondary school level typically do not have much time for development of material, and sometimes lack specific expertise in technical details. Thus, the necessary complexity of wellmade, completed scenarios has a large influence on the feasibility of custom development of scenarios.
11 The Greenfoot Programming Environment 14: 11 Fig. 7. A lift simulation. Fig. 8. An on-screen piano. Creating interesting, good looking interactive animations and games in Greenfoot is relatively straightforward. A typical initial scenario, commonly used as a framework in the first few lessons, consists of about 40 to 70 lines of code. More complex and sophisticated completed scenarios typically consist of only a few hundred lines of code. For example, a full implementation of the Asteroids game (Figure 5) has about 620 lines of code, while a sophisticated ants simulation (Figure 6) consists of about 490 lines of code. This is a scale and level of complexity where many teachers are able to develop these scenarios themselves. Of course, not every teacher needs to develop new scenarios. The more common case for most teachers is that they browse through a pool of existing teaching scenarios and choose one that suits their needs. However, enough teachers are in a position to develop scenarios that
12 14: 12 M. Kölling Fig. 9. A weather map, with real data from the Internet. such a pool can be created and built up. What is necessary for this to work is a mechanism for sharing these scenarios among the teaching community. This is discussed further in Section 11, below. The development of prepared teaching scenarios is only necessary in the early stages of learning. After some time (depending on age, engagement, and talent, some days, weeks, or a small number of months) learners will be able to design and develop entire new scenarios from scratch without needing the scaffolding to get started. The initial starting scenarios are typically provided by a teacher if the learning takes place in a classroom. For self-directed study, teaching material is provided online, with references provided directly in the Greenfoot environment, so that learners can work independently. The material includes both educational scenarios and tutorials. This, too, is discussed further in Section TARGET AUDIENCE The target audience of users of Greenfoot includes pupils from about 14 years of age, and scales up into introductory university education. (Age, in this context, should be seen as a rough approximation. We have seen Greenfoot successfully used with classes of 13-year-olds what is needed is a level of literacy and maturity that individual children will naturally reach at varying stages in their development). While the output of Greenfoot scenarios is graphical, its programming interaction is textual. This imposes a higher hurdle of competence than that needed for Scratch [Maloney et al. 2008] or Alice [Dann et al. 2008]. Users of Greenfoot may be complete programming novices within that age group, or they may have prior programming experience in Scratch, Alice, or comparable systems. Concepts learned in Alice and Scratch transfer well into Greenfoot. Where concepts correspond, they are presented in a similar manner, supporting a similar mental model, while Greenfoot introduces some additional concepts that build on the material learned in those systems. This is discussed further in Section 15. The purpose of using Greenfoot with novices may be similar to that of using Scratch and Alice generating interest and enthusiasm in programming (and
13 The Greenfoot Programming Environment 14: 13 maybe computer science in general) and conveying fundamental programming principles but can also be more formal. Higher level software development concepts, such as good class design, separation of concerns, encapsulation and cohesion, coupling, and additional levels of abstraction can also be taught. 9. JAVAASALANGUAGE The programming language used in Greenfoot is standard Java. This has a strong effect on many of the characteristics of Greenfoot some of them beneficial, others imposing limitations and complexities. Firstly, the use of a textual language in general (as opposed to the Scratch/Alice model of drag-and-drop instruction blocks) is considerably harder for young learners to master. This imposes a minimum maturity level. While Scratch and Alice can be used with very young kids, Greenfoot does not usually work for pre-teens. This is mostly a result of the language, not the conceptual model of Greenfoot. Informal experiments with Greenfoot and 10-year-olds have shown that learners of that age can understand the underlying model and concepts quite easily, but struggle with the syntax of the Java programming language to a degree that they cannot progress on their own. The second aspect is the use of Java specifically. Other textual languages are available that are easier to master. Here, the main problems are not with the object-oriented nature of Java (as some teachers sometimes speculate), but with the choice of syntax. The concepts of object orientation seem to impose no conceptual problems even for learners at the lower boundary of our target age group. The mental model of independently acting and communicating objects, the concept of classes and even the idea of inheritance seem to pose no overly difficult challenge. The syntax of Java however, with its nested textual block structure coupled with poor error messages, presents a hard challenge for young novices. Using Java in Greenfoot is considerably easier than using Java in a standard professional environment (be it a text editor/command line environment or a standard professional IDE). Since actors can be created independently and interactively and methods called individually, no testing framework or main method is needed. This, coupled with the automatic provision of simple class templates, leads to the ability of starting by writing and executing single lines of code, with immediate visual feedback. This makes Java in Greenfoot suitable for the target age group, but the Java syntax still provides a problem for younger children. On the positive side, using a standard, industry strength programming language has a number of advantages. Firstly, Greenfoot scales well into older age groups. More sophisticated and technically demanding ideas can be implemented than is possible in systems with custom-made educational languages. Language constructs and libraries are available for advanced topics. Secondly, performance is good enough to develop and run fairly complex scenarios with hundreds of objects.
14 14: 14 M. Kölling Thirdly, a wealth of infrastructure is available for Java, including teaching material, textbooks, and technical development to port the virtual machine to new platforms, improve performance, and many other ongoing improvements. Greenfoot can tap into those, making many improvements to our platform easier than it would be if we had to develop these elements from scratch. Some of these benefits are discussed in more detail in the next section. 10. EXTENDABILITY AND PERFORMANCE The fact that Greenfoot uses Java, while presenting problems for young learners, has benefits at the older end of our target age group. In effect, there is no age limit at the upper end. Since Greenfoot supports the full Java language, including use of all libraries, very sophisticated scenarios can be created. And since execution is carried out on the standard Java VM a highly optimized professional platform performance is good for many cases. Scenarios such as the ants simulation, with several hundred objects on screen, each performing collision detection against hundreds of other objects, perform smoothly without problems on typically available medium range hardware. Educationally, this means that Greenfoot can easily be used in introductory university courses. All concepts that are commonly introduced there have a natural representation in Greenfoot. Greenfoot is also occasionally used in advanced university agent modelling and AI modules. In these cases, teachers are mostly interested in the ease of creating graphical animations of the agents behavior, while the actual implementation of each agent class may be highly complex. For motivation of learners, this means that they do not easily hit a brick wall where their ambition outstrips the capabilities of the programming system. With systems based on simpler educational languages and graphical code editing, especially older teenagers often reach a point where their ideas cannot easily be realized within that system. The problem might be in the expressiveness of the language or in performance. At that time, graduating to Greenfoot can give them a welcome path forward. The price we pay in the added complexity for early beginners pays off when students reach a level of competence and ambition to aim for more advanced and demanding projects. In addition to performance, the Java infrastructure also provides a wealth of specialized functionality through its standard libraries. More advanced users can connect to databases, use networked communication, build multi-user scenarios, communicate with mobile phones, and integrate any other functionality that is supported by a Java library. Lastly, the use of a standard language commonly used in programming education eases transfer out of the system into more general development environments. Since all educational IDEs are interim tools the goal is, after all, to motivate students to learn more, and move on to other systems transfer out of the system should not be neglected. While we often discuss the challenges of getting started in a system, moving out poses its own set of challenges.
15 The Greenfoot Programming Environment 14: 15 Ideally, concepts learned in an educational IDE carry over smoothly into future systems. The use of Java in Greenfoot makes this connection more direct and immediate. Progression to the BlueJ IDE [Kölling et al. 2003] is specifically well supported. BlueJ was designed by the same development team as Greenfoot, and consistency of representation of the same concepts in the two environments is an explicit design goal. Thus, transferring between the two, including parallel use in a course with frequent switches between them, is easily possible. We have used this approach in our own introductory programming course at university level with good success. Transfer to other IDEs using class-based, object-oriented languages is also fairly straightforward, as all concepts encountered in Greenfoot should easily transfer. As such, Greenfoot may provide an ideal stepping stone between Scratch or Alice on one hand, and more general IDEs on the other. 11. ECOSYSTEM Greenfoot is supported by the usual collection of material, including a Web site [Greenfoot 2010], tutorials [GF Tutorial 2010], and a full textbook [Kölling 2009]. In addition, two of the design objectives of Greenfoot were to provide social interaction and sharing for learners (listed as design goal 1.7 in Section 4) and support for teachers (goal 2.6). Both of these require infrastructure beyond the immediate development environment The Greenfoot Gallery For students, two paths of social interaction are available. The first is an online discussion forum, Greenfoot Discuss, provided as a group on the Google Groups platform. 2 Here, learners can ask for help, ask technical questions, and discuss ideas. The more interesting path is the Greenfoot Gallery [Gallery 2010]. This is a Web site where Greenfoot scenarios can be published, and other people can execute those scenarios and leave ratings and comments for them. Greenfoot scenarios run directly on the site within the Web browser. Scenarios can be published to the Greenfoot Gallery directly from within the Greenfoot environment with just a few mouse clicks. To publish scenarios, comment or rate them, users must create an account on the Greenfoot Gallery site. Simply playing the scenarios is possible without an account. The Gallery serves as a highly motivating element in the Greenfoot ecosystem, with frequent discussion threads attached to scenarios where other users provide feedback, report errors or suggest improvements [Fincher et al. 2010]. As a result, students in organized teaching courses often spend additional time after an assignment has finished improving and extending their projects. 2 Available at
16 14: 16 M. Kölling 11.2 The Greenroom The second Web-based system external to the Greenfoot environment itself but linked into its infrastructure is the Greenroom [Greenroom 2010]. The Greenroom is an online community site exclusively for teachers. It provides functionality for discussions, resource sharing, and news announcements. The Greenroom allows new teachers adopting Greenfoot to ask questions, get advice, and find teaching material. Existing resources include worksheets, test questions, assignment and project ideas, handouts, slides, teaching scenarios, written tutorials, and tutorial videos. The Greenroom has so far avoided the fate of many other resource repositories quickly waning interest after a short burst of initial use. It has proven highly popular, with more than 800 teachers subscribed, many active discussions, dozens of resources, and daily activity. 12. STRENGTHS For the purpose of comparison with Alice and Scratch, we discuss three of the main strengths of the Greenfoot system. (1) Good illustration of OO concepts. (2) Good scaling up (number of objects, performance). (3) Relatively simple start. We will discuss each of these in more detail Good Illustration of OO Concepts While students play with creating games or simulations, they are implicitly observing and interacting with many major concepts of object-oriented programming, as present in many modern OO programming languages. Concepts that are implicitly illustrated include the following. A program consists of a collection of classes. From classes, we can instantiate objects. One class can create many objects. Objects have separate state. We can communicate with objects via method calls. Methods may have parameters and return values. Several more. These are concepts that are traditionally hard to learn and teach. In Greenfoot, these become implicitly apparent without much verbal explanation, and they transfer well to other widely used programming languages which students may transfer to later.
17 The Greenfoot Programming Environment 14: Good Scaling Up (Number of Objects, Performance) Greenfoot scales well when students become more competent and want to create more sophisticated programs. The creation of many objects is not a problem, since programmatic instantiation is part of the language. Thus, games or simulations with many objects (traffic simulations, ant simulations, etc.) can be created easily. This enables the creation of scenarios that display true emergent behavior, which is highly motivating. The performance is good (scenarios with several hundreds of objects, all checking collisions between each other, run smoothly). Also, the user language is standard Java, and any Java library can be used in Greenfoot. This means that very sophisticated algorithms can be written (e.g., AI algorithms for actor behavior) and access to external technologies (databases, network access, external devices such as game controllers) can be implemented Relatively Simple Start In contexts other than comparing with Scratch and Alice, we claim that it is easy to get started in Greenfoot. Early examples are very easy to write and interesting results are quick to achieve. In comparison with most programming systems, especially producing animated graphics is very easy in Greenfoot. In comparison with Scratch and Alice, Greenfoot gets beaten by those systems in terms of ease of entry. However, in context of its design goals use of a standard programming language, ability to scale up to sophisticated programs in scope and performance it provides an extremely easy path of entry for young programmers. 13. LIMITATIONS As with all systems, there are also clear weaknesses and limitations situations where Greenfoot is not a good solution. They include: (1) Tinkering by younger kids. (2) Error handling and reporting. (3) 3D Tinkering by Younger Kids The use of Java as the user language brings with it an unavoidable minimum of complexity. Java is a text-based, syntax-oriented language that requires a certain level of conceptual and linguistic maturity to cope with its structure. Younger children often get caught in structural syntax errors (such as unmatched scope brackets) which they find hard to diagnose and fix. Exploration and tinkering which we highly value and encourage requires reading of textual documentation of APIs, which requires an ability and willingness to work with written documentation or sample programs. All of these impose a fairly hard minimum of required maturity, which many children reach around the age of 14.
18 14: 18 M. Kölling 13.2 Error Handling and Reporting Another side effect of using Java as the language is the comparatively poor quality of error messages. Firstly, syntax errors are common, as is the case in most text-based programming languages, and every programmer knows the deep feeling of frustration that occasionally sets in when struggling with errors over some period of time. Secondly, the messages used to report the errors are often not especially helpful, and interpreting the error messages is a skill that needs time to acquire. This occasionally wastes time in a non-productive state and has the potential to frustrate learners D Greenfoot is designed as a 2D system. All APIs are aimed towards supporting 2D animation. It is possible to create 3D scenarios, as several impressive projects submitted to the Greenfoot Gallery have demonstrated. However, doing so is hard work, and Greenfoot offers little specific support for making this easier than it is in standard Java. The existence of these projects in the Gallery, however, shows that there is an interest at least for some users to create those kinds of games. This is not well supported in Greenfoot. 14. EXPERIENCE Greenfoot has been used extensively at high school level, at colleges and in introductory university courses. Lengths of courses stretch from single-day outreach activities with novices (sometimes as short as two hour sessions) to full semester formal modules. A large amount of feedback and anecdotal data exists; however, no formal study of the effects of teaching Greenfoot has been carried out. Thus, firm conclusions are hard to draw. Some of the data that is available is interesting nonetheless and provides a basis for further work on the system. It may also form a possible basis for research questions for more formal studies of the effectiveness of Greenfoot in learning situations. Accurate user numbers are not collected for Greenfoot, but some lower boundaries can be established. The Greenroom has, at the time of writing, over 800 members, almost all of which are instructors using Greenfoot. About two thirds of these are at a secondary school, and most of the remainder are at college or university. Since its first release in mid 2006, Greenfoot has been downloaded more than half a million times from our Web site. Feedback from teachers often emphasises motivation and engagement of students: Greenfoot worked really well with my students, I was very impressed how absorbed they were. Greenfoot is a brilliant instructional tool, and it s setting off sparks in my student s heads like I ve never seen before.
19 The Greenfoot Programming Environment 14: 19 My students love Greenfoot! They worked harder than ever on this challenge. We are having a great time working with Greenfoot. The students can relate to the scenario and are anxious to add additional capabilities. Another aspect regularly mentioned in user feedback is ease of use. Greenfoot seems to succeed in providing fewer stumbling blocks than other systems teachers had experience with. I ve been enjoying both the system and the book; it s great to see my students making real progress on their projects, free from the normal development obstructions and roadblocks. The Greenfoot system (software and material) also seems successful in providing help for less experienced teachers. I had my first class yesterday, and having done no programming whatsoever before, I was worried that I would not be able to get into it, however using Greenfoot to program the little crab has reassured me, and I feel that I will be able to do this well. At high school level, Greenfoot is regularly used both in curricular instruction and in extracurricular activities, such as after-school clubs. At university level, most use is in introductory programming courses. Here, it is sometimes used for an initial part of the first semester (e.g., the first six weeks), and sometimes throughout the semester in parallel or alternating with other environments (this pattern seems to work especially well with BlueJ, because of the commonalities in interface and programming model). Universities also use Greenfoot for school outreach and engagement activities. 15. RELATION TO SCRATCH AND ALICE Greenfoot is a teaching system designed to make the creation and understanding of computer programs easier. In the taxonomy presented by Kelleher and Pausch [Kelleher and Pausch 2005], it is grouped in the Teaching Systems/Mechanics of Programming category, and within this, covers the following sub-categories: Simplify Typing Code, Making New Models Accessible, Tracking Program Execution, Make Programming Concrete and Models of Programming Execution. Greenfoot shares many design objectives and teaching philosophies with Scratch and Alice, such as the encouragement of creative exploration, tinkering, experimentation, discovery, and social interaction. All three systems make use of graphics and sound as motivators, while teaching fundamental programming concepts. The main target age groups differ. Both Scratch and Alice can be used with younger children than Greenfoot, while Greenfoot scales better for more proficient users. Scratch has a target user group almost entirely complementary to
20 14: 20 M. Kölling Greenfoot (8- to 16-year-olds, to Greenfoot s 14+), while Alice aims at a broader range from 12 to about 19. Greenfoot can follow on well from either Alice or Scratch. However, because of the good complementary fit in target age group, as well as the common focus on 2D graphics, a sequence of Scratch-to-Greenfoot is especially interesting. Concepts between those systems transfer well. Scratch has a simpler object model without classes which allows a very quick and easy start, but has drawbacks for some kinds of more advanced projects, especially those involving many objects of the same kind. This is an ideal opportunity to motivate a switch to Greenfoot once learners reach a stage where they aim for more ambitious projects. Concepts learned in Scratch can then be generalized and extended. The move to Greenfoot s text-based editing and class-based object model adds complexity, but the functionality gained in return provides more power for the programmer. This presents a well working, realistic trade-off in a move to a more powerful system as learners progress in their programming ability. Some resources exist in the Greenroom to explicitly facilitate this transition from Scratch to Greenfoot. Alice s object model is, like Greenfoot s, based on Java 3, and the Aliceequivalent Java code can be produced and edited. Thus, Alice s mental model is very close to that of Greenfoot. This would allow smooth transition between the two systems. However, the Alice team also propose use of Alice at introductory university level, covering much of the same age group that Greenfoot is aimed at. Here, the switch into Greenfoot is not quite as obvious an opportunity as with Scratch, since continuing in Alice is a possible alternative. The choice in this case comes down to preference of teachers between different kinds of systems. 16. CONCLUSION Greenfoot is a system straddling the balance point between relatively untrained programmers and a professional programming language. It is designed for users with no or little programming experience, but aims at providing practice with standard programming concepts and techniques used in a current mainstream language. This is intended to make adoption in schools and universities easier, since traditional curricula can easily be taught using it. Greenfoot aims at making the use of the standard language, Java, easy by providing a custom-designed environment that removes much of the complexity commonly associated with object-oriented programming. At the same time, it adds functionality to easily create graphics, animation and sound, so that engaging examples can be treated early. Using Greenfoot, young learners can easily create simple games and simulations while learning fundamental programming principles. Feedback from users appears to indicate that the goal of engaging learners through the use of these kinds of examples is successful. Greenfoot can be used as a first programming system for learners in the mid-teens or older, or as a second system 3 As of Alice version 3.0.
Game Programming in Introductory Courses With Direct State Manipulation Michael Kölling Computing Laboratory University of Kent email@example.com.
Game Programming in Introductory Courses With Direct State Manipulation Michael Kölling Computing Laboratory University of Kent firstname.lastname@example.com ABSTRACT While the introduction of object-oriented programmingMore information
Motivating Programmers via an Online Community
Motivating Programmers via an Online Community Poul Henriksen Computing Laboratory University of Kent email@example.com Michael Kölling Computing Laboratory University of Kent email@example.com DavinMore information
TEACHING OBJECT ORIENTED PROGRAMMING AT THE INTRODUCTORY LEVEL. Mehmet C. OKUR *
149 TEACHING OBJECT ORIENTED PROGRAMMING AT THE INTRODUCTORY LEVEL Mehmet C. OKUR * ABSTRACT Teaching object oriented programming has become a rapidly expanding preference at various educational environments.More information
AP Computer Science A - Syllabus Overview of AP Computer Science A Computer Facilities
AP Computer Science A - Syllabus Overview of AP Computer Science A Computer Facilities The classroom is set up like a traditional classroom on the left side of the room. This is where I will conduct myMore information
Fundamentals of Java Programming
Fundamentals of Java Programming This document is exclusive property of Cisco Systems, Inc. Permission is granted to print and copy this document for non-commercial distribution and exclusive use by instructorsMore information
Gaming for Middle School Students: Building Virtual Worlds
Gaming for Middle School Students: Building Virtual Worlds CHARLES R. HARDNETT Spelman College Computer Science Department Atlanta, GA 30314 email@example.com ABSTRACT We can begin engaging new talentedMore information
Teaching Object-Oriented Programming with Games
2009 Sixth International Conference on Information Technology: New Generations Teaching Object-Oriented Programming with Games Lu Yan School of Computer Science, University of Hertfordshire Hatfield, HertfordshireMore information
The first program: Little Crab
CHAPTER 2 The first program: Little Crab topics: concepts: writing code: movement, turning, reacting to the screen edges source code, method call, parameter, sequence, if-statement In the previous chapter,More information
2 The first program: Little Crab
2 The first program: Little Crab topics: concepts: writing code: movement, turning, reacting to the screen edges source code, method call, parameter, sequence, if statement In the previous chapter, weMore information
3 Improving the Crab more sophisticated programming
3 Improving the Crab more sophisticated programming topics: concepts: random behavior, keyboard control, sound dot notation, random numbers, defining methods, comments In the previous chapter, we lookedMore information
Experiences with Online Programming Examinations
Experiences with Online Programming Examinations Monica Farrow and Peter King School of Mathematical and Computer Sciences, Heriot-Watt University, Edinburgh EH14 4AS Abstract An online programming examinationMore information
Going Interactive: Combining Ad-Hoc and Regression Testing
Going Interactive: Combining Ad-Hoc and Regression Testing Michael Kölling 1, Andrew Patterson 2 1 Mærsk Mc-Kinney Møller Institute, University of Southern Denmark, Denmark email@example.com 2 Deakin University,More information
SL-110: Fundamentals of Java Revision 15 October Sun Educational Services Instructor-Led Course Description
Sun Educational Services Instructor-Led Course Description Fundamentals of Java SL-110 The Fundamentals of the Java course provides students, with little or no programming experience, with the basics ofMore information
Wilson Area School District Planned Course Guide
Wilson Area School District Planned Course Guide Title of planned course: Introduction to Computer Programming Subject Area: Business Grade Level: 9-12 Course Description: In this course, students areMore information
Glossary of Object Oriented Terms
Appendix E Glossary of Object Oriented Terms abstract class: A class primarily intended to define an instance, but can not be instantiated without additional methods. abstract data type: An abstractionMore information
TEACHING INTRODUCTORY COMPUTER GRAPHICS WITH THE PROCESSING LANGUAGE Dino Schweitzer, Jeff Boleng, Paul Graham United States Air Force Academy, CO 80840 firstname.lastname@example.com ABSTRACT Different approachesMore information
GAME: A Generic Automated Marking Environment for Programming Assessment
GAME: A Generic Automated Marking Environment for Programming Assessment Michael Blumenstein, Steve Green, Ann Nguyen and Vallipuram Muthukkumarasamy School of Information Technology, Griffith UniversityMore information
Educational Programming on the Raspberry Pi. School of Computing, University of Kent, Canterbury, CT2 7NF, UK; email@example.com; Tel.
electronics Article Educational Programming on the Raspberry Pi Michael Kölling School of Computing, University of Kent, Canterbury, CT2 7NF, UK; email@example.com; Tel.: +44-1227-823821 Academic Editors:More information
EXPERIENCES BUILDING A COLLEGE VIDEO GAME DESIGN COURSE Paul E. Dickson Hampshire College School of Cognitive Science 893 West St. Amherst, MA 01002, USA (413) 559-5861 email@example.com ABSTRACTMore information
Part 1 Foundations of object orientation
OFWJ_C01.QXD 2/3/06 2:14 pm Page 1 Part 1 Foundations of object orientation OFWJ_C01.QXD 2/3/06 2:14 pm Page 2 1 OFWJ_C01.QXD 2/3/06 2:14 pm Page 3 CHAPTER 1 Objects and classes Main concepts discussedMore information
Objects From the Beginning - With GUIs
Objects From the Beginning - With GUIs Viera K. Proulx College of Computer Science Northeastern University Boston, MA 02115 1-617-373-2225 vkp @ccs.neu.edu Jeff Raab College of Computer Science NortheasternMore information
Having Fun with Computer Programming and Games: Teacher and Student Experiences
Having Fun with Computer Programming and Games: Teacher and Student Experiences Clare McInerney Lero - the Irish Software Engineering Research Centre, University of Limerick, Ireland firstname.lastname@example.com information
Abstraction in Computer Science & Software Engineering: A Pedagogical Perspective
Orit Hazzan's Column Abstraction in Computer Science & Software Engineering: A Pedagogical Perspective This column is coauthored with Jeff Kramer, Department of Computing, Imperial College, London ABSTRACTMore information
Introducing Computer Science Through Animation and Virtual Worlds
Introducing Computer Science Through Animation and Virtual Worlds Susan H. Rodger Department of Computer Science Duke University Durham, NC 27705 firstname.lastname@example.com Abstract We describe a course for non-majorsMore information
Interactive Game Design with Greenfoot YEAR 1 Greenfoot Single-player Interactive Game
MESA VIRTUAL COMPUTER SCIENCE COMPETITION CYBER RULES 2016 Interactive Game Design with Greenfoot YEAR 1 Greenfoot Single-player Interactive Game Level: Type of Contest: Composition of Team: Number ofMore information
Objects: Visualization of Behavior and State
Objects: Visualization of Behavior and State Wanda Dann* Toby Dragon Ithaca College Ithaca, NY 14850 1-607-274-3602 wpdann @ ithaca.edu Stephen Cooper* Kevin Dietzler Kathleen Ryan Saint Joseph's UniversityMore information
Unit Testing in BlueJ
Unit Testing in BlueJ Version 1.0 for BlueJ Version 1.3.0 Michael Kölling Mærsk Institute University of Southern Denmark Copyright M. Kölling 1 INTRODUCTION.........................................................................More information
GSPIM: Graphical Visualization Tool for MIPS Assembly
GSPIM: Graphical Visualization Tool for MIPS Assembly Programming and Simulation Patrick Borunda Science University of Arizona email@example.com Chris Brewer Science University of Arizona firstname.lastname@example.com information
Building and Using Web Services With JDeveloper 11g
Building and Using Web Services With JDeveloper 11g Purpose In this tutorial, you create a series of simple web service scenarios in JDeveloper. This is intended as a light introduction to some of theMore information
Programming Languages in a Liberal Arts Education
Programming Languages in a Liberal Arts Education Kim Bruce Computer Science Department Pomona College Claremont, CA 91711 Stephen N. Freund Computer Science Department Williams College Williamstown, MAMore information
Mediated Transfer: Alice 3 to Java
Mediated Transfer: Alice 3 to Java Wanda Dann Computer Science Department 1-412-268-9959 firstname.lastname@example.com Dennis Cosgrove Human Computer Interaction Institute 1-412-268-4074 email@example.com DonMore information
Chapter 1. Introduction to ios Development. Objectives: Touch on the history of ios and the devices that support this operating system.
Chapter 1 Introduction to ios Development Objectives: Touch on the history of ios and the devices that support this operating system. Understand the different types of Apple Developer accounts. IntroduceMore information
CO320 Introduction to Object- Oriented Programming
CO320 Introduction to Object- Oriented Programming Michael Kölling 3.0 Take control of your own learning Lecture Classes Exercises Book Web page Discussion forum Study groups Practice, practice, practice!More information
The BlueJ Tutorial. Version 2.0.1 for BlueJ Version 2.0.x. Michael Kölling Mærsk Institute University of Southern Denmark
The BlueJ Tutorial Version 2.0.1 for BlueJ Version 2.0.x Michael Kölling Mærsk Institute University of Southern Denmark Table of contents Copyright M. Kölling Contents 1 Foreword 4 1.1 About BlueJ...4More information
Alice to Java: Engaging Students in Programming. Lorilyn Owens Oracle Academy
Alice to Java: Engaging Students in Programming Lorilyn Owens Oracle Academy Engaging Students Purpose Content Progression Support 2 Engage with a Purpose PURPOSE Content Progression Support 3 The JobMore information
Using Karel with Eclipse
Mehran Sahami Handout #6 CS 106A September 23, 2015 Using Karel with Eclipse Based on a handout by Eric Roberts Once you have downloaded a copy of Eclipse as described in Handout #5, your next task isMore information
Thomas Jefferson High School for Science and Technology Program of Studies Accelerated Foundations of Computer Science as of April 2013
Thomas Jefferson High School for Science and Technology Program of Studies Accelerated Foundations of Computer Science as of April 2013 Unit of Study / Accelerated Foundations of Computer Science is offeredMore information
Encouraging Playful Design in Computer Science
Encouraging Playful Design in Computer Science Gregory Garrett Creativity and Design Cognition, Spring 2010 Georgia Institute of Technology email@example.com Abstract In this paper we describe our visionMore information
COURSE TITLE. Computer Programming 1 LENGTH. One Semester Grades 9-12 DEPARTMENT. Computer Department Barbara O Donnell, Supervisor SCHOOL
COURSE TITLE Computer Programming 1 LENGTH One Semester Grades 9-12 DEPARTMENT Computer Department Barbara O Donnell, Supervisor SCHOOL Rutherford High School DATE Spring 2015 Computer Programming 1 PageMore information
New Generation of Software Development
New Generation of Software Development Terry Hon University of British Columbia 201-2366 Main Mall Vancouver B.C. V6T 1Z4 email@example.com ABSTRACT In this paper, I present a picture of what software developmentMore information
Manage Software Development in LabVIEW with Professional Tools
Manage Software Development in LabVIEW with Professional Tools Introduction For many years, National Instruments LabVIEW software has been known as an easy-to-use development tool for building data acquisitionMore information
Env3D: A Very Simple Java Gaming Engine for CS 1
Env3D: A Very Simple Java Gaming Engine for CS 1 Jason Madar Capilano College firstname.lastname@example.com Introduction 3D gaming is becoming very popular, and students are exposed to interactive 3D virtualMore information
Abstract. Introduction
Database Systems and Oracle: Experiences and Lessons Learned Deborah Dunn Assistant Professor Computer Science Department Stephen F. Austin State University Nacogdoches, TX 75961 (936) 468-2508 firstname.lastname@example.com information
Lecture Notes on Programming Languages
Lecture Notes on Programming Languages 1 Lecture 09: Support for Object-Oriented Programming This lecture discusses how programming languages support object-oriented programming. Topics to be covered include:More information
Programming with Scratch
Programming with Scratch Harvey Siy email@example.com http://www.cs.unomaha.edu/~hsiy Outline Computational thinking Introduction to Scratch Short exercise A more complicated example Discussions 2 ComputationalMore information
Availability of the Program A free version is available of each (see individual programs for links).
Choosing a Programming Platform Diane Hobenshield Tepylo, Lisa Floyd, and Steve Floyd (Computer Science and Mathematics teachers) The Tasks Working Group had many questions and concerns about choosingMore information
Google Apps for Education: The Basics
Google Apps for Education: The Basics You will learn how to get started with Google Drive by uploading and converting documents. You will also learn how to share your documents with others. Plus learnMore information
Stock Market Instructor Guide
Stock Market Using GoVenture In Your Learning Environment Contents 1. Welcome... 3 2. About GoVenture... 4 3. What Makes GoVenture Stock Market Unique... 5 4. How GoVenture Differs from Other Stock Simulations...More information
Using the TASKING Software Platform for AURIX
Using the TASKING Software Platform for AURIX MA160-869 (v1.0rb3) June 19, 2015 Copyright 2015 Altium BV. All rights reserved. You are permitted to print this document provided that (1) the use of suchMore information
CS Standards Crosswalk: CSTA K-12 Computer Science Standards and Oracle Java Programming (2014)
CS Standards Crosswalk: CSTA K-12 Computer Science Standards and Oracle Java Programming (2014) CSTA Website Oracle Website Oracle Contact http://csta.acm.org/curriculum/sub/k12standards.html https://academy.oracle.com/oa-web-introcs-curriculum.htmlMore information
Teaching Java with the BlueJ Environment
Teaching Java with the BlueJ Environment Dianne Hagan School of Computer Science and Software Engineering Monash University, AUSTRALIA firstname.lastname@example.com Selby Markham Faculty of InformationMore information
Adobe Spark. Schools and Educators. A Guide for. spark.adobe.com
Adobe Spark A Guide for Schools and Educators spark.adobe.com CONTENTS 1: What Is Adobe Spark?... 3 2: How Much Does Adobe Spark Cost?... 4 3: Is Adobe Spark A Web Application Or An App?... 4 4: ThreeMore information
Toward a community enhanced programming education
Toward a community enhanced programming education Ryo Suzuki University of Tokyo Tokyo, Japan firstname.lastname@example.com Permission to make digital or hard copies of all or part of this work forMore information
2 Key words: Automatic feedback, 1 st year students, large classes, computer programming, independent learners
Learning and Teaching Enhancement Project Report, June, 2015 Project Title: Helping 1st Year CS Students to Become Independent Learners Through Automated Feedback School & department: School of MathematicalMore information
Software. Managing Software Assets. Major types of software BIOS
Software Managing Software Assets A software program is a series of statements or instructions to the computer. The process of writing or coding programs is termed programming; and the individuals whoMore information
Introduction to Programming with Greenfoot
Introduction to Programming with Greenfoot Companion Website Additional material and resources for this book can be found at http://www.greenfoot.org/book/ For students: The Greenfoot software The scenariosMore information
An Interactive Tutorial System for Java
An Interactive Tutorial System for Java Eric Roberts Stanford University email@example.com ABSTRACT As part of the documentation for its library packages, the Java Task Force (JTF) developed anMore information
Cabana: A Cross-platform Mobile Development System
Cabana: A Cross-platform Mobile Development System Paul E. Dickson Hampshire College School of Cognitive Science 893 West St. Amherst, MA 01002, USA email@example.com ABSTRACT Mobile application developmentMore information
Bitstrips for Schools http://www.bitstripsforschools.com
The SAMR Model: Integrating Bitstrips for Schools Ministry Licensed Resource Title: Description of resource Bitstrips for Schools http://www.bitstripsforschools.com Bitstrips for Schools is an online educationalMore information
A Team of Pedagogical Agents in Multimedia Environment for Children
Morozov, M., Tanakov, A., and Bystrov, D. (2004). A Team of Pedagogical Agents in Multimedia Environment for Children. Educational Technology & Society, 7 (2), 19-24. A Team of Pedagogical Agents in MultimediaMore information
Chapter 13: Program Development and Programming Languages
15 th Edition Understanding Computers Today and Tomorrow Comprehensive Chapter 13: Program Development and Programming Languages Deborah Morley Charles S. Parker Copyright 2015 Cengage Learning LearningMore information
BlueJ Teamwork Tutorial
BlueJ Teamwork Tutorial Version 2.0 for BlueJ Version 2.5.0 (and 2.2.x) Bruce Quig, Davin McCall School of Engineering & IT, Deakin University Contents 1 OVERVIEW... 3 2 SETTING UP A REPOSITORY... 3 3More information
Enabling Service-Based Application Development through Social Objects
Enabling Service-Based Application Development through Social Objects Peter D. Schott, Michael J. Burns, and R. Bruce Craig Abstract Software development is typically a social activity; development isMore information
Web Tools and Techniques for E-Learning
Web Tools and Techniques for E-Learning This paper is intended as an introduction to web-based training for technical communicators who are new to e-learning or want to move into e-learning. We focus onMore information
Using BlueJ to Introduce Programming
Using BlueJ to Introduce Programming Michael Kölling University of Kent, Canterbury, Kent CT2 7NF, United Kingdom email@example.com Abstract. This chapter describes the BlueJ system. The discussion includesMore information
Best Practices for Online Courses. 100 Quality Indicators for Online Course Design
Best Practices for Online Courses 100 Quality Indicators for Online Course Design The following criteria are meant to act as guidelines for the course development process. Some of these guidelines wouldMore information
On the Learning in E-Learning
On the Learning in E-Learning Raimond Reichert Swiss Centre for Innovations in Learning University of St Gallen 9000 St Gallen, Switzerland firstname.lastname@example.com Werner Hartmann Technology & EducationMore information
CERTIFICATION EXAMINATIONS FOR OKLAHOMA EDUCATORS (CEOE ) OKLAHOMA SUBJECT AREA TESTS (OSAT ) FIELD 081: COMPUTER SCIENCE September 2008 Subarea Range of Competencies I. Computer Use in Educational EnvironmentsMore information
MICHIGAN TEST FOR TEACHER CERTIFICATION (MTTC) TEST OBJECTIVES Subarea Educational Computing and Technology Literacy Computer Systems, Data, and Algorithms Program Design and Verification Programming LanguageMore information
Orange Unified School District Video Game Design II Year Course
Course No. B861 O642 Orange Unified School District Video Game Design II Year Course Grade Level: 10-12 Prerequisites: Video Game Design 1 Introduction to the Subject Video Game Design II is an advancedMore information
It provides the performance indicators to evaluate the level of knowledge and competence of teacher to apply ICT in the educational setting.
COMMISSION ON INFORMATION AND COMMUNICATIONS TECHNOLOGY NATIONAL ICT COMPETENCY STANDARD (NICS) FOR TEACHERS INTRODUCTION The National ICT Competency Standard (NICS) for Teachers defines the competencyMore information
Explicit Instruction: Strategies for Meaningful Direct Teaching Author: Jennifer L. Goeke
Explicit Instruction: Strategies for Meaningful Direct Teaching Author: Jennifer L. Goeke ISBN-10: 0205533280 ISBN-13: 9780205533282 Publisher: Merrill / Pearson Copyright: 2009 Format: Paper; 144 pp Published:More information
Incorporation of an online tutoring tool into programming courses. Abstract
Incorporation of an online tutoring tool into programming courses Ozgur Aktunc Engineering Department St. Mary s University firstname.lastname@example.com Abstract One of the challenges growing institutions faceMore information
Instructional Design Framework CSE: Unit 1 Lesson 1
Instructional Design Framework Stage 1 Stage 2 Stage 3 If the desired end result is for learners to then you need evidence of the learners ability to then the learning events need to. Stage 1 Desired ResultsMore information
Hypercosm. Studio. www.hypercosm.com
Hypercosm Studio www.hypercosm.com Hypercosm Studio Guide 3 Revision: November 2005 Copyright 2005 Hypercosm LLC All rights reserved. Hypercosm, OMAR, Hypercosm 3D Player, and Hypercosm Studio are trademarksMore information
COMPUTER SCIENCE COURSE OUTLINE Grade 7 8 11/12 10/11/12 11/12 Course Introduction to Computer Essentials (focus on Applications) Part 1 Computer Applications Part 2- Computer Integration Advanced ComputerMore information
Frances: A Tool For Understanding Code Generation
Frances: A Tool For Understanding Code Generation Tyler Sondag Dept. of Computer Science Iowa State University 226 Atanasoff Hall Ames, IA 50014 email@example.com Kian L. Pokorny Division of ComputingMore information
Android: Setup Hello, World: Android Edition. due by noon ET on Wed 2/22. Ingredients.
Android: Setup Hello, World: Android Edition due by noon ET on Wed 2/22 Ingredients. Android Development Tools Plugin for Eclipse Android Software Development Kit Eclipse Java Help. Help is available throughoutMore information
Search help. More on Office.com: images templates
Page 1 of 14 Access 2010 Home > Access 2010 Help and How-to > Getting started Search help More on Office.com: images templates Access 2010: database tasks Here are some basic database tasks that you canMore information
02-201: Programming for Scientists
1. Course Information 1.1 Course description 02-201: Programming for Scientists Carl Kingsford Fall 2015 Provides a practical introduction to programming for students with little or no prior programmingMore information
Articulating Instructional Goals
Janet Russell CNDLS Workshop Goals: 1) Teaching vs. Learning goals Participants will be able to distinguish between teacher-centered and student-centered learning goals. 2) Articulate a set of learningMore information
Week 2 Practical Objects and Turtles
Week 2 Practical Objects and Turtles Aims and Objectives Your aim in this practical is: to practise the creation and use of objects in Java By the end of this practical you should be able to: create objectsMore information
Competencies for Secondary Teachers: Computer Science, Grades 4-12
1. Computational Thinking CSTA: Comp. Thinking 1.1 The ability to use the basic steps in algorithmic problemsolving to design solutions (e.g., problem statement and exploration, examination of sample instances,More information
Course Title: Software Development
Course Title: Software Development Unit: Customer Service Content Standard(s) and Depth of 1. Analyze customer software needs and system requirements to design an information technology-based project plan.More information
Version 4.5 The Graphical Metamodeling Example
Version 4.5 The Graphical Metamodeling Example MetaCase Document No. GE-4.5 Copyright 2008 by MetaCase Oy. All rights reserved First Printing, 2 nd Edition, February 2008. MetaCase Ylistönmäentie 31 FIMore information
What Is Ad-Aware Update Server?
Contents What Is Ad-Aware Update Server?...2 Installation and Removal...3 System Requirements...3 Obtaining the Installation File...3 Installing Ad-Aware Update Server...3 Upgrade...4 Repairing, ModifyingMore information
Web Services: Introduction and Travel Project Tutorials Using Visual Studio and ASP.NET
Web Services: Introduction and Travel Project Tutorials Using Visual Studio and ASP.NET Alan R. Peslak email@example.com Information Sciences and Technology, Penn State University Dunmore, PA 18512 AbstractMore information
Improving Students Learning Programming Skills with ProGames - Programming through Games system
Improving Students Learning Programming Skills with ProGames - Programming through Games system Raquel Hijón-Neira 1, Ángel Velázquez-Iturbide 1, Celeste Pizarro-Romero 2, Luís Carriço 3 1 DepartamentoMore information
1. Responsive Website Basics: Code with HTML, CSS and JavaScript 2. Responsive Web Design
Massive Open Online Courses (MOOCs): Goldsmiths 1. Responsive Website Basics: Code with HTML, CSS and JavaScript 2. Responsive Web Design As part of a MOOCs specialisation: Responsive website developmentMore information
Java Application Developer Certificate Program Competencies
Java Application Developer Certificate Program Competencies After completing the following units, you will be able to: Basic Programming Logic Explain the steps involved in the program development cycleMore information
Steps to Migrating to a Private Cloud
Deploying and Managing Private Clouds The Essentials Series Steps to Migrating to a Private Cloud sponsored by Introduction to Realtime Publishers by Don Jones, Series Editor For several years now, RealtimeMore information
Scalable Game Design: Broadening Participation by Integrating Game Design and Science Simulation Building into Middle School Curricula
Scalable Game Design: Broadening Participation by Integrating Game Design and Science Simulation Building into Middle School Curricula Introduction At the University of Colorado we have worked on visualMore information
Instructional Design Principles in the Development of LearnFlex
Instructional Design Principles in the Development of LearnFlex A White Paper by Dr. Gary Woodill, Ed.D. Chief Learning Officer, Operitel Corporation firstname.lastname@example.com Dr. Karen Anderson, PhD. SeniorMore information
Case studies: Outline. Requirement Engineering. Case Study: Automated Banking System. UML and Case Studies ITNP090 - Object Oriented Software Design
I. Automated Banking System Case studies: Outline Requirements Engineering: OO and incremental software development 1. case study: withdraw money a. use cases b. identifying class/object (class diagram)More information
CS 209 Programming in Java #1
CS 209 Programming in Java #1 Introduction Spring, 2006 Instructor: J.G. Neal 1 Topics CS 209 Target Audience CS 209 Course Goals CS 209 Syllabus - See handout Java Features, History, Environment JavaMore information
Code::Blocks Student Manual
Code::Blocks Student Manual Lawrence Goetz, Network Administrator Yedidyah Langsam, Professor and Theodore Raphan, Distinguished Professor Dept. of Computer and Information Science Brooklyn College ofMore information
Getting Started with LEGO Robotics
Excerpted from Getting Started with LEGO Robotics A Guide for K-12 Educators Mark Gura LEGO Robotics is a hands on, multidisciplinary, collaborative, authentic learning experience, and Mark Gura wantsMore information
The BSN Hardware and Software Platform: Enabling Easy Development of Body Sensor Network Applications
The BSN Hardware and Software Platform: Enabling Easy Development of Body Sensor Network Applications Joshua Ellul firstname.lastname@example.com Overview Brief introduction to Body Sensor Networks BSN HardwareMore information
An Experimental Study of Cooperative Learning in CS1
An Study of Cooperative Learning in CS1 Leland L. Beck Department of Computer Science San Diego State University San Diego, CA 92182-772 (619) 594-687 email@example.com Alexander W. Chizhik School of TeacherMore information


text:
NIM07060 - Class 1 NICs: Payments made under employment legislation: Earnings period to be used in assessing NICs liability: General
Regulations 2, 5(a) and 8 Social Security (Contributions) Regulations 2001
Payments made under:
- a reinstatement order (see NIM07020 NIM07021)
- a re-engagement order (see NIM07030 NIM07031)
- an order for the continuation of a contract of employment (see NIM07040 onwards)
- a protective award (see NIM07050 onwards)
have their own specific earnings periods.
For details of the earnings periods to be used for payments made under:
As payments made under any of the above orders or a protective award have their ownunique earnings period, any such payment must not be aggregated with any other payment ofearnings made at the same time. But this is subject to the following exception.
Exception payment made to a director
The only exception to the rule mentioned in the previous paragraph is where the paymentmade under:
- any of the above orders; or
- a protective award
is paid to a director.
This exception is provided for in regulation 2 Social Security (Contributions)Regulations 2001.
In such cases:
- add the amount of the payment made under any of the above orders or a protective award to the amount of the other earnings, and assess the amount of NICs on the total amount; and
- use the earnings period which is being used to assess NICs on other payments made to the director ie, an annual earnings period or a pro-rata annual earnings period (regulation 8 Social Security (Contributions) Regulations 2001; see NIM12021 onwards).

subset: commoncrawl


text:
With another 428,000 new unemployment filings last week, the flood of bad economic news continues to point to a recessionary "double dip" that President Barack Obama's $859 billion stimulus program was supposed to
And let's not forget that, while Obama and a Democratic Congress were "pump-priming" as never before, Federal Reserve Board Chairman Ben Bernanke was simultaneously injecting another $1.6 trillion in freshly printed bills into the economy. Surely now the Keynesian belief that massive government spending is the way to ignite economic growth during a recession has been utterly and forever discredited.
But a congressional report released last week added another layer of explanation for the abject failure of Obamanomics since 2009. Along with the explosion of federal spending, Obama directed his appointees at key federal departments and agencies to embark on an unprecedented expansion of bureaucratic regulation.
Thousands of new bureaucrats were hired at places such as the Department of Heath and Human Services and the U.S. Environmental Protection Agency, and legions of costly new regulations soon poured forth.
The report by the House Oversight and Government Reform Committee, chaired by Rep. Darrell Issa, R-Vista, took aim at Obama's "regulatory tsunami," concluding that the pace and scale of new regulations threatens the ability of the government to fulfill even its most basic regulatory functions.
Here's how the congressional panel summarized its conclusions:
"The Obama administration has created a regulatory environment that is suffocating America's entrepreneurs' ability to create jobs and grow businesses. This regulatory tsunami has caused job creators to lock down at a time when we need them to expand.
"The committee has found that the problems created by this regulatory tsunami goes far beyond the cost of the regulations themselves, but also include breakdowns in the regulatory process itself that is having a severe impact on large and small businesses alike."
Specifically, the panel found at least 219 "economically significant regulations in the pipeline, which if finalized, will impose costs of $100 million or more annually on the economy." That's a minimum of $219 billion in added costs to do business in this country over the next decade. Even worse, the panel found the Obama bureaucrats have already imposed 75 major new regulations that are projected to add another $380 billion in costs.
The Issa panel concluded that, as a result of this flood of new rules, "the regulatory process is broken" and that it is "being manipulated and exploited in an effort to reward allies of the Obama administration such as environmental groups, trial lawyers and unions."


text:
Honda Atlas Cars Pakistan Limited, a joint venture between Honda Motor Company Limited Japan, and the Atlas Group of Companies Pakistan, was incorporated in November 1992, and their first vehicle rolled off the assembly line in May 1994. Since the beginning, Honda was on par with the other local automobile manufacturers regarding available products, features offered, built quality, and updating their vehicles on time.
After the imports halted and local production of cars started in our country, Honda was the only company to keep introducing newer models on a regular basis. Toyota did not replace the 7th generation Toyota Corolla and kept selling it for nine years (1993-2002). Suzuki's lineup including Suzuki Mehran, Suzuki Bolan and Suzuki Ravi are still unchanged ever since their production started. The models were already a decade old when the production commenced.
Honda, who began with the 5th generation of Honda Civic 1995 was the first local company to discontinue a model in 1996 and introduced the 6th generation Civic, some two years after its production. Honda was also the first company to introduce an all new Honda City SX8 in the entry level sedan segment in 1997, giving some serious competition to Suzuki Margalla, which was unchanged for about six years back then.
Honda was the first local manufacturer to launch a true facelift in 1998, the 6th gen Honda Civic facelift arrived in the market and was very well received. Honda was also the first local manufacturer to offer Sunroof in their Civic Oriel trims.
Honda had a track record of replacing their models or introducing a facelift every 3rd year. After the production started in 1994, the 5th generation Civic was replaced with the 6th gen in 1996. Almost three years later in January 1999, the Civic facelift was launched. The 7th gen Civic was launched in March 2001 and about three years later, the 7th gen facelift (a.k.a. Eagle Eye) was introduced in 2004. The 8th gen Civic was introduced in July 2006 maintaining the three-year track record of Honda.
The Honda City SX8 that was introduced in January 1997 was updated with a facelift in January 2000. Three years later in August 2003, the new City iDSI was introduced, and it received an update with a facelift in 2006, again maintaining the three-year cycle. While on 31st January 2009 the City iDSI was replaced with the new City iVTEC.
Unfortunately, Honda has not been keeping up with their standard of introducing or updating their vehicles recently. The 8th generation Civic was never offered with a facelift and kept selling for some six years without any significant changes.
The current Honda Civic 2016 was launched in 2012, was to be replaced by its facelift in 2015, but a true facelift never arrived for the Civic 2016. Similarly, the City introduced in 2009 was to be updated with its facelift in 2012 as per Honda standards, but the facelift came in October 2014. In international markets, the 6th generation Honda City 2013 was introduced in late 2013 and is expected to receive a facelift soon.
However, Honda Atlas is still offering the 5th generation City which, on 31st January 2016 has completed 7th year of its product life in our market and has entered in the 8th year of its production, making it the longest selling period for any locally produced model of Honda.
It's not just the delay factor; the City misses out on basic features that were stripped off the car for no reason. Honda was the pioneer to offer a high-mounted brake lamp at the rear windscreen of their cars which was touted as a safety feature by Honda in their earlier models. The 5th gen local City came without one. Honda even removed the trunk light from the Honda City which is something that is present even in the cars from the 80s.
Honda City 2015 price in Pakistan on average is about 1.5 million rupees and yet owners have been found installing a trunk light by themselves even after spending so much on this car. Interior came without center arm-rest too, while the later models didn't have central locking feature in the base trim.
Back in 1997 when Honda launched the SX8 City, even the base model was equipped with central locking and a trunk light, some fundamental features which Honda is reluctant to offer in 2016.
Get The Honda City 2016 Financed And Insured Through PakWheels
Apart from the sluggish automatic transmission and a rather hard drive due to the stiff suspension. The City is a popular car in our market, probably because the 5th gen Honda City remains the only City, which never saw a real competitor. Liana was out of the competition by 2010, and thus, the City remains the only choice in the entry level sedan segment. It's obvious that since there is no competition in the class, Honda seems to be not interested in updating to a newer 6th generation City and is happy to continue selling it.
On the other hand, Honda is losing many potential buyers that are either drifting towards the New Toyota Corolla, or the imported Japanese car. This has hurt Honda so badly that today they are shy to disclose the individual sales figures for Honda City and Honda Civic, instead present them as combined figures. Though on paper, the company boasts to have offered cars like CR-V, CR-Z, HR-V (used imported version being Honda Vezel 2015) and Honda Accord but, in reality, these cars don't even make up 5 percent of the market.
Read the comparison between Honda Vezel and Honda HR-V
It's quite disappointing to see the leading manufacturer of our small automobile industry, a company that always excelled in offering modern, up-to-date and quality products now following the footsteps of Pak Suzuki.
It's about time Honda should work hard to regain its market here, they should offer affordable products that are within the reach of masses such as Honda Jazz or Honda Life. The new Honda Civic X (Read 10th Gen Honda Civic X review) is on the verge of its launch here, and that's a winner that can get Honda Pakistan back on track, but Honda needs to win people's hearts, and should not disappoint them this time.
It's about time for the power of dreams to become power of reality I think.


text: Communication Upgrades on the WayMay 18, 2012 09:11 AM in Photos • 0 CommentsA technician installs a wireless tower at the corner of Chief Peguis Trail and Henderson Highway on Thursday. The city is identifying equipment requirements and locations to support current and future traffic signals and traffic management centre wireless communication needs. Upgrades will take place over the next several months at locations throughout Winnipeg. (STAN MILOSEVIC / MANITOBAPHOTOS.COM) Advertisements ShareTweetEmail Sports HighlightsRelatedComments comments


text:
According to this site---"If you use Windows XP and havent yet updated your system with the applicable security updates that Microsoft issued Tuesday, you might want to hold off for a bit. Turns out, a non-trivial number of XP users are reporting that their systems suffer from the dreaded Blue Screen of Death (BSoD) and fall into an interminable reboot loop after installing the latest batch of patches from Redmond."
Before I knew about this problem, I downloaded this update (KB977165) and installed it and got a BSOD on reboot. Info on this screen was:
1st line---
10digit #, then in parens ( 10digits, 10 digits, 10 digits, 10 digits).
2nd line---
ctoss2k.sys - address F64FC57A base at F64FA0000 Data stamp 3E81578E.
Then on the next line--- "dump of physical memory" msg.
When I rebooted, pressed the F8 key, I went to the resart page that allows you to reboot in normal mode, safe mode, etc. I selected the mode "last know good configuration" and rebooted.
Since then my system has worked fine. My question---is there a way to undo this windows update fix without having to go to the repair screen/recovery console suggested in the 5 steps in the url link above?


text:
0 Flares 0 Flares ×
4479 Sterling Pointe Drive NW, Kennesaw, GA
Just Listed
- Follow This Home!
- Search All Homes For Sale
- Free List of Foreclosed Homes For Sale
- Mortgage and Refinance
- Free Home Values
Presented By:
$ Click for current price
4 BEDROOMS | 4 (3 full, 1 half ) BATHROOMS | 3633 SQUARE FEET
Elegant executive home in Allatoona HS! You will fall in love with this stunning 3 sides brick home. Stunning master on the main with additional sitting area w/ fireplace.Formal dining rm, separate living rm & office on main.Gorgeous hardwoods on main and plantation shutters throughout this open floor plan. Enjoy the 2 story bright family room featuring fireplace and bookcases. Spacious kitchen features island, granite and ss appliances.Relax in your spacious sunroom and entertain in your private flagstone patio.Large secondary bedrooms upstairs,3 car garage and more.


text:
Next Episode of Police Squad! is
not planed. TV Show was canceled.
Police Squad! was a parody of the Quinn Martin Productions' police dramas of the 1960s and 1970s, hence the use of "In Color" by the narrator. The show's main staple of entertainment came from sight gags (such as a tow truck being a truck in the shape of a big toe) and misunderstandings in dialogue, mostly from people taking things extremely literally. Several great routines came from these misunderstandings that left characters in the scene very confused, but left the audience with loads of humor.
The daughter of a wealthy business man is kidnapped on her 18th birthday and Police Squad swings into action. The main suspect of their investigation is the girl's boyfriend. When Frank and Ed listen to a recording of the kidnapper's demands, they hear the distinct sound of a tuba in the background, though it could also be a ship's horn. They search for a tuba store. When they do track down and find the kidnapper, the criminal fights back.
Frank investigates a district judge's courtroom after it is booby-trapped with a powerful explosive. The main suspect is a recently paroled ex-convict with a history of similar bombings. Upon questioning the bomber's ex-wife, Frank and Ed find she's more interested in getting charity than the fact that her ex-husband may be up to his old tricks. Frank and Ed discover the bomber has a showgirl girlfriend on the side. She has the perfect alibi for her boyfriend, but Frank and Ed wonder if she's really just covering for him.
The mob sets up an "insurance" scam that threatens several businesses and residents. Frank and Nordberg go to investigate. After a dance instructor is beaten up, they set up their own shop - a key-making and locksmith store - and go undercover. When the mob stops by to offer them "insurance", Frank dismisses their threats and the mob strikes their store. Frank ends up having the key to stopping the crime wave, largely because of the key-making and locksmith shop he and Nordberg set up.
A struggling comedian owes money to the owner of a nightclub. When his body is discovered at the bottom of a cliff in a car crash, all the clues point to suicide. It is later discovered that the comedian was also a police informant on a drug ring he infiltrated at his nightclub. Frank steps in and takes the place of the deceased at the nightclub in order to gather more clues.
Ed Williams(Mr. Olsen)
Leslie Nielsen(Det. Frank Drebin)
Alan North(Capt. Ed Hocken)
Peter Lupus(Norberg)
William Duell(Johnny)
Rex Hamilton(Abraham Lincoln)
Looks like something went completely wrong!
But don't worry - it can happen to the best of us,
- and it just happened to you.
Please try again later or contact us.


text:
Bold red lips is one of the most popular makeup look for the holiday season. It is the ultimate accessory that suits absolutely everyone. I love red lips, and have been using "its Christmas!" as an excuse to wear my favourite reds every single day, including around the house.
Bright lipstick is notoriously impractical, especially if you are like me, and you can't help but maintain the incoming food flow more or less constant. So I thought I'd share my lipstick application routine that prevents it from wearing off too soon, and helps it fade gracefully.
Apply moisturising lip balm in advance, or simply start with bare lips.
Pick a lip pencil closest to the colour of your lipstick. Using a sharp pencil will help you get the a more precise line, especially if you're not well practiced, but as you can tell, my liner here is reasonably blunt, which makes it glide easier.
Next, fill in the outline that you have created. This will ensure that if you do eat (I know I will!) or drink, even if the gloss of the lipstick wears off, the stain of the pencil won't leave you with a blank lip centre.
Now the obvious part - apply your lipstick. The key to success of this whole process is to work in thin layers, so make sure you don't go over the same area more than once - just enough for the lipstick to show its colour. Using a lip brush instead of going straight from the bullet will give you an even thinner layer, and will also allow you to get closer to the edges, in case your liner and lipstick don't match exactly.
Now grab a tissue and press it against the lips once or twice. This will take the excess product off, leaving the pigment behind.
For the final step, apply your lipstick again, but this time use dabbing motions, rather than sweeps. Only pat the lipstick in the centre of your lips, where the gloss will have been removed by the tissue.
And you're done! Hopefully this will help you be less conscious of your bright pout while helping yourself to a pork pie.
Happy Holidays! x


text:
With record-high numbers of people seeking jobs, the amount of online resume-posting websites has skyrocketed. This article will teach you how to protect your electronic privacy when you post your resume on the Internet.
According to the Bureau of Labor Statistics, in August 2011 there were 14.0 million unemployed workers in the United States. Given that statistic, it's easy to see that competition in the world of online job searches is fierce. If you're one of the millions of candidates using online resume posting as a job-search method, your electronic privacy may be at risk.
Posting online resumes can compromise your electronic privacy.
Posting your resume online places your electronic privacy at risk in a variety of ways:
- Your private information may be viewable by people you never intended to see it.
- Current job market conditions have given rise to phishers and other Internet scammers who gather personal information for unethical purposes.
- If you already have a job, you risk having your current company discover that you're seeking other employment.
- You may be leaving yourself open to spam.
- Your resume may contain enough information to allow an identity thief to begin setting up accounts in your name.
When you post an online resume, it's natural that you want to put your best foot forward with employers so they'll hire you. After you've carefully crafted the best possible resume, it may seem self-defeating to be cagey about your private information.
So how can you strike a balance between submitting a powerful online resume and protecting your electronic privacy?
Protect your Internet privacy on online job boards.
There are thousands of online job boards on the Web. Some, like Monster.com and CareerBuilder.com, have been around for years and are well known. Others are newer sites that may not have a recognizable name.
Remove private information
Job boards typically allow you to complete an electronic version of your resume, as well as upload a PDF or DOC format for storage. In order to protect your Internet privacy, it's essential that when you store resumes online you remove as much of your private information as possible.
- Never provide personal data like your date of birth, Social Security number, home address or any financial information on electronic resumes.
- Post your city and state or region in place of sharing your home address.
- Instead of using your personal email address for your contact information, set up a separate job search email through a free email program like Gmail or Yahoo, and supply that as your main method of communication.
- You might also want to consider setting up a separate job search phone number through Skype or another affordable online VoIP service in order to further protect your digital privacy.
Make sure that if you upload a PDF or DOC version of your resume that you have removed personal data as well.
Manage privacy controls
Many online job boards have privacy controls that allow you to select who sees your resume and how much information they receive about you. Opt for maximum privacy by selecting the option that hides identifying data when employers search your resume, or if you plan to use the job board to submit your resume for specific job postings only, choose the privacy controls option that keeps your resume entirely private.
Keep the name of your current company off your resume if you don't want your employer to know you're searching for a new job. Instead of posting your company's name on your resume, select a descriptive phrase such as "an industrial automation products manufacturing company" or "a major national bank."
If you're working with an unknown job board, do some research to see what you can learn about the site before posting an online resume. Avoid job boards that lack privacy controls and the ability to secure personal data. Don't rely on safety seals like BBB (Better Business Bureau) that are shown on the site without first clicking on the image to see if it actually goes through to the certifying site. Once you've clicked through, check the URL in your browser window to make sure it's the actual site's URL. You can confirm the correct site address through a quick Google search.
Safeguard your online privacy in online classifieds.
Your Internet privacy may also be at risk when you respond to online classified ads with an email and a copy of your electronic resume. Craigslist frequently warns of fake job postings and scams aimed at collecting your private information.
Follow the same safety rules for resumes you email to unknown entities as you would for online postings, especially if you're responding to blind ads. Blind ads that contain nonspecific details, that ask you respond to a randomized, site-assigned email address and that don't name the employer may pose a risk to your online security, so be careful of the information you submit. Wherever possible, try to go to the employer's website and submit an online application through the site rather than responding to an ad with an email.
Fix what's already online.
If you've already posted resumes online that fall outside the above recommendations, you can still protect your Internet safety. Start by returning to online job boards where you've posted your resume to remove identifying information and to change your privacy options. Track where you've posted your resume by using a spreadsheet or other document. Once you've completed your job search, go back and remove your resume from those sites. If you want additional peace of mind, consider online privacy protection, which monitors and removes your private information from the Internet.
Posting your resume with online job boards is an effective career development strategy. However, be sure to protect your digital privacy by carefully controlling the information you supply to potential employers.