Paul Calande
Division II Evaluations

Database Driven Websites (Spring 2018)

Final Instructor Evaluation

Paul Calande did good work in this course. In his first homework he presented good commands for creating tables and data, and performing join operations of medium complexity. His second assignment presented very nice code, which met all requirements. In addition, this homework included some nice extra features, and used programming language features he learned independently, beyond what had been covered in class, demonstrating initiative and capacity to carry out independent work. His homework on data normalization presented a fairly good decomposition of attributes into separate tables. His description of how he carried out this process, nevertheless, had some minor mistakes related to the terminologies he was using. His work dealing with Ruby on Rails was good, meeting many but not all specifications for a problem of medium complexity. This work failed to meet some of the more complex aspects of the assignment, but nevertheless those aspects that were completed demonstrated good design and understanding of Ruby on Rails methodologies.

In closing, Paul did good work in this course. He demonstrated very good understanding of database theory, and his code provided evidence of good programming practices and implementation of database code of medium complexity.

Final Self-Evaluation

My major goal during this Database-Driven Websites course was to learn the skills necessary to create my own websites. I certainly met this goal and went from knowing almost nothing about web development to being able to roll out my own web applications with relative ease. As an aspiring commercial game developer, knowing how to build websites from the ground up will prove to be incredibly useful.

One noteworthy direct result of this course is the fact that I made my own website from scratch. It includes my resume and my portfolio, and I've already used my new site in my job applications. I built my website using PHP, HTML, and CSS, which are all languages that I learned during this class. At the time of writing this self-evaluation, my website can be found at http://paulcalande.me/.

In addition to the iconic languages mentioned in the previous paragraph, I learned about managing databases, particularly using SQL, as well as how to organize data via data normalization. I also learned about a prolific Model-View-Controller web development framework known as Ruby on Rails. It was extremely informative to read through Michael Heartl's book, Ruby on Rails (4th edition) Learn Web Development with Rails. Having such a framework under my belt will serve me well in the future. It may even be able to land me some web development jobs if I find myself wanting more work.

At the time of writing this evaluation, I am working on finishing the course's last assignments involving Ruby on Rails. Overall, I am quite satisfied with what I got out of this course and I will certainly carry my new knowledge with me as I continue moving forwards.

Quantitative Cumulative Skill

Paul designed, implemented, carried out and explained algorithms of medium.

Independent Work Cumulative Skill

Paul independently selected the topic his data would be storing, but aside from that the format and content of his submissions followed fairly prescribed requirements.

Partnership with Fay Games (Spring 2018)

Final Instructor Evaluation

Paul Calande proposed, designed, and implemented an independent course focused on developing his original game in partnership with Fay Games, a local game studio. Paul pitched his game as a 2D platformer in the genre of Castlevania or Metroid. Paul would provide the story, creative direction, and programming, while Fay Games would provide additional resources in game design, art, production, and audio design.

Overall, Paul's performance was mixed. During the semester, Paul was in reasonably good contact with me through meetings, email updates, and Slack (an instant messaging service). His performance as a programmer and game designer was sporadic. When he focused on the project and put time into it, he regularly made progress and contributed significantly to the development of the game. At other times, he was focused on other projects (also important!), and contributed little. He could have done a better job at being honest with himself about what he could really accomplish in a given week. I admire that when Paul struggled, he was able to introspect and identify what was holding him back. Overall, I believe his work on the game helped him develop his skills in programming, game development, communication, teamwork, and project management. I look forward to continued collaborations with Paul!

Final Self-Evaluation

My goal for this independent study was to get a solid start on making a commercial game in collaboration with Fay Games. As an aspiring creator of entertainment, this opportunity is very important towards my future. However, for that reason, doing work on the project has been a little intimidating, and my course goals evolved to include becoming comfortable with publicly sharing various works in progress, including plans for the game's story.

Opening up my own creative ideas to the prospect of criticism has always been fairly difficult for me because of my fear of disapproval. Over the course of the independent study, this slowly got easier for me. By the time I started writing this final self-evaluation, I've done enough discussion with my advisor along with self-reflection to mitigate my fear of disapproval quite significantly. As is the case with most fears, the most effective cure is exposure. Now that this fear is mostly gone, I am feeling more capable of creating a desirable future where I share my works. This independent study has definitely invoked an important step in my own personal development.

In addition to becoming more comfortable with sharing my work, I learned the importance of iterating upon prototypes and how it takes precedent over trying to do everything at once. In the past, I've had difficulty imagining large tasks in terms of small substituent steps rather than one massive ordeal, which intimidated me. This independent study, along with the other courses I took this semester, forced me to hone this skill of breaking tasks down into smaller pieces. Thanks to harsh deadlines, my development was furthered and I've become a more robust and capable worker. I now have more tools and strategies at my disposal to help prevent myself from being driven into corners again in the future.

Due to struggling to overcome my fears and other challenges mentioned above, I didn't accomplish as much as I hoped I would. Regardless, an early albeit playable prototype was successfully created, and I think it is a good start to creating a solid final product. I now feel much more capable of working efficiently.

