Showing posts with label learning. Show all posts
Showing posts with label learning. Show all posts

Wednesday, January 28, 2026

An overheard comment about the importance of knowing

Earlier this semester in my game design class, I overheard a student say to another, "If you don't know much, you won't be able to think of something."

He's right, contrary to the philosophy that believes that students don't need to learn facts because they can look them up.

Saturday, February 1, 2025

The Goal of Higher Education: Remarks at the BSU College of Sciences and Humanities Dean's Honor Reception

By virtue of receiving the inaugural Teacher of the Year award from the College of Sciences and Humanities, I was invited to give some remarks at the Dean's Honor Reception. The reception is later this morning, and these are the remarks I intend to give. I will be working from notes, not this written form, so the precise delivery will certainly vary, but these are the main points. Also, the original title for the talk was "The End of Higher Education," which was a pun on the two meanings of "end," but it was softened to "The Goal of Higher Education."

EDIT (Feb 2): The talk was well received. I have edited my original post to contain a few turns of phrase that I used spontaneously at the time.

In preparation for this talk, I read through two of the notebooks I keep whenever I read a book. It was purely delightful: it's like someone wrote a book that contained only things that I find fascinating, inspiring, or challenging. I hope that you also keep notes when you read. It will bring you joy to read them later.

I searched my notebooks for an answer to the question, "What is the goal of higher education?" I am sure you have your own answers, perhaps dealing with careers or impact on the world. In the Republic, Plato asserts that the goal of higher education is to love what is beautiful. I think he's right. 

You might ask, "How do we come to recognize beauty?" I put it to you that beauty is already there, that it's a transcendental property of the world around us. The question then becomes, "How do we fail to recognize beauty?"

In The Lord of the Rings, Gollum was not free to recognize beauty. Gollum could only see the One Ring. Because he was distracted by this created thing, he was blind to the beauty around him. He elevated this created thing beyond its station, and this led to his downfall. Tolkien scholar Joseph Pierce talks about how we can all become Gollumized. We can become so distracted by things that we fail to see beauty.

German philosopher Martin Heidegger wrote that we are not free if we believe that technology is morally neutral. Heidegger recognized that humanity has always used technology, but he said that we are not free if we think of this technology as neutral. Take the humble hammer as an example. With a hammer, I can pound nails, but remember the old saying, "When all you have is a hammer, every problem looks like a nail." It's true. The hammer has moral agency. That is to say, the hammer affects the moral decision space that you are in. With a hammer in hand, striking things with it becomes an option. The hammer has moral agency. How much more so the smart phone?

Canvas is a technology. Canvas affects your moral decision space. Canvas color codes your grades so that you "know how well you are doing." Canvas gives you notifications, so that you stop what you are doing and pay attention to it. Canvas gives you confetti when you turn in work on time. Beware. Larry Muller, in his brilliant book The Tyranny of Metrics, writes about how the calculative is opposed to the imaginative. 

How is one to recognize beauty while tempering the calculative? I have time to share with you three stories.

My friend Dannie was an undergraduate architecture major here back in the 1990s. He asked one of his professors, "How am I doing in this course?" expecting a quantitative answer. The professor took out a piece of paper and, along a line, drew an egg, a tadpole, and then a frog. He pointed to a spot on the line and said, "You're about here." Now that is a midsemester grade!

Last weekend, I ran Global Game Jam here on campus. This is an event where people get together and, in 48 hours, create original videogames. We had over 40 people attend, mostly Ball State students but also students from other places as well as community members. There was no judging, there were no grades, there were no prizes, there was no competition, yet at the end, we had made eight original videogames, which are now available to the world for free. We made them for the joy of creating them and the pleasure of sharing them. This event is a global event, and all together, this community created over 11,000 games, just for the sake of beauty.

I regularly teach a required sophomore-level programming class. In this class, I use a system called "achievements", inspired by video games, that let students earn course credit by doing things that are outside the normal course expectations. One of the options is called, "Detox," and it requires a student to go 24 hours without looking at a screen. Every semester, a few students try it, and the beauty of their essay responses would make you weep. Students have told me how they walked across campus and really heard the birdsong for the first time. Others write about how they reflect on their life, how they got to where they are, and their hopes and dreams. My favorite story is of a student who, instead of doomscrolling on Instagram, took her grandmother for coffee. There is nothing better than that.

I put it to you that beauty is all around us—well, unless you work in the Robert Bell Building, like I do, but we're doing our best. 

Look at the people on stage here. They are beautiful. Look at the people sitting next to you or behind you. Really! Do it! They are beautiful.

