Return to school

By Ed Yakovich [Public domain], via Wikimedia Commons

I haven't posted in a while as I haven't been working on anything that can be considered project-driven or really worthy of a post. In the late summer, I was signed up for three additional Coursera courses: Computer Networks, Startup Engineering, and Discrete Optimization. I didn't post on any of them because I wasn't able to finish them. I was interrupted for a very good reason. This fall, I'm jumping back into the academic life. I had a decent time working as a mechanical engineer in industry but never felt satisfied with my level of knowledge. I would spend a lot of free time researching some advanced topics that interested me and now I am ready to start devoting myself to that purpose full time. It is very exciting.

Earlier this month, I moved to Philadelphia to start working at the Scalable Autonomous Systems lab under Dr. Ani Hsieh. I'll be taking over a project that was started by two students over the summer. They have been developing a new generation of the SAS lab's ground robots to be used as a platform for future research. The primary motivation for the new robots is to utilize the multi-core processors recently available on ODroid single-board computers for processing data from RGB-D sensors. I spent most of my time during the first week trying to digest their design documentation and code as I'll need to understand all of the work that they have done in order to continue development.

By Conspiritech (Own work) [Public domain], via Wikimedia Commons

In reality, a lot has been done already, there was a functioning (moving) robot when I walked in the door on the first day. However, as with all projects of this nature, there are plenty of places where improvements can be made. Concessions are often made on the road to functionality and it is important to identify which ones are worth shoring up. I spent a majority of last week rewriting the Arduino code to eliminate the use of floating point data types, implement interrupt-driven encoder reads, eliminate redundant variables, and generally streamline things as much as my naive C-coding skills will accommodate.


Tomorrow I start my first class as a Mechanical Engineering PhD student at Drexel University. I'll be studying Advanced Dynamics and Applied Engineering Analytical Methods. Advanced Dynamics kind of looks like it will cover the same topics that I was drawn to last year when I was playing around with writing an inverted pendulum simulator in GNU Octave. The Analytical Methods course will hopefully be relevant to the work that I do in the future. I don't often like application-driven classes as they tend to skimp out on the theory but this one seems worth while. Overall, I am excited to get started, we'll see how energetic I am next month.

Coursera: An Introduction to Interactive Programming in Python

I recently finished taking a class called Interactive Programming in Python. The focus was to introduce students to the process of developing games or other applications that a user may interact with in real time. Much of the course focused on standard Python operators, methods and some "best practices" for using them and organizing intuitive, readable code. The class content was generated through the shared effort of a team of professors at Rice University: Joe Warren, John Greiner, Stephen Wong, and Scott Rixner.

As far as exercises go, the class consisted of relatively challenging weekly review quizzes and a coding project (usually in the form of some game such as Pong, or Memory). I can really appreciate the work that was put into developing the quizzes. They make an effort to compel the student to explore all of the characteristics of the various data structures and ask questions that aren't deliberately answered in the lectures but may be determined via deductive reasoning or plain old trial and error.

The video lectures were very engaging. Professors Warren and Rixner did a great job of keeping the videos interesting and getting the students excited for the weekly project. At the end of each lecture series, there would be a short introduction to the latest assignment. This would usually be capped off with a competition between Professors Warren and Rixner using the game that we would be developing. Through their banter, it was amusing to preview their sort of friendly adversarial relationship off camera. While it can't be expected that a class will be entertaining, as long as it is also informative - it certainly can't hurt.

One unique characteristic of the course was that it was entirely self contained. This is sort of a philosophical objective of coursera courses in general but this course could be completed entirely within the confines of a web browser. The student does not need to download any documents, install Python, or even submit files. This is made possible by Professor Rixner's  browser-based Python emulator CodeSkulptor. This approach to development can be good and bad. While CodeSkulptor makes the coding assignments easier on the student, it limits exposure to some of the contextual learning that is necessary for anyone trying to utilize Python. CodeSkulptor only supports a tightly packaged set of  operations; this narrows the focus of the assignments so that the student isn't as overwhelmed by a gigantic API. At the same time, while it is great for the primary focus of the course, the reliance on CodeSkulptor does not prepare the student to jump into developing Python code right out of the gate. They must learn a little more before they can start initializing their scripts and modules on their own machine.

The timeline was a little more rigid than other coursera courses that I have experienced. Unfortunately, the second and third weeks coincided with a trip that I took to Turkey which caused me to miss one or two deadlines and really hurt my overall score. I can understand the motivation for the deadlines - the class implemented a unique scoring method that came with some logistic trade-offs. For instance, All coding assignments were peer-reviewed. After submitting an assignment, the student is then expected to grade five additional assignments before doing  a self-evaluation. The tradeoff here is that, although this allows for flexible implementation of the assignment because it is being interpreted by a proficiently heuristic machine (another human being), the grading takes more than a few days and the deadlines are absolute. If a submission is late, no one may grade it and the student does not get any credit. This is a challenging characteristic for a Massive Open Online Course - usually assignments in online courses of this nature have a healthy buffer to accommodate students with demanding schedules.

I think this process worked out fairly well. All of my graders seemed to put a good deal of thought into their feedback (and I did the same for those who I graded). This indicated to me that they took the role seriously and the process worked pretty well. I believe there are ways of improving the logistics such that students who need to submit past the deadline may be paired with others who need to do the same for partial credit. Additionally, in anticipation of abuse, I would suggest implementing a method for the student to provide feedback to the graders such that consistently poor graders (graders whose assessments consistently represent outliers) may be identified and isolated from impacting other student's grades.

In summary, I'm pleased with the class. I decided to try this one out because I wanted to learn a little more about generating user interfaces and graphics objects in Python. This is sort of a weak point for me - most of the code that I have generated so far is for personal use, terminal based, and sort of clunky. I was also interested in learning some better practices for organizing interactive programs and implementing robust GUIs. Unfortunately, the class did not get a whole lot deeper than timers, simple drawing, and interactive objects. Still, I learned a good deal in the course and I look forward to additional opportunities to learn about interactive programming in this type of setting.