Game Development Workshop (Spring 2018)

Final Instructor Evaluation

Paul Calande participated in the course as a programmer, who was tasked with creating the underlying code of the game. Programmers implemented the game design ideas in code, specifically using C# in the Unity game engine. Programmers also needed to integrate assets provided by the art and audio teams into the game.

Paul participated on two different teams during the semester, and had perfect attendance (0 absences). For the first half of the semester, he worked on a game, Rocket Puncher, which was a side scrolling 2D bullet hell game. The gameplay was surreal and clever, exploring melee attacks in the bullet hell genre. There were two other members of that team, and Paul collaborated extremely successfully with them. The game reached a high level of polish and quality due to the significant effort that Paul and his teammates devoted to the project.

In the second half of the semester, Paul worked on Not the Face, a single player boss fight game where the player controlled a rolling head, which gained powerups over time. This game also reached a high level of polish through good iterative development practices, solid teamwork, and lots of hard work. In fact, the team even combined both games into a single experience, and submitted it to the student E3 competition!

Overall, Paul made a huge contribution to his teams and the course. Both of his games demonstrate high quality work that are a worthy achievement, and he surely learned a lot about game programming, teamwork, and game development in general. I look forward to playing any future games he might create.

Final Self-Evaluation

My goals for this Game Development Workshop course were to sharpen my programming skills and improve my ability to cooperate with members of game development teams. I believe that I met these goals quite well. I learned an immense number of programming techniques as well as how to use certain tools in the Unity game engine.

In the end, I wrote over 11,000 lines of C# code, which I think is pretty impressive! I also wrote my own versatile Unity C# library, which can be reused across multiple games. It's quite modular and fits well into the paradigm of entity-component systems. This library and the skill I gained by writing it will most certainly be helpful towards my future, both as a programmer and as a game developer!

Some tasks ended up being more challenging than I thought they would be, and there were times when I procrastinated. However, I managed to finish almost all of the tasks for each of the two projects I worked on. I even submitted a game to an E3 competition.

I was the only programmer on my team. Communication and collaboration generally went smoothly. I suppose the experience I gained from being lead programmer on Project IONA can be thanked for my improved communication skills. My teammates stated that I'm a "programming god". That wouldn't be a bad job title at all!

Independent Work Cumulative Skill

Paul made good progress on independent work.

Artificial Intelligence (Fall 2017)

Final Instructor Evaluation

The objectives of this course were to: gain familiarity with a range of concepts and computational techniques that have been developed by artificial intelligence (AI) researchers over history of the field; apply several of these concepts and techniques to hands-on research and development activities; develop skills in "functional"-style programming; conduct independent programming-based project work; develop project presentation skills; and work collaboratively with classmates. Students were evaluated on the basis of attendance, participation (both in class and in out-of-class activities), a portfolio of code and text, and in-class demo presentations. Students were expected to demonstrate that they had read and thought about the course readings, and portfolios were expected to demonstrate facility with the code environment used in the class and engagement with several of the class topics at the implementation level.

Paul Calande's performance in this course was superb. He attended every class session and he engaged deeply with the course material. He contributed to the work of the class in substantive and constructive ways, both in his presentations and in his interactions with classmates. Paul wrote thoughtful responses to the course readings and worked on programming projects involving the use of AI search algorithms to solve puzzles, the implementation of artificial neural networks, and the use of evolutionary computation to produce music-making programs. In all of this work Paul demonstrated strong and developing technical skills, enthusiasm, curiosity, dedication, and attention to detail. Paul learned and grew a great deal in this course, and he is well prepared to move on to more advanced work in artificial intelligence.

Final Self-Evaluation

My goal in this course was to learn about artificial intelligence, and boy, did I do that! I learned about search algorithms, genetic algorithms, genetic programming, neural networks, and more. Neural networks used to be a complete mystery to me, but now I've finally learned about how they work, including most of the nitty-gritty details such as gradient descent. This enhanced understanding of various artificial intelligence techniques will serve me well in the future when I need to solve difficult problems or perform complicated tasks.

One of my favorite parts of the course was learning about the applications of artificial intelligence in the real world, as well as the implications they have on society. For instance, I never quite understood how facial recognition tasks worked, but now that I've taken this course, I learned that tasks like these are often performed via AI. Everything has started to make a lot more sense. I have gone from not understanding artificial intelligence at all to being able to write my own AIs to solve tasks of my choosing.

Artificial intelligence is not an easy field to learn (at least for me), so I did struggle a bit, especially when learning about neural networks. Occasionally I had a hard time keeping up-to-date with the readings, although that's partially because this semester was so busy for me. I wish I could have done more on the final project (rewriting GenBebop, a Common Lisp music generation AI, in Clojure), since the notion of automatically-generated creativity is fascinating to me.