Speaking for myself, I don't care what grades you get. I want you to find your One Ring—because we all have them—cast it into the fire, and then join me in life's great adventure of loving beauty.

Saturday, March 19, 2022

A student discovers the vacuousness of midsemester grades

Midsemester grades are epistemologically invalid. Yes, you can compute something but it doesn't mean anything. At midsemester, every student's grade ought to be an 'F' since they have not finished the course. Aside from that, any faculty worth their paycheck should be giving student enough feedback that they know how they are doing, what to do to improve, and how to get more help or practice. At Ball State, a rule was passed a few years ago that we have to give "midsemester grades" in all classes. Par for the course, nobody actually defined what "midsemester grades" mean.

At midsemester, I threw my students' grades into a spreadsheet blender and dutifully keyed the results into the terrible Web database interface. Because I use a form of mastery grading—where students can resubmit work until it receives full credit—it is not uncommon for students to have an F or a D at midsemester and end up with a B or an A.  Furthermore, the majority weight of a student's grade comes from work in the second half of the semester. I made an apologetic announcement on Canvas about having to file midsemester grades, explaining exactly what I did, that it should contain no surprises, and suggesting how students interpret their status. (It turns out, explaining to someone how to achieve their goals is the actual solution to the problem that the university is trying to solve through midsemester grades. The process is human and personal, not quantitative and automatic. No one should be surprised by this.) A few students expressed concern about their midsemester grades, but not many, which I take as an indication that perhaps a majority read the Canvas announcement. A professor can dream, anyway, since the alternative is despair.

But none of that is my reason for writing today. The previous two paragraphs provide the backdrop my tale. Pardon the metadiscourse.

As I explained in early January, I introduced a new achievement into CS222 this semester. Tool-Maker is earned by "satisfying your obsessions," and more particularly by doing the following.

Write a program to compute a student's grade in CS222 based on the policies described on this course site. You may use any programming language or environment that you like, but you must follow the practices of Clean Code.

I know of one student who is pursuing this achievement, and he has been working on it on and off for a little while, sending me occasional questions to clarify policies described on the course site. Today, he emailed me such a question. He asked whether the tool should compute one's grade as if there are no future assignments or whether it should compute one's grade and counting future work as zero.

Exactly!

He stumbled directly into the midsemester grade problem. He did not mention if his question was based on memories of my Canvas announcement, and so I suspect he simply ran across this as he tried to know whether his tool was correct or not. I told him that either way was fine with me. Practically speaking, I don't care, because the two goals of the assignment are to understand class policies and to get practice with Clean Code. My scholar sense tingles, however: once he has completed the work, I will have to ask him why he chose the path he did. One of them may simply be easier than the other, and I couldn't blame him for taking that one. However, he may make his choice based on perceived usefulness, and which model he finds useful might be a tasty bit of insight.

Tuesday, February 15, 2022

Right and Wrong, Well and Poorly, and the Art of Programming

Writing, painting, drawing, acting. These are arts that you cannot really do wrong, but you can do poorly. If a student writes a weak, unstructured, meandering essay, a good teacher will have to tell them that they did it poorly. A less dedicated teacher may decide not to give such feedback or even to lie that the work is good. Remove the feedback system, and the author will have to draw conclusions about their writing for themselves, subject to all the usual bugaboos like impostor syndrome and the Dunning-Kruger effect.

Programming is different. You can do it poorly, but you can also do it wrong. If your program does not compile, it is not really a program at all. That is, the syntax of a programming language determines what constitutes a valid program, and if you don't have valid syntax, you only have an approximation of a program. You have a non-program. Once you've done it right—once you have something that is, in fact, a program—only then can you consider whether you've done it poorly or well. Put another way, you cannot even program poorly unless you have programmed.

This puts learners of programming in a unique situation in education, as far as I can tell. The closest relative may be poetic forms like haiku. If someone walks up to you, shows you four lines in iambic pentameter, and asks, "How do you like my haiku?" the only real answer is that the question is malformed. It is not a haiku at all. If someone hands you a bunch of monospace text and semicolons and asks, "How do you like my Java program?" then unless it compiles, all you can say is that it is not a Java program at all.

Proofs and philosophical arguments are interesting to consider. For these forms, each step should follow logically from the previous. Consider what happens if a nascent mathematician produces a "proof" but the steps do not logically follow from each other. Is it a wrong proof or is it not a proof at all? That is, can a proof be wrong? I think most mathematicians would agree with me that it is not a proof since the question remains unproven. Notice, though, that in the absence of an evaluator, or in the presence of evaluators' inevitable oversights, a learner may not recognize the distinction. This can be addressed by formal theorem-proving systems, which are, essentially, programming.

