In an introductory course where abilities vary widely, it would be difficult to form competent groups which could truly explore the group project.

Another concept which is put to use in this paper is the code reuse; this is a particular focus of cs15 which is never actually tested. A foundation principle of OOP is that of general and extendable code which can be applied in more than one place, but if this happens at all in cs15, it does so to a very small extent.

In the paper the students were to meant to build on the previous year's project, but I'm not sure this would be feasible in an introductory course where being able to design and implement ones own ideas are a more important goal. The is definitely merit in being able to use someone else's code, I think this is realized to some degree in the cs15 use of GP. If this is a point which requires more stress, efforts can definitely be made to integrate more and more varied support code in future programs. As it is, I think that reliance on more support code would not necessarily lead to better programming ability, nor a better understanding of the concepts of OOP.

In the future, cs15 could take a step forward by actually forcing the reuse of code or at least have projects contain more general elements which could be applied to future projects. I heard that last year instead of MoviePlayer, there were two Swarms, but that they didn't really build on each other in a way that would teach code reuse. I propose that a set of projects could be designed which contained general elements that could be used elsewhere.

For example, a part of a Swarm replacement could be a program which involved keyboard interaction with the user. The implementation of this interaction could be very general and portable such that it could be extended and put into Tetris with minimal effort. The way this sequence of assignments cloud work is that first a student build interaction object is used by a given GUI, much like in PizzaDex (but not so that everyone hates it like PizzaDex ). Then that object could be used in two other projects.

I think that the concept of code reuse is a good one and one that should not just be taught, but also implemented in an introductory course.

Code reuse is a great thing to think about when writing software. As I said in my initial reaction, CS 123 uses it quite effectively in my opinion. It would be great if we could figure out a series of assignments that built on each other, though it is important to note that this would be a major overhaul that I think is outside the realm of this ISP.

I agree that code reuse should be implemented to a greater extent in 15, but it also has to be taken into account that there's a log of material to cover, and perhaps using a "building blocks" philosophy isn't the most efficient way to get to all of it.

Also, the issue of design reuse and code reuse are almost interchangable. There was no _NEED_ to use a bee factory in swarm, but it sure made tetris easier.

Although there are a variety of backgrounds, I do think competent groups could be formed. Some people would find far more ease at programming than others and something would need to be done to reflect that but I think that each group could develop valid programs. I do think an alternative grading system would need to be devised.

The problem that tends to happen with making "extensible" and reusable code is that it is often very difficult to determine what aspects could be made extensible. For example, one reason that code reuse was not very well implemented with Swarm last year was that it was possible to build off of your Swarm I code for Swarm II, but only if you designed the Swarm I code in a way that worked with Swarm II. One possible answer to this would be to mention what things they should be thinking about when thinking about extensibility. However, I think that knowing how to make code extensible comes primarily from working on large projects, especially projects where you change the specifics part-way through the project. That experience is tough to teach or get across in an intro class.

Again, it is noted that this kind of instruction will not be great for introductory purposes. But should we really be focused on just what is good for introductory classes? Instead, I think we should note that there does exist some positiveness in bringing more real world like environs to the classroom.

What do group dynamics skills bring to an individual? What can they offer to him/her as a person, and not just as a computer science student. So often we narrow ourselves into thinking that education has to be about this specific topic or that specific topic that we forget that we are shaping an individual. If group dynamics can help shape an individual in a positive, though perhaps non-cs manner then I believe that should not be overlooked.