Fortunately, now that I've taken this course and thus know the ropes, I can keep messing around with AI on my own time! I'm more than willing to continue pursuing this field as a hobby in the future. Taking this course gave me the boost I needed to enter the field of artificial intelligence, as I was initially lacking the self-drive to get over the hump of getting started with studying AI. I'm looking forward to experimenting with making AI-based tools to help me with my video game development and hobby endeavors!

Quantitative Cumulative Skill

Independent Work Cumulative Skill


Game Engine Graphics and Audio (Fall 2017)

Final Instructor Evaluation

Paul Calande proposed, designed, developed, and implemented an independent course focused on game engine graphics and audio, and also included a component of team leadership for a large programming team. Paul's original syllabus had an extremely aggressive schedule for his game engine work, but as with many courses, the syllabus changed during the course to reflect reality. Nonetheless, the actual work he accomplished in the course was substantial, and worthy of due credit.

During the semester, Paul was in good contact with me through weekly email updates, include samples of his graphics work. We also maintained strong communication through an instant messaging client, Slack. He worked independently and reliably, even though he slipped from the overly-aggressive schedule in the original syllabus, his final work was high quality and demonstrated significant learning. He was open to feedback from me regarding his work, and also was able to thoughtful introspect about his course goals and patterns of work. It is clear that Paul was able to further his technical and leadership skills through his work in this independent study, and I believe that Paul was successful in achieving his goals for the course. I'm sure he will move forward with stronger skills in game development, teamwork, leadership, written and oral communication, and time management.

Final Self-Evaluation

My goal for this course was initially to learn enough about OpenGL to be able to use its graphics capabilities to make my own game engine. I didn't reach that point, but I did satisfy the syllabus nonetheless. This is fine, because my long-term goals changed over the course of this semester. I went from wanting to do game development alone to becoming comfortable with working in a team. Hence, making my entire own game engine wouldn't be the best use of my time right now, despite being a good exercise.

I struggled to keep up with the rigorous syllabus, but learning how computer graphics works under the hood has made me appreciate 3D graphics a lot more. Graphics processing units truly do perform an impressive quantity of work, and they're all so fast now that many of us take them for granted and hardly appreciate how far technology has come. I now understand which OpenGL operations are most efficient and will use that knowledge when optimizing games in the future.

The Hampshire course I previously took about linear algebra helped me a lot in understanding all of the matrix and vector math behind computer graphics and OpenGL's rendering pipeline.

As for the leadership component of this study, please see my final self-evaluation for CS327 Interdisciplinary Game Studio. I did so much work in that class that it actually counted for two courses, including this independent study!

Interdisciplinary Game Studio (Fall 2017)

Final Instructor Evaluation

It is the dream of every professor to have students who work as hard and learn as much as Paul did in this course. In my 5 years at Hampshire, I've never seen a student contribute as much as Paul did. It is no surprise that on the last day of class, every other student in the course applauded Paul.

Paul Calande was the lead of the Programming team, which was tasked with creating the underlying code of the game. Programmers would read the documents provided by the game design team and implement those ideas in code, specifically using C# in the Unity game engine and GitHub for source control. Programmers also needed to integrate assets provided by the art and audio teams into the game. Throughout the course, programmers coordinated with each other to allow all the pieces of code to function together. The programming team included 5 members, 1 lead, and 1 producer.

Paul had good attendance this semester (1 absence), and was a thoughtful contributor to class discussions during game critiques. It's hard to summarize Paul's contributions, because they were so massive. Without him, the game we published would be a shadow of what it actually is. He led the programming team with diligence, skill, and superb communication speed. His biggest weakness was taking on too much himself, something I suspect will be a regular challenge for him in team projects, because he is likely to be the most competent programmer on the team. Nonetheless, Paul adjusted his style and strove to delegate more later in the course. Overall, Paul was the most indispensable member of the team this semester, and I look forward to seeing Paul's future work in this field. If this class (or something similar) is offered again, I would welcome his participation in a leadership role.

Final Self-Evaluation

My initial goal for this course was a simple one: to gain skills in video game programming. Upon first entering Interdisciplinary Game Studio, I was offered the role of lead programmer, which I took. I was very anxious about it at first; I didn't think I would be able to fulfill the role. However, I ended up totally exceeding my own expectations and doing extremely well! My overall contribution to the class (and the video game we were developing) was ultimately very large.

At first, I stumbled a bit. During the early weeks, I made the mistake of communicating more on Slack when I could have communicated more in person instead. I fixed this mistake and found that in-person communication was both far more enjoyable and far more effective than communication via text. I also learned how to properly sort tasks by priority using labels on Trello. Initially, I was using the Trello labels to sort tasks by category, but I quickly learned the importance of using the labels to instead assign priority and determine what needs to get done as soon as possible. By prioritizing and assigning tasks to the rest of my team, I got a ton of practice honing my production skillset.