It seems then that computer programming is the best tool for teaching someone that truth exists. Without the intervention or explanation by a teacher, a learner can see that some things are programs and some things are not.

Recently, I asked my students to evaluate their accountability to a team with respect to a stated methodology. Several students presented arguments in this form: (1) I followed the methodology. (2) There was one part I didn't follow. (3) In conclusion, I followed the methodology. This kind of intellectual dishonesty pervades undergraduate writing and thinking, although I cannot tell if it is getting worse or if I am getting tired. The compiler doesn't care how much I want the text in this file to be a Java program. It won't take sympathy on you, it won't tire of reading, and it won't lie. 

Monday, January 24, 2022

Book Recommendations for Computer Science Goodness

 

A student emailed me the other day to ask about what books I would recommend they read for some "computer science goodness." They asked about books that I enjoyed and books that shook up how I thought about the field. I could have sworn I wrote a blog post about this in the past. Turns out, I wrote a post in 2016 about books that influenced my teaching practice. I was a bit surprised to find, on searching my blog, that I also wrote a post in 2011 about books that influenced my teaching practice. It's hard to keep these posts DRY.

My list here has some overlap with those other two lists, since a good book will often be multifaceted. Here's a quick list of titles that come to mind with very brief descriptions of why I like them. I've included links to sources or storefronts for reference; I don't make any commission on these. Since I don't have any other real ordering to the recommendations, I've provided them in alphabetical order by author.

  • Alistair Cockburn. Agile Software Development: The Cooperative Game. This book lays out an operationalized definition of what software development is: a cooperative game of invention and communication. It helped me think more specifically about the intersection of my knowledge of software development and game development. It also gives a good grounding in what "agility" means beyond buzzwords.
  • Allen Holub. Holub on Patterns: Learning Design Patterns by Looking at Code. While the original GoF book is undeniably influential, this is my favorite book on design patterns, since it shows how they occur in practice: nested within each other and inside of meaningful contexts. The book is showing its age, and I'd love to see a second edition that uses more modern language features. That said, the first chapter is one of the most brilliant essays on the meaning of OOP.
  • Andy Hunt and Dave Thomas. The Pragmatic Programmer. This is a classic book of good, practical, generally applicable advice for writing high-quality software.
  • Robert C. Martin. Clean Code. Amazing book about how to write high-quality software. The student who emailed me should have already read this, but I'm including it here for completeness' sake.
  • Peter Seibel. Practical Common Lisp. Like a lot of people, I was intrigued by Lisp when I learned it—and when I taught it! But I never quite understood how you would use it to build something substantial, something that wasn't just a classroom toy. This book explains not only that, but why macros and metaprogramming really are the cat's pajamas.

Tuesday, January 18, 2022

Writing tips are a surprise (CS222 Spring 2022 Assignment 0 Notes)

As I mentioned in my previous post, I rearranged the first three weeks of CS222 assigned work into six assignments. Part of Assignment 0 involved reading and responding to portions of the course plan. I did this with a quiz in the past, but now it was rolled into a larger "Assignment." I still feel like quizzing students over the course plan represents further infantilization of college students, I also can't deny that I've had less confusion around the policies in the course plan since grading student work about it.

I have spent significant effort over the years curating my Tips page, but I had never previously required students to ever engage with it. Sure, I encouraged and cajoled, but there was never anything graded that came explicitly and solely from that page. I changed that this year by adding a question to Assignment 0 asking students, "What surprised you on the Tips page?" 

There were a range of answers. A few students aid that while it was good advice, nothing there surprised them. Others mentioned that the presence of the page at all, or its attention to writing, were surprises. A few students referenced the checklists, indicating that they were thinking ahead to how they will know if they are doing what is expected in the future.

My favorite responses were those that referenced George Orwell's writing tips. The tips page includes a quotation from George Orwell's 1946 essay, "Politics and the English Language." It is a masterful essay, and you should take a few minutes to read it. While only a few students referenced it as surprising, one student was particularly clear* in their response, writing, "George Orwell's tips surprised me the most because they are just about the opposite of what I learned in probably every English class I've ever taken." In my feedback to this student, I indicated that I would love to hear more about this, but that's the kind of thing that rarely receives notice from students, much less a response. Perhaps I can use it to engage my classes in person, however, in those few awkward minutes between when I get myself set up and when the meeting begins.

* My first draft used the phrase, "hit the nail on the head," but then I realized that this violates Orwell's first rule.

Friday, December 17, 2021

What we learned in CS222, Fall 2021 edition

