CS21A plans — education

Graphics IO Applet, interfaces

Arrays

searching, sorting, etc

Polymorphism already

From that point on, they can do games,
so games would be the final project

loop; they can kinda do threaded things. My plan is, Graphics IO
Applet, introduce them to interfaces, and then from there we go to
arrays. Then searching, sorting…

Swing?

Another project – Martin is playing around with this thing called
processing from the Media Lab. An environment for doing graphics.
Supposed to be friendly to non-programmers. Supposed to be easier
learning curve. It’s a little like Graphics IO Applet. In Graphics IO
Applet, you have to create an object. Here, you just override a method
and put all the draw commands. Possible project. Beef up and clean up
IOApplet and GraphicsIOApplet to be something like processing.
Processing builds up; you have a simple non-programmer way of doing
it…

http://www.proce55ing.net/reference/compare/processing_java.html

Framework. That’s going to be a little hard to think about…
Scaffolding.

Big picture – framework, pedagogical structure, modules

addButton returning a button, and then later on…

alice
designing the interfaces easy for a beginner to use
specifically for oop first programming

need public class
look at bluej, which is more of an ide/environment

dr. sarmenta doesn’t want a preprocessor. Mostly just things that they
extend or implement. We want them to learn how to use the compiler.

Unlike proce55ing, don’t hide the detail; expose it a little at a time.

Eric’s doing something similar with his class. He writes the code and
then they gradually replace parts of it.

Martin has the source code for proce55ing.

Front-end learning lab; they can upload their code and select from
different ones…

Each student writes his own class, and then someone ties everything
into a single thing.

The class takes an input, does things, and produces output. Filters;
that’s an interesting idea also. There are a lot of branches that we
can go into also in terms of design patterns. What I want to do now is
that if we’re going to discuss inheritance and polymorphism in CS21A,
and real AWT and real Swing in A, then we can free up the time to do
design patterns in CS21B.

(I miss my Twiddler!)

Maybe we can introduce patterns in CS21B by showing them patterns
they’ve done before. For example, listeners would be a case of the
observer design patterns. We should look into that. For example, given
a problem, this is how you can solve it… It becomes a pattern to
them even if they don’t know it. Cookbook. Delegation.

We need to be organized about our own patterns for teaching. Toward
the end, lecture on design patterns highlighting.
Problem-solving/cookbook based approach. _Intentional teaching._

Back to proce55ing. Design by numbers.

In the beginning, if you’re a graphic designer, then you’ll probably
go off into that from GraphicsIOApplet directly.

Standard version, movie-making version, python version.

The g dot whatever makes sense.

piece of paper passed around analogy

Magical thing about mouse listeners and instanceof