On top of my production, leadership, and interdisciplinary communication, I did a lot of programming on my own time and learned about a ton of features in Unity. I gained a large amount of experience in Unity's animation features, manipulating UI elements and the UI canvas, creating volume sliders and audio mixers, and much more. I also got experience writing technical design documents in order to communicate to programmers exactly what needs to be done. I learned several new tricks in Git too, as well as how to resolve merge conflicts on GitHub.

I am very glad that I chose to take the role of lead programmer because it allowed me to develop many skills. I learned far more from this class than I would have if I wasn't the lead. This semester was by far the most challenging one at this point in my academic career, and I'm glad that my limits are being pushed and that I'm expanding my comfort zone. I will use all of the skills that I learned in this course to continue working towards being able to make anything I want in Unity and beyond.

Independent Work Cumulative Skill

Paul made excellent progress on Independent Work this semester.

Programming Paradigms (Spring 2017)

Final Instructor Evaluation

Paul did very good work in this course. He implemented programs for Fibonacci numbers and to compute factorial(n) in both imperative and functional styles. His object oriented code made good use of many advanced features, such as inheritance and polymorphism. Paul implemented binary search trees in both functional and imperative styles, with which he demonstrated very good engagement with different paradigms while addressing a common task. In this section of the course he also developed makefiles in order to facilitate the compiling of his code, which, while not a programming paradigm in itself, will serve him well in future programming projects. His Prolog code implemented an English language parser/generator able to handle complete sentences, including adjectives and adverbs. In addition, his parser was able to handle complex operations such as generating traces of the rules that had been used during sentence processing. Finally, in the section on SQL, Paul developed clean, correct, and efficient code to populate database tables, and to send and receive queries of moderate complexity. This will allow him to participate in many common programming tasks, for example with many professional computer science endeavors which make use of database technology.

In closing, Paul did very good work in this course, and demonstrated good engagement with imperative, functional, object oriented, and logic programming, as well as with Standard Query Language. He should be able to use these paradigms without problem in future programming activities.

Final Self-Evaluation

Programming Paradigms has been a very informative course that has introduced me to several programming paradigms I had not encountered before. As a computer programmer, my mind has been exposed to new ways of thinking about programming; I have many new tools to use for solving complex problems.

C++ and Python are languages I already knew pretty well. Scheme was something I knew a little bit of since I had learned Clojure in a different class this semester (Clojure and Scheme are both dialects of Lisp, so they are very similar). Prolog (and, by extension, logical programming) boggled my mind - I had not seen anything like it before. Its ability to state facts and predicates is quite intuitive and evidently powerful for fields such as natural language processing. Learning about SQL was one of my favorite parts of the course. Database management is a crucial bit of knowledge required by many software engineering jobs and it will certainly come in handy. Especially after I had heard about SQL year after year but never got around to understanding what it was actually doing - until this course, of course.

I have completed all assignments in this course and am happy with my performance. The binary search tree assignment in particular bolstered my skills in problem solving in most of the programming languages within this course. Writing an implementation of a binary search tree in C++ drove me to learn more about using smart pointers, a powerful and prolific library feature for automatic memory management. I will certainly keep using these smart pointers in future C++ programs of mine. It was quite easy to convert my C++ code to Python code. Writing a functional implementation of a binary search tree was naturally much easier than writing the imperative implementation, which made me better understand the advantages and disadvantages of each programming paradigm. This class has most certainly been great in terms of improving my job security.

Quantitative Cumulative Skill

Paul correctly designed and implemented computer algorithms of intermediate complexity.

Genetic Programming (Spring 2017)

Final Instructor Evaluation

Paul Calande's work in this course was superb. He attended every class, participated actively in class activities, and delivered well-prepared presentations. His programming work was more sophisticated than what was expected for the class.

Throughout the course, Paul showed a big interest in learning more about genetic programming, functional programming, and the Clojure programming language. Early on in the course, Paul was experimenting with some advanced programming concepts, such as recursion and "destructuring" Clojure data structures. Paul put in extra effort to adhere to the conventional best practices of the in Clojure language. This resulted in clean, well-written code, and this practice will likely serve him well in the future.

Paul's final project implemented a genetic programming system that produces programs = analogous to binary circuits. This was project was an impressive use of genetic programming, and presented unique challenges that Paul tackled very creatively. Paul's project clearly showed a good understanding of genetic programming and the Clojure programming language. Overall, it seems Paul learned a lot in the course, and he should be proud of the work he produced.

Final Self-Evaluation

Prior to taking this course, even the core concepts of evolutionary computation seemed elusive to me. Last semester, I took a Hampshire course called Evolution of Game-Playing Multi-Agent Systems. One section of the course briefly went over the concepts of evolving AI, but I didn't really grasp any of it. Fortunately, this class, Genetic Programming, has solidified my understanding of the core ideas involved in machine learning and biology-inspired evolution of a population of data.