Welcome back to the "What we learned in CS222" series. As part of the final exam in this course, students participate in a divergent thinking exercise in which we list off what we learned during the semester. Then, in a convergent exercise, each student gets a number of stickers with which to vote for the ones most important to them.

One thing that was a bit different this semester was that, in a fit of distraction, I forgot to set the timer. We came up with this list of 129 items in roughly half an hour, but it was only roughly timeboxed. Another first was that one student misunderstood the instructions, marking the sheets that were most important to him rather than the items. We all had a good laugh about this, but it does mean that his votes may not have actually ended up where he wanted them; some were off on the side clearly not marking a specific item, but others were near enough to text that they were indistinguishable from legitimate votes.

The other unique element this semester is the answer to the question you might have from looking at the list below: Who is Jack? Jack is a Computer Science student who was not in my class but had better attendance than several students who were. Jack was enrolled in a separate section of CS222, taught by one of my colleagues, so he was studying similar material. He had a class in the room immediately before my class, so he regularly would just stay sitting with his friends who stuck around for my class. It was the strangest thing: I've had plenty of students sign up for a class and not show up, but I've never had someone not sign up but come. Maybe someday he'll shed some more light on his experience attending both classes. The only time I asked him about it specifically was on the last day of class, after my students had presented their final projects. I asked him which section of the class had better projects. He thought a moment and told us about some of the visually compelling projects in the other section, which he thought were more impressive, but added that my students probably had better code. I'll take what I can get.

Without further ado, here is what the students said they learned.

Refactoring6
Team Coordination5
OO Design4
User stories4
OO Decomposition3
Clean Code Formatting3
TDD3
SRP3
Readability3
Git2
Code Review2
GUIs2
Whiteboard programming2
Jack2
Kembel's design thinking2
Software craftsmanship2
Testing with coverage1
Version control1
Pair programming1
Naming conventions1
APIs1
HTTP requests1
Debugging1
SMART goals1
Branching and merging1
CRC Cards1
IntelliJ IDEA1
Functional Decomposition1
Accessors & Mutators1
User experience (UX)1
Backlog1
ImageView1
Iterations1
View and model layer
JavaFX
Flutter
Web queries
Parsing
JSON Data
Waterfall
Methods & objects
Short methods
FIRST testing
Aliasing
Defensive copies
Deep copies
Scrum
Event-driven programming
Multithreading
Encapsulation
Dreyfus Model of Skill Acquisition
Copyright laws
Licensing
Human Success & Failure Modes
Rubber duck debugging
Pragmatic Programmer
RCM "Uncle Bob"
Retrospectives
Conditions of Satisfaction
Red-Green-Refactor
Acceptance testing
UI templating
Binding (UI)
"God" classes
Packages within project
Dependencies
Gradle
Java 16
Documentation
Environment replication (machine independence)
IDE
Principle of Least Astonishment
Comments
Commit messages
README files
Polymorphism
INheritance
Elegant code
Abstraction
High-level languages
Exposure of sensitive data
Leaky abstraction
API etiquette (user agents, frequency of use)
Testing protocols
Task Lists
Butter dish
Hyperlinks
GridPane
ScrollPane
HBoxes and VBoxes
ChoiceBox
Buttons
Desktop (class in Java)
Inner classes
Holub on Patterns
OO Road simulation
OO Bank example
Risk matrix
History of computing
When is a feature complete?
Machine Learning
Mearns Bux
Assignability of tasks
Try-catch (error handling)
IOExceptions
Stack traces
Stack overflow
Weak warnings
Compiler errors and warnings
Runtime errors
Edge cases
Test before commit
Interfaces
Engines
Run configurations
Class implementations
Abstract classes
Making stuff static
Equals and hashcode
Hashmaps
Depend on interfaces, not implementations
Don't program your own time API
DRY
Import optimization
IDE tools (e.g. format, extract method)
Functional programming
Presentations
Slides
power points

After we closed the discussion, a student pointed out that Clean Code itself was not listed. I had noticed that but didn't say anything. I suppose it's another indication that this was a semester unlike any other, which point foreshadows my upcoming reflection post.

Wednesday, January 13, 2021

Reflecting on almost a year of FamJams: What the family learned

I will be giving a presentation at GodotCon 2021 entitled, "(Almost) A Year of Fam Jams". The presentation will be a summary of how my family started doing game jams together and what we learned from the process. It draws liberally from my blog posts on the topic. The presentation is already recorded, and the conference organizers will set up a time that it streams, during which time I will be online to answer questions.

In preparing for the presentation, we had a family meeting in which I asked everyone what they learned over the past year and what advice they would give to someone who wanted to start fam jamming. This was an interesting exercise, and one thing that stood out to me was that some of them were happy to give advice that it wasn't clear they themselves had learned yet. "Do as I say, not as I do" is a powerful human capacity! I hope they understood when I pushed back on these points, because I wanted to make sure I distilled our true and best ideas for the presentation.

