Feedback on csv-i from when students were frustrated

[JoshCheek]

When the students were frustrated with csv-i, I sat talked to them to better understand and address the issues. These are the notes I took.

To close this issue, look at each item and either turn it into a todo or decide it's not worth doing anything about (too unclear or too much work or not an issue)

---

#### "Difficult to track how all the objects were interacting with each other"

Another student suggested that a visual representation would be helpful.
In this case, we only have three classes, maybe we could come up with something.
At the same time, it's a skill they will have to learn, so they will get better at it over time.
But it's probably good to give them a strong model early so that they have a foundation to develop this skill on top of.

#### "Visual representations would be helpful"

I agree. Unfortunately this is difficult:
* Depending on how much you know, the way to represent an object graph may be different.
* There is not necessarily a common representation of an object graph. Perhaps the answer is that I need to explore UML more?
* Probably requires showing visually how the graph changes as we modify the code, so requires juggling and updating lots of images and so forth (tedious, easy to get wrong).
* Perhaps a tool that generates these? Maybe Rubinius + graphviz

#### "Felt like copying someone else's calc homework w/o having even taken arithmetic"

I don't think it's worth introducing "arithmetic", which is presumably some simpler code before this.
Aside from the class method, this is pretty simple (though probably they are comfortable accepting it and are more confused by the composition).
I think a better solution is to ease the transitions

#### "Jumped well beyond the current horizon of knowledge"

I feel like maybe we should remove the mock object? Downside is this requires us to implement the repository

#### like that there are more exercises at the bottom to apply the ideas to on our own
#### would be good if there was a "roadmap" at the beginning
#### big jump to go from copy/paste to "now go make your own"

Add in my high-level interpretation

play with TDD and object design
use an integration test to guide us
integration test gets the wiring into place (files/classes/methods)
now we specify all the behaviour and test edge cases with unit tests
introduces another object,a repository (doesn't really go into the reasoning about why)
separate out file reading from entry containment so you can intialize with just ary of hashes
create entry data structure
when low-level tests pass, go back to high-level test for guidance about what to implement next
This leads us to write a test for looking up by first and last name
and then finally reverse lookup

Maybe reassure them when we do the big jump, that it's okay that they wouldn't have thought of that

[kytrinyx]

This is so fascinating!

"Felt like copying someone else's calc homework w/o having even taken arithmetic"

CSV-I was supposed to be the arithmetic.

Last year we jumped straight from Ruby in 100 Minutes via a couple of play-along tutorials to writing a REPL that connected a gazillion objects, and then we piled on with the SalesReporterEngineManager, which is essentially csv-i times 100.

I'm taking this to mean that we're getting closer if they're able to express actual, specific concerns like the above.

"Difficult to track how all the objects were interacting with each other"

How about spending more time at the whiteboard drawing boxes and arrows? They need to be able to think about this on their own, but perhaps you can use Halloween and Mythical Creatures and other toy problems to make them practice drawing diagrams? Perhaps you can create some common patterns and have both the toy code and the drawn-up pattern that they can relate it to, and then it's more of a problem of matching their new problem to an existing pattern that they've seen before. It will quickly go beyond the basic patterns that they've seen, but it might be enough to bridge the gap.

"Jumped well beyond the current horizon of knowledge"

Again, that's fascinating. I was really trying to capture that horizon with CSV-I. I feel like removing the mock object introduces a bad habit right off the bat. The first two groups were doing so many testing anti-patterns (lots of duplication, lots of testing all the way through the stack, because they didn't understand how the pieces connected).

Would it help to draw pictures? What if the problem is broken down into a metaphor... squirrels moving peanuts from their hidey holes in Grandma's garden to their stash in their tree. Or some other silly thing that makes it easy for them to think about it in terms they're familiar with.

would be good if there was a "roadmap" at the beginning

Yeah, I'm terrible at roadmaps. That would be helpful.

big jump to go from copy/paste to "now go make your own"

Wait, what? Each of the 5 CSV exercises provide less and less boilerplate. Where's the jump? The second exercise you can basically go back through the tutorial, change a few names, and you're golden.

play with TDD and object design

This would be great. I haven't thought about what that would look like, but I think it would be incredibly helpful.

use an integration test to guide us
integration test gets the wiring into place (files/classes/methods)
now we specify all the behaviour and test edge cases with unit tests

Yeah, definitely. I started playing with aruba as a REALLY high-level integration test where it doesn't matter how you actually structure the code, as long as the output is right. That can have downsides, though.

introduces another object,a repository (doesn't really go into the reasoning about why)

Should we simply add some reasoning here? I'm torn. They probably don't have enough context to understand the reasoning. On the other hand, if we don't introduce the object, then we're going to end up with anti-patterns that they're going to follow forever. Especially since Rails is full of them :/

separate out file reading from entry containment so you can intialize with just ary of hashes

I can't tell if you're saying we do this already or that we should do this (I can't recall, it's been a long time since I wrote these). I think we should.

Maybe reassure them when we do the big jump, that it's okay that they wouldn't have thought of that

Well... yeah. That's why they're in the course. Programming has a bunch of things that you wouldn't think of ahead of time, but that start making sense after a while.

Sorry—I was just thinking out loud here, I don't have any real TODOs to suggest.