To do genetic programming, we used a programming language called Clojure. Clojure is the first functional programming language that I learned. Its syntax and various conventions have taught me a lot. Lazy sequences are a very powerful and efficient way to store data, performing calculations only as they are needed rather than calculating the whole sequence ahead of time. This notion of a lazy sequence is a clever and intuitive concept that I had not thought about previously, but makes perfect sense. I've done work with function binding and composition before in other languages, but never fully understood its purpose and power until I started working with Clojure. I was especially surprised by how easy it is to randomly generate programs and run these programs directly - this is the power of functional programming and Lisp. As my first Lisp dialect language, learning Clojure has been a very memorable and enjoyable experience for me.

I now know some of the ways to utilize machine learning to solve difficult problems. As a programmer, this helps my job prospects. Additionally, I am taking Lee Spector's critically acclaimed Artificial Intelligence course next semester, so everything I learned in this course will help me a lot going forward in my education.

Quantitative Cumulative Skill

The student used quantitative information successfully as a tool in construction, production or design.

Independent Work Cumulative Skill

The student developed project ideas, and was able to steer the project through appropriate deadlines. Student was able to sustain a focused effort and complete the project.

Virtual Reality Game Lab (Spring 2017)

Final Instructor Evaluation

In the first project, Paul worked on a five person team in the role of programmer. On the given theme of shadows, Paul's team created a VR game (The Hollows) for the Vive that involved exploring an underground cave, climbing, ropes, lights, and light-phobic enemies. The game was large in scope, and though more iterative development would have improved it, the final product demonstrated significant accomplishment given the time constraints. Paul's teammates complimented his work ethic and his many contributions to the game's codebase, though also noting that Paul might have been able to raise lingering frustrations sooner rather than later.

In the second project, Paul worked on a different five person team in the role of programmer. Paul's team created the game Mountain God for the Vive, in which players play God, protecting a village from invading hordes via divine powers such as lightning bolts, healing, and even stopping time. The final game reached a high level of polish due to successful iterative development, and the team even submitted their game to a student competition! Paul's teammates had incredibly high praise for him, noting that the game wouldn't have been half of what it was without his contributions. It is clear that Paul went above and beyond in his work on this project, and it shows in the final product and his peer reviews.

Paul met the attendance requirements for the course with perfect attendance, and was generally quiet in class. When Paul did share feedback during a large-group discussion, it was relevant and welcome. Overall, Paul was one of the top contributors in the course, and his projects demonstrate the large effort involved.

Final Self-Evaluation

When I entered the Virtual Reality Game Lab course, my goal was to get experience with working in teams on game development. As I was taking the course, my goals also extended to include getting more experience with programming and project workflow. My overall educational goal is to obtain the skillset I need to fully develop my own games, and this course was certainly progress in that regard.

I believe I have done well in terms of satisfying all of my course goals. Through doing a ton of programming for our games, I learned of many new programming techniques such as how to use C#'s delegate events, which are a crucial asset when it comes to decoupling entity components. Events allow me to effectively write isolated code that could be easily ported to different games. Working in this course also gave me more experience with determining how to break a large class down into multiple portable subclasses. That is a crucial part in writing useful components in entity-based systems like Unity.

I also learned how to use Git Bash, a powerful console program for version control. Previously I was using GUI implementations of Git, but using the raw power of the command line proved to be much faster and more effective since I could instantly enter any Git command I desire. After learning Git Bash during this course, I taught many of my teammates how to use Git Bash, and they also seemed to prefer it over the GUI-based alternatives.

For me, the most challenging aspect of this course was managing the coordination within our teams. Team-based programming in particular is something that requires ample communication - something I was not used to after developing games on my own for years. I also discovered how even a single team member can really change the outcome of a project. In particular, when one of your team members makes huge changes to the project without contacting anyone ahead of time, it can really wreak havoc. Witnessing this made me realize how important it is to establish the team's dynamic as soon as possible. I now know much more about what to encourage and what to avoid when working in teams. Working in this course gave me a great amount of experience with team-based development, and I am glad for that.

Taking this course changed the way I view problems and the development process. Originally, I was thinking only about the end results of projects without taking the most important part into consideration - the process and what I had gained out of it in terms of my skillset and problem-solving abilities. After taking this course, I decided that I should view challenges less like obstacles and more like opportunities for learning and self-improvement.

My dream is still to be a one-man game studio, but for now I'm going to continue exploring team-based game development. Seeing the ways that experienced individuals work in other disciplines is highly informative. Additionally, working on implementing other people's ideas in ways that are programmatically efficient has proven to be an interesting challenge. Thinking about how to design modular and reusable components for Unity has been a great learning experience for me. This prepares me to tackle additional future programming challenges more effectively.

Independent Work Cumulative Skill

Paul demonstrated strong independent work skills.

Evolution of Game Playing Multi-Agent Systems (Fall 2016)

Final Instructor Evaluation

Paul did good work in this course, in particular with concepts related to multi-agent systems. In this area he translated code and ideas within a publicly available multi-agent system from Python to C++. While doing so, Paul analyzed, understood, and greatly improved the code with which he began. Because of the knowledge he gained through working with this code, he was able to explain complex details about the way specific multi-agent systems work to the rest of the class. By the time he finished this code translation, he had learned much about both multi-agent system implementation and the C++ language.