I took more notes from this meeting than I could fit into the presentation. This blog post gives me a chance to share my notes more exhaustively. I will start with the youngest family member and move up from there. I believe this order might be enjoyable and also demonstrate the differences in ability to form abstractions and conclusions. I have listed the items so that the first statement captures the essence of what the family member shared, and then I provide my commentary on that item after that.

#4 Son:

Put the game's name on the title screen. This was one of the first things anybody said in response to my question, and it made me laugh. He's right! We do always put the name on the title screen. Now, it's less clear to me that he understands the value of this in setting the expectations of the player or conveying the theme, but that will come.

Make sure everyone can work at the same time. That is, he recognizes that we don't want to be in a position where anyone is "busy-waiting", such as waiting for access to a particular machine or resource. Astute!

#3 Son:

Use the black keys when composing music. Readers may recall that this son is very interested in using LMMS to compose music for the games, and I showed him many months ago that he could avoid some dissonance by using only "the black keys" to get a pentatonic scale. He's latched on to that, and his compositions have been more ear-friendly for it.

Make the game's music match the theme of the game. This is a great observation, and I think it first came up in Get the Food. We definitely came back to this idea in other games, too, including Find the Ornaments, where we talked about what might make a song sound like the holidays. (Also, I don't think it only comes in games titled Verb the Noun, but more data may be required.)

#2 Son:

Have someone who can do everything that needs to be done. His point here is that you don't want to have three people who all want to write the music for the game and nobody who wants to do art. It's an interesting perspective, since I tend to think about it the other way: design the game such that it leverages the abilities and interests of the people involved. In fact, my wife brought up this point in response. Both sides are true, and I'm glad he brought it up.

Playtest with people who didn't program the game. He has noticed that if his older brother and I work on the programming, we might sometimes have blinders to things that are wrong or just feel bad. Again, this is a pretty astute observation. At first, I thought he meant people outside the family, but he really just meant that people inside the family should be giving feedback during the whole production process. 

Leading does not mean you tell people what to do and wait until they are done: it means you check in with them and give them advice. This is an amazing point, and I remember that he struggled a bit with it the first time he was creative director. I think it was something like his telling other people to work and then his sitting down with a book. He got the idea, though, and we worked through it. Now, he is much better about communication, negotiation, and critiquing. 

#1 Son:

Prototype the gameplay with blocks. That is, don't get caught up in producing and perfecting the minutiae before you get the big ideas working.

It's fun to make different kinds of games. I couldn't agree more!

This son also mentioned something that may seem pedestrian, but it's really not: how to use Godot Engine. He's become quite accomplished with it, to the point where he can navigate the documentation and forums and figure out pretty much anything he needs. Right now, he's looking into networked multiplayer games; we had a good talk about IP addresses on our family walk yesterday. 

Lovely Wife:

Do drawings in pen or marker—not pencil—for ease of cropping and scanning. She has spent a lot of time post-processing the kids' hand-drawn artwork, and this is a nice, easy pro-tip.

Even though each game is different, there are certain things that you always need, such as fonts. I sometimes forget that, coming into it, my wife really had no idea how video games were made. That is, just because someone is smart and my age and played some video games doesn't actually mean they know what goes into the engineering of them. Now, she sees the patterns that I took for granted, like the idea that there are certain elements that you always expect to be on the to-do list.

We face challenges sharing workstations, and it's better to have each person have easy access to their own machine. She and I have tried to manage the proliferation of devices in the household, and we don't have a one-laptop-per-child policy. We have Old Lappy and New Lappy. Sometimes, this is not quite enough, and we're still trying to figure out the best way to manage all the technology needs and desires.

It is useful to follow genre conventions. Our first game was designed by a five-year-old and defies expectations, but after that, we moved more into conventional forms. This has been helpful for allowing everyone to imagine what the end product might be. It also has become easier as we have learned more about the tools themselves, since the tools are designed to help with common problems.

Determine your screen-size early. We had some mismatched expectations in our early jams about how to manage the size of screens, in part because the programmers saw this as flexible but the art production required it to be fixed. Now, we set the screen size early on, which means the prototype programming matches the expected final look, and the art comes in without needing to be resized multiple times.

Use drawing templates for young artists. As of The Flying Planes, we have been focused on trying to get more art into the games. In theory, this is simple: if we can put in one plane, then we can put in several. In practice, the kids drew them in all different shapes and sizes, which made it hard to get them all to fit and look right. Now, if we know something is to be mass-produced, she provides the kids with a rectangular template, which is really the bounding box. This makes it easier to scan and process as well as to integrate into the game itself. 