Paul did less related to evolutionary computation, in part because of how immersed he was in the code translation he was working on for the multi-agent systems part of the course. In fact, aside from participating in class discussions while the material on evolutionary computation was being presented, Paul did nothing else in that regard. I am certain that he could make interesting contributions, if he desires, and he himself mentions in his self-evaluation that he intends to explore this topic in the near future.

The great work Paul did with the multi-agent systems part of the course was enough to warrant his receiving full credit for the course, but at the same time he failed to show much engagement with the evolutionary computation part of the course. I hope he does engage with that topic in the near future.

Final Self-Evaluation

This class has been sort of a rollercoaster for me. It has been both a fulfilling programming experience and a whirlwind of confusion. Multi-agent systems and evolutionary programs were both subjects that I had zero experience with when coming into this course. Learning about them was cool, but I struggled a lot. Struggling is good, though, because every struggle makes you more powerful. Or something like that. The point is, I learned about a fair number of things, but it was very painful most of the time.

The first hurdle I ran into during this course was the immense challenge of trying to compile the RoboCup Soccer Server on my Windows machine. I spent hours upon hours trying to navigate the impossible labyrinth known as GNU Build System. Autotools, makefiles, configure scripts, Linux-like systems, MSYS, Cygwin. All of these concepts inundated my feeble brain. Eventually, after months of troubleshooting, I finally got the configure and makefile scripts to complete without any errors and spit out an exe file. And what a relief it was! It was a long journey and I learned a lot about Linux, but build systems wasn't exactly supposed to be the subject of this course. That's fine though, because I learned something new and relevant to my concentration of computer programming, and that's what matters.

Rewriting the Lafayette client gave me the push I needed to motivate myself to learn more C++. I didn't really have a reason to push myself to learn more C++ concepts until I was forced to recreate the functionality that the Lafayette code offered. I'm glad for that, because I'm now motivated to keep working with C++ on my own time since I've got some momentum going.

Moreover, interpreting the Lafayette client code was my first real experience with the Python programming language. I've dabbled in Python before, but I didn't really go out of my way to try to understand more complicated Python code. Thanks to this class, I've learned more about the differences between Python 2 and Python 3, and I've also learned about several important Python concepts such as dictionaries and regular expressions.

This class and the Lafayette client also introduced me to several extremely important programming concepts, such as multithreading, multiprocessing, and networking. These are all things that I have never really programmed with before. Now, thanks to this course, I feel fairly comfortable writing simple multithreaded programs. Joining and detaching threads are familiar concepts to me now. I don't exactly have many applications for which I can write multiprocessing code, but it is a concept I now understand. Networking code is something I have briefly toyed with before, but learning about popular networking libraries such as boost::asio was very informative.

If there's anything from this class that I still feel weak about, it would be evolutionary computation. Without regularly-scheduled but manageable programming exercises, I didn't feel like I was really absorbing the information about evolutionary computation given during the lectures. I do have a conceptual understanding of multi-agent systems, though, and that's nice. As I said, though, I learned a ton of different things that weren't necessarily in the course description, which is fine and actually pretty great. Even if I didn't fully pick up on everything in the class, the experience was still very informative for me nonetheless.

Quantitative Cumulative Skill

Paul translated intermediate code to advanced code from one programming language to another. Through this activity he demonstrated proficiency in both the C++ and the Python programming languages, as well as in understanding complex algorithms more generally.

Independent Work Cumulative Skill

Paul worked all semester long on an independent project of his own choosing, one that will integrate well with the work of others.

Introduction to Programming in Unity (Fall 2016)

Final Instructor Evaluation

Paul did very good work in this course. By the end of the semester he had written code that included input and output, conditionals, loops, arrays, objects, and classes. His code was efficient and, for the most part, clean. There were some small exceptions, for example, when he included functions in his code that were not used/called for. In general, though, his code was consistently introductory level, which was the intended target for this course. Paul consistently turned in good reflections on group dynamics, which was an important part of the course.

As a final project, Paul's group implemented a fairly complex game involving object collection and avoidance, timers, increasing challenges, and an entertaining storyline. Their code was efficient and well structured, and their game was entertaining. The code itself made good use of the programming elements covered in the course.

Paul did good programming work in this course and is ready for more advanced courses on this topic.

Final Self-Evaluation

I have a confession to make. When I first saw the title of this course, I thought it would be about teaching game development with Unity, not about basic programming concepts. That didn't stop me from enjoying the course, though! While I have been a programmer for several years now, programming in groups was not something I had any meaningful experience with upon entering this course. During the course, however, I enjoyed working with other students on programming and got valuable experience doing so. Trying to help other students learn new concepts often helped reinforce my own understanding of these concepts.