Determine a palette early. This is a standard graphic design idea of course, though it's not something most kids (or maybe anyone?) thinks of. The games that have had constrained palettes are certainly easier on the eyes. Maybe this would be a fun area for us to grow with the kids, allowing them to explore palette creation and see how they affect the look and feel of the game.

Final Thoughts

It was fun to go back through these notes. If you got here from watching the GodotCon video, in which I acknowledge that I would probably have to write a blog post to get all my notes together, I hope you enjoyed it! As always, please feel free to leave a comment, especially if you have some tip of your own to share with the community.

Monday, July 13, 2020

Answering questions about effective online learning

I was asked, through the grapevine, to provide some insights into online teaching and learning. The answers are being compiled into an article directed at parents of first-time college students. In the spirit of no wasted writing, I decided to write up my answers here.

Question 1: From your experience during the Spring semester, what approaches to online learning taken by students seemed to be most successful for them?

I want to preface my answer my saying that both my Spring courses were team-oriented, project-intensive courses. We had a great advantage in that the teams were formed before the pandemic forced campus to close. I am planning to do less team work than I normally would since it is so hard to mentor distributed teams as they learn fundamental technical and social processes of collaboration.

A common feature of my most successful student teams was that they maintained a regular schedule. They all had this before the pandemic, and many of them carried that schedule forward as classes moved to purely online. They established regular meeting times, generally between three and six hours, during which times all team members were expected to be online and working on the project. Some used Zoom audio or video meetings during the whole time, while others used Discord or Slack, switching to Zoom audio or video calling when text was inadequate. Because the whole team was online at the same time, teams were able to clear up communication quickly, before issues festered and became social and technical problems.

The most successful teams combined synchronous distributed meetings with asynchronous, persistent chatrooms—either Slack or Discord. This gave a place where they could pose questions, provide links, encourage each other, and otherwise socialize outside of their scheduled meeting times. In the cases where I was invited to join and participate in these discussions, I definitely saw the best students doing all four of those things. The impact of peer-encouragement on these forums is not to be underestimated. When students took the time to give each other a little virtual pat on the back, it clearly and directly contributed to a higher morale, better learning, and increased productivity.

Students and teams who reached out to me for help had much better results than those who didn't. This should come as no surprise, as it's the same for in-person classes, but it also should not be discounted. I could answer easy questions over email, and anything more involved could be done through a video chat—ideally with the whole team. In a normal semester, I would set up face-to-face meetings for this purpose, but video chat actually proved much easier, and I plan to keep this tool on my toolbelt moving forward, regardless of instructional mode.

Question 2: Conversely, were there certain approaches to online learning on the part of  students that caused them difficulty or led to unsuccessful outcomes?

After campus shut down, a few of my student teams decided to take this as an opportunity to relax their schedules. Rather than meet together to work on the project at specific times, they divvied out responsibilities and asked people to work whenever they felt like it. This led to the unfortunate but seemingly-inevitable consequences of miscommunication and confusion, which then resulted in mistrust and poor performance. Briefly, every team that relaxed their schedule of meetings regretted it.

Incidentally, if you ask any undergraduate what the worst part of college is, the answer is "group projects." There are many reasons for this, and they include that we don't do well, institutionally, at teaching students how to work in groups. I had an upper-division class in Fall 2019 in which we had a powerful heart-to-heart conversation in which the room of students admitted they had never been on anything than a dysfunctional team in any school experience. That is, working on a team is not just intrinsically hard: the students also have no tacit or mental model for what positive collaboration looks like.

Coming back to the question, another problem I saw was students' using familiar tools rather than effective but novel tools. Discord vs. Zoom is a great example. Many students use Discord for online gaming, and since they are familiar with the tool, it becomes a natural choice for them when deciding on how to work together as a team. Discord even recently added screen-sharing, so that you can see what a teammate is working on. However, this is like streaming on Twitch: it's a one-way stream, in which one person is working and others are watching. Contrast this against Zoom's Screen Sharing feature, in which anyone on the team can actually drive the host's computer. This leads to real collaboration rather than simply passive or voyeuristic participation. In almost every online team meeting in the Spring, a case would come up where someone in the conversation (often me!) would take control of the screen and type in a few characters to explain a concept, or steer the mouse to demonstrate an interaction. This gives a similar affordance to sitting together in the lab or in office hours, temporarily "taking the wheel" to demonstrate something, as compared to the passive-consumptive stream approach, which as no affordance for collaborative work.