Our final project, Five Nights at Alan Turing's, was the most fruitful part of the course for me. It was my first meaningful undertaking in Unity and I learned a lot while doing it. One of the most important concepts I learned from it was the quaternion: a way of representing a 3-dimensional rotation that is very computationally efficient. I also learned about various methods of utilizing time-keeping functions to make games run independent of framerate - something that is undeniably extremely important in the modern video game industry. Admittedly, I put way more work into the game than was necessary, but I really wanted to see it finished and enjoyed it all the way through.

While this class might have been a bit too easy for my skill level, I do not regret taking it at all. I would do it again - if I had the time! Seeing the creativity of other students during the final project was my favorite part of all.

Quantitative Cumulative Skill

Paul implemented computer algorithms of intermediate to advanced difficulty.

Independent Work Cumulative Skill

Paul worked as part of a group that designed and implemented an original and entertaining game. These efforts required the group to plan and execute a number of tasks through several weeks' worth of work.

Linear Algebra (Fall 2016)

Final Instructor Evaluation

By the end of the semester, the goal was that the students would know how to Paul has exceeded my expectations in terms of all of the course goals listed above. His assignments were impeccable and the quality of his work exceptional. His peers benefited from his presence in the class, as he frequently worked with them on in-class exercises. Paul's enthusiasm for the subject and his good sense of humor kept the class atmosphere jovial and conducive to learning.

He undertook a challenging final project in which he wrote a code that uses rotation and projection matrices to render a 2D projection of a virtual 3D cube. He successfully integrated the material we learned in class with his personal interest in animation graphics and programming.

Final Self-Evaluation

Matrices were first introduced to me sometime during my middle school years. I worked with them without knowing their purpose or why they were teaching them to us. It all seemed so painful and confusing. What better way to solve that problem than to take an entire class about matrices?

Linear Algebra class obviously improved my formerly lacking understanding of matrices. It was a fun class for me. I enjoyed participating in class discussions. The questions I asked during lectures always got informative answers, so I always felt like I was progressing. I attended every class, except for that one time when I slept through my alarm. Simply unforgivable.

So, you're asking me about problem sets, short assignments, and so on... I did everything, and I did my best. I'm satisfied with the work I did. Yep. Not much to say here. It felt like the homework assignments were rather huge at times, but I managed, and everything turned out fine. I feel as if my work ethic has improved a bit because of this class. That's always nice!

At the end of the course, I applied linear algebra to something of immediate interest to me: 3D computer graphics. I ended up having to learn OpenGL in order to make my final project work, and it was great! Deadlines are wonderful in a twisted way because they motivate me to work quickly. Where does this motivation come from, you ask? Fear. Deadlines inspire immense fear in me, and so they are the one way to make me stop procrastinating. Thus, the final project of the course forced me to learn an immense amount of stuff relevant to my concentration of computer programming, and for that I am very happy! On the other hand, I had to learn so much that I took a lot of time and ended up turning in my project at the very last minute, but that's beside the point. Education trumps all, or so they say. (Disclaimer: No one says that.)

I am not going to lie: matrices are complicated things (at least to me). I am very glad that I understand them now, especially since they are so important to computer graphics. The understanding of linear algebra that I gained from this class will help me a lot in future programming endeavors and will most certainly save me from many hours of Googling what a dot product is.

Quantitative Cumulative Skill

Consistently calculates accurately, including use of advanced methods of numeric analysis or representation. Accurately uses a graph, table or diagram to solve problems or predict change. Critically analyzes reported quantitative information and can identify limitations or bias.

Independent Work Cumulative Skill

The student came up with a good question or project idea, either within the context of a course or outside a course. Student was able to steer the project through appropriate deadlines.

American Sign Language I (Fall 2016)

Final Instructor Evaluation

Paul Calande truly showed enthusiasm in learning American Sign Language as well as in learning about the Deaf culture/community. His attendance was excellent. His receptive and expressive signing skills are very good. His three quizzes and final examination were excellent. He wrote six out of six reaction papers and one research paper. His final paper was based on "The Relationship Between American Sign Language Proficiency and English Academic Development: A Review of the Research." All of his papers were well written and turned in on time. Preparing those papers has increased his knowledge and sensitivity about Deaf and hard of hearing people/issues. By completing his student workbook assignments, he has acquired several conversational skills: vocabulary and key grammar structure, numbers, fingerspelling, and spatial elements. He analyzed one documentary, "Through Deaf Eyes." He has learned that there is a diversity of people with hearing loss and various signing skills. He gave two presentations in ASL and did well on both. He developed confidence in using ASL. In summary, Paul has completed all the requirements for American Sign Language I, LS 0123-2, and is ready to take American Sign Language II.

Final Self-Evaluation

American Sign Language I was a very enjoyable class. I learned an immense amount about Deaf culture, which I knew nothing about when I started the semester. Every reading assignment was very informative and enjoyable, and I feel like I took important life lessons away from each one. Out of all of the readings, Deaf Like Me was my favorite. Until I read that book, I hadn't fully realized just how much emphasis our society places on the notion that everyone should fit some standard of "normal". How silly it is!

My understanding of signing (and language in general) was nicely developed over the course of this class. Admittedly, I had grown sick of learning oral languages after taking Spanish for several years during grade school. In contrast, I found signing to be very engaging and fun, and above all, expressive. The important of facial expressions - something I had not fully considered - is not to be understated. It is interesting to see how much attention to detail that ASL has. For instance, merely moving your hands in faster, wider arcs would convey more enthusiasm or zeal with some signs. I thought that was so cool! Sign languages are among my favorite brands of languages; there's just so much you can do with them!

Multiple Cultural Perspectives Cumulative Skill

Paul Calande has learned that there is a diversity of people with hearing loss - culturally Deaf, oral deaf, late deafened, and hard of hearing. He has learned more about a variety of Deaf leaders and artists through their profiles. He has learned ways of communicating with Deaf people including signing, gestures, writing/typing, using third person, and lipreading/speech. He has also learned different cultural ways of getting a Deaf person's attention and negotiating a signing environment. He also understood that the cultural behavior between the Deaf and hearing people is different. With this exposure, Paul understood the multiple cultural perspectives among the Deaf community.

Calculus II (Spring 2016)

Final Instructor Evaluation

Paul attended every class, came prepared, and engaged with the material. Students were expected to complete daily homework sets and Paul completed all of them. Paul demonstrated an excellent understanding of the core concepts: successive approximations, derivatives, integrals, the fundamental theorem of calculus, functions of several variables, and series. He also demonstrated an ability to use techniques for calculating special integrals and determining the convergence of series. Paul was comfortable not only calculating solutions but also interpreting, graphing, understanding, and explaining the various concepts. Paul also used MATLAB, a multi-paradigm numerical computing environment and language, to plot functions of several variables, calculate Riemann Sums, and use Euler's method. Overall, Paul showed not only a strong understanding of the content in Calculus II but a willingness to engage with challenging and complicated problems.

Final Self-Evaluation

While I have taken a fairly thorough calculus class during high school, Calculus II is a class that has made me view calculus more conceptually. I'm more of a "raw calculations" type of mathematician, so looking at the conceptual aspects of calculus rather than the purely formulaic aspects was challenging. However, it was a welcome challenge which makes me very glad I took this class. After all, I entered this class wishing to broaden my horizons and gain a deeper understanding of calculus, and I feel like these goals were successfully achieved.

Ultimately, I have learned to grow comfortable with exploring familiar subjects from different angles and have realized that there's always more to learn about something that you think you've mastered!

Quantitative Cumulative Skill

Consistently calculates accurately, including use of advanced methods of numeric analysis or representation. Solution method is appropriate and follows a logical sequence. Accurately uses a graph, table or diagram to solve problems or predict change.

Independent Work Cumulative Skill

Students were expected to evaluate their own work and stay on track with independent HW assignments. Paul did this successfully.

Elementary Theory of Numbers (Spring 2016)

Final Instructor Evaluation

This course covered the elementary theory of numbers, including topics such as divisibility, congruency theory, Fermat and Euler theorems, number theoretic functions, quadratic reciprocity, and introduction to elliptic curves, among others. Students wrote a total of twenty homework assignments, completed in-class assignments, took a cumulative skills-check assessment, and gave a final presentation on a topic of interest to them.

Paul completed this course successfully with an excellent performance. He showed good understanding of the topics covered through the skills-check assessment and by completing all the required homework assignments. He is a good problem solver who knows how to use technology and programing, in particular, to solve difficult or laborious problems. Paul gave an interesting and engaging presentation on factorials and the Gamma function. His arguments are clearly articulated and presented in a logical way. Overall, he demonstrated mathematical maturity and mastery of the topics covered.

Paul is very reliable and resourceful. He attended classes regularly and was actively engaged in the ongoing discussion. He also utilized appropriate time management in completing his work. Paul regularly shared his very useful insights with the class, enriching the ongoing discussion. Overall, his performance was excellent!

To continue growing in math, Paul needs to continue taking challenging mathematics courses that are proof-based and expose him to new ideas and techniques.

Final Self-Evaluation

Elementary Theory of Numbers has been a very engaging class for me. I learned a whole lot about an area of mathematics that I had hardly thought about at all before, and it was very enjoyable for the entire semester. Something that I am extremely grateful for is the fact that I was allowed to hone my skills in programming, which was something I was studying alongside Hampshire's classes.

In my opinion, my most noteworthy achievement in the class was the final presentation that I did. Previously, I had never done an oral presentation that lasted longer than about 10 minutes, but somehow I ran my mouth for 45 minutes while still managing to have a presentation that was actually good. I surprised myself and simultaneously learned that I was more capable than I expected, which is a very valuable piece of knowledge to have. All things considered, I am extremely happy that I was able to take this class!

Quantitative Cumulative Skill

Paul's calculations are typically accurate. He learned how to construct mathematical arguments with clarity and presented his arguments in a logical and convincing way.