An important point about this is that some of my teams continued to use Discord even after I pointed out the problem or, in one case, mandated the use of something else. The team's inertia and pride kept them from learning about a better solution to their problem. I suppose what we see here is that the root cause is not the tool but the pride, but that seems to be always how it is.

Question 3: What are some tips you can offer students about how they can make the most of online learning and have the most successful outcomes?

Students are in many ways at the mercy of their instructors. The frustrating truth is that it can be hard to get faculty to make the most of learning toward the goal of successful outcomes. Because of this, students need to be careful consumers. To the extent possible, see what you can find out about the courses you want to take. See if you can infer from the designs that this is going to be good learning experience, based on the objectives of the course and the interactions designed for them. Personally, I keep all my course plans public and online, but I suspect I'm in the small minority there.

Advice that is easy to give and hard to swallow is be conscientious. Conscientiousness is highly correlated with academic success, and no matter how conscientious you are, you can always take action to improve. I think the most accessible way to do this is to set up a schedule for a week, see how well you can follow it, and then actively reflect on the differences between what you had hoped to do and what you did do. Nobody is going to make you do this reflection, but that is where the real learning happens.

It's also important to keep in mind a few core principles of effective learning, such as I wrote about in my notes about the excellent Make It Stick. These principles are not about success in college so much as how to become an effective lifetime learner. Ideally, these things would align, but in practice, they don't always do so. I'll repeat my quotation here from Chapter 8 of that book, which provides a great overview of the mindset of effective learning.

  • Some kinds of difficulties during learning help to make the learning stronger and better remembered.
  • When learning is easy, it is often superficial and soon forgotten.
  • Note all of our intellectual abilities are hardwired. In fact, when learning is effortful, it changes the brain, making new connections and increasing intellectual ability.
  • You learn better when you wrestle with new problems before being shown the solution, rather than the other way around.
  • To achieve excellence in any sphere, you must strive to surpass your current level of ability.
  • Striving, by its nature, often results in setbacks, and setbacks are often what provide essential information needed to adjust strategies to achieve mastery.
Finally, my advice to all learners is practice intellectual humility. Listen to other people as if they know something you don't know, because they do. 

Sunday, June 28, 2020

Fam Jam #4: Get the Food (and a few words about #3)

I will start with a few updates. We did do a Fam Jam in May, but I did not write a blog post about it. #2 Son surprised us by wanting to create a game around mechanisms of practicing arithmetic, and the result is Math Traps. It was a fun jam, but perhaps the most interesting part is how excited #3 Son was to make the soundtrack using LMMS. I also recently put together a public-facing page for the family's github organization. http://the-g-force.github.io/ shows all of our fam jam games.

Now, though, I turn to the main focus of this post: your June Fam Jam.

The Jam was yesterday, and we all worked together to create Get the Food. The game was the second one for which my youngest son (5) served as creative director, his first being Joe Johnson Gets Captured from our first jam. We decided to give him the reins once more rather than moving up in age order, since my oldest son is really already capable of building pretty much anything he can imagine.

It was a kind of difficult to get the youngest to focus in on an idea during our morning meeting in the living room. He started by describing a guy who goes through a magic portal to a campground, and he has to avoid the traps in the tents. Then he gets on a motorcycle and goes somewhere, I cannot remember. Also, he's fighting bad guys, and also he fishes. I'm pretty sure he just unwittingly designed a Zelda game. In any case, we tried to encourage him to rein it in, to focus in on one idea that we could all get behind. The fishing idea seemed to get some traction from the family, and in the course of the discussion, it changed from fishing to being a fish.

#2 Son was excited to apply his recently-developed skills with Piskel to create pixel art. His first fish was created before we settled in on the right screen size, and it was a frustrating conversation to point out that we had our cart before our horse. Once we got the screen size sorted, he made all three animated fish that are in the game.

#3 Son was very happy to work on the soundtrack. His first pass was very busy, with a lot of pasted blocks between tracks. That is, he would lay down something like a bass track and then copy that to the drum track and another bass track, just playing them at different times. It's not all bad, but it's very busy. I worked with him more yesterday than in the past, trying to help him understand a little bit more about composition. In particular, I tried to show him that most instruments just hit one note at a time, especially things like the bass. At one point, I pulled together a simple set of five tracks and challenged him to write something where none of them hit more than one note at a time. Somehow, however, he lost this file or something, since when I came back to where he was working, he was doing something completely different, with some instrument patches I would not have chosen for an underwater game. We worked a bit more, with me trying to encourage him to move notes just to the white notes, in hopes we could at least get something in C Major. It was during this process that I had an epiphany: instead of encouraging him to put everything on the white notes in the piano roll, why not encourage him to use only the black notes? The result would be a pentatonic scale, with significantly less opportunity for dissonance than without this constraint. We were both happy with this result. If you listen to the main theme of the game that plays in the background of gameplay, it is all pentatonics (after I helped him move a few errant tones to the black keys). The theme that plays on the title screen is an excerpt from the first piece he wrote that morning.

#1 Son, as mentioned earlier, has become fairly adept with Godot Engine. The code that he writes is still pretty messy, though, with names that don't always match functionality. He also makes amateur mistakes of perspective. We had an interesting conversation around the relationship between the player-controlled fish and the aquarium scene. I suggested that, instead of having the Aquarium script manually move the player fish around, instead we just have it tell the fish where the player touched. He said, "That sounds complicated." I responded that his perspective was upside-down. Coupling the player-controlled fish to the aquarium was complicated, but putting the fish's behavior into its own script was simpler. There's a sense in which we are both right, and it's just a matter of experience and its concomitant wisdom. Using my approach, though, I explained how we could then reuse this fish behavior in our enemy AI: both the player-controlled and AI-controlled fish had behavior determined by having a destination specified, but it was only a difference of who specified the destination.

We ran into a strange problem late in the game development. #1 Son and I had set up what we thought was a robust approach that would allow for easy adding of different kinds of enemy fish. However, when we got the new art from #2 son for the second enemy fish, it was a different size than the other. This meant that it needed its own collision shape, so we ended up making it a subclass of the original enemy fish. It felt to me at the time like switching to a delegation rather than inheritance approach would be better, but it wasn't clear that we could make this change fast enough for a jam. This approach worked, but we also had trouble that I still don't completely understand. The second fish was not detecting the flakes, but it seemed to have to do with its proximity to the bottom of the tank. We never did figure it out, but #1 Son came up with a workaround that involved using multiple physics layers and masks. Honestly, I struggle to think through the layers and masks system—it is not intuitive to me, so I was grateful that he was able to come up with a workable solution.

I hope you enjoy the game. We went for a nice family walk when we were done. Everyone shared something they learned during the day, and then I also asked each person to share either a question they had or something they wanted to try next. It was a fun, casual reflection session. I also mentioned to them that we could try a different jam format, such as giving everybody the same assets and seeing what they can make with it. #1 Son is adept with Godot Engine, and #2 and #3 can both use Construct. #4 Son and my wife would be left with paper prototyping perhaps. The big idea, anyway, is that I think they're excited to keep making things together, and maybe to try some different modes. Of course, I think #3 is just waiting for his chance to be in charge again so he can draw from his love of rockets and enjoyment of Totally Reliable Delivery Service.

Tuesday, April 28, 2020

What We Learned in CS222: Spring 2020 Edition

For many years now, when teaching CS222, I have started the final exam by having the students make a list of what they learned. This small, reflective, timeboxed exercise is conveniently executed during a conventional final exam slot, and we normally then transition to compiling our lists. This compilation process starts out with students simply reciting what they have on their lists, but inevitably, one person's comment spurs the memory of another, and new ideas emerge that were not written down. It also can get a bit silly, in a very good way.

I wanted to keep as much of this exercise in tact as I could despite the closing of campus. I ended up creating a final assignment for the students, due on the last regular meeting day of class, in which they each had to post a list of what they learned to a Canvas discussion board. Canvas discussion boards have an interesting feature in which you can prevent students from seeing others' posts until they themselves post, and this seemed the right option for the assignment. The result is that each student got to share an unadulterated list for their classmates to see. Unfortunately, this lost the fun of compiling the list together, but at least it got the reflective part.

I went through all of the posts and compiled a spreadsheet to count what was most common. Of course, there was a possibility of interpretive error here, but I think on the whole that it is representative. I only found one item among all those shared that I couldn't really classify at all. In the end, I counted 73 distinct learning outcomes. Here are the top six, with their number of occurrences:

  • Clean Code (9)
  • Single-Responsibility Principle (8)
  • Test-Driven Development (8)
  • Model-View Separation (7)
  • GitHub (7)
  • Making GUIs in JavaFX (6)
This is not significantly different from a normal semester's outcome. The ones most often mentioned tend to be the generic ones, such as "Clean Code," whereas specific Clean Code practices or theories are less frequently represented (and counted separately). Curiously, items relating to distributed development were sparse. Many people wrote about working on a team, but only one explicitly mentioned remote collaboration.

That's enough blogging for today, since I already wrote up my reflection on the Spring 2020 Game Studio this morning. I expect I will be back tomorrow with a reflection on the CS222 course.