Tag Archives: computer science

Course Review: CPSC 311

Leave a reply

Definition of Programming Languages

“I prefer the word ‘thunk’ to expression closures.”

Text: Programming Languages: Application and Interpretation by Shriram Krishnamurthi

Prof: Dr. Steve Wolfman

Wolfman was slightly less flipped in CPSC311, especially as the term progressed. His lectures were pretty entertaining and included a lot of live modification of the interpreter. Instead of sticking to textbook examples of dynamic scope and laziness, we often worked on languages in assignments and midterms where exotic adaptations and variants of these concepts were incorporated into a language in mind-bending ways.

Difficulty

I expected this to be an easy course. It ended up taking a lot of time. A lot of the programming languages concepts were completely new to me and combined with Wolfman’s avant-garde presentation of the material, I spent a great deal of time preparing for midterms and understanding the readings. The project we selected was in Elixir, and it was also very time-consuming as we had to learn distributed systems concepts in a new language with little guidance. That said, I feel the project was kind of a ‘choose-your-on-adventure’. You could do very well in the project with far less work if you chose wisely initially. Overall, the average was quite hight (around 77%) even though the midterm averages were quite low.

Key Concepts

Scoping

Deferred evaluation

Recursion

Continuations

Functional programming

SKI combinator

Interpreters

 Hard Concepts

Dynamic scope: Really messes with your brain, helps to write out the context.

Continuations: Odd concept. Helps to think of what function the continuation is bound to and apply it.

SKI combinator: Takes practice to get used to ‘algebraic’ manipulations of functions.

Conclusion

Learnt a lot. Enjoyed the project. Challenging course.

Email, RSS Follow

Course Review: CPSC 221

Leave a reply

Basic Algorithms and Data Structures

“After 221 all of you should use “divide-and-conquer” when handing out exams, its a lot more efficient!”

Text: Objects, Abstraction, Data Structures, and Design Using C++ by Koffman, Elliot B., and Wolfgang, Paul

Prof: Dr. Alan Hu

Dr. Alan Hu is great at making everyday metaphors (often involving Justin Bieber) out of abstract computer concepts. He is also very patient in class, answering questions in detail. His classes have a slightly “free-wheeling” style because of this, so the lack of structure could distract some. Dr. Hu is a super approachable guy, (except during exams!), and he seems genuinely passionate about teaching computer science.

Difficulty

The assignments and labs are all do-able, though the penalties for small compilation errors on assignments are harsh. The midterm was pretty long and it had a mistake on it and I (and many others) got wrecked. The final was significantly easier and the scaling was huge. There is a lot of material in the course though, and the questions on exams definitely require some thinking. However, if you are okay with mathematical proofs and work consistently you should be okay after scaling.

Key Concepts

Big-O, Theta, Omega (Time and Space Complexity)

Sorting Algorithms

Basic Data Structures

Iteration and Recursion

Basic Graph Theory

Parallelism

 Hard Concepts

Proof of program correctness: Slightly different than mathematical proof, make sure to fully understand the conditions for a program to be correct. I only realized towards the end of the course, that this requires you to really read and understand the code fully.

Implementation in C++: Algorithms can look a lot less elegant in C++, so one needs to be familiar with common coding style in that language to interpret algorithms well.

Evaluating time complexity of given algorithm: Generally easy, but curve-balls can be thrown. Try breaking it down or stepping through the code.

Conclusion

Really important course for interviews, (along with 213). Felt like I improved a lot of reading code, and Dr. Hu was pretty entertaining.

Email, RSS Follow

Course Review: CPSC 310

1 Reply

Introduction to Software Engineering

“The only things that matter are lives and money.”

Text: (none)

Prof: Dr Elisa Baniassad, Dr Gail Murphy, Dr Marc Palyart

Elisa shares a lot of her experience, and how things work in the “real world”, which is helpful for an engineering class. She is also pretty approachable and sympathetic to any concerns that you might have. Dr Murphy created a lot of useful examples, and live-coded in class which was also a great way to learn. Dr Palyart followed a similar approach to Dr Murphy.

Difficulty

The on going “agile development” project during labs is the only thing that really matters. It is where most of your learning takes place, and you don’t get a lot of help for that, so its pretty tough. The classes look at various buzzwords, design patterns and software development processes and these are assessed in the exams. The in class material is not very hard to understand at all.

Key Concepts

Design of Web Applications

Implementation with TypeScript, JavaScript, Mongo etc

Software development processes

Testing

 Hard Concepts

 

Networking: If, you, like me, have never taken a networking course, a lot of how the internet etc is working will seem like magic.

Nodejs: Return of asynchronous programming. Common source of bugs.

Git: Took me a while to get comfortable uploading etc with git.

Self-learning: Sometimes, you just have to use google and your own ingenuity to come up with a band-aid solution to get stuff working when you understand less than you would like and don’t have time to learn more.

Conclusion

Project is great experience, working as a group and learning new skills. Really hard though! Classes are okay, not much you couldn’t read from a book.

Email, RSS Follow

Course Review: CPSC 213

Leave a reply

Introduction to Computer Systems

“You’ll probably never code in assembly again. But the ability to understand complex computer systems made up of about 20 simply understood lines of code is something you should keep.”

Text: Computer Systems: A Programmer’s Perspective by Randal Bryant

Prof: Dr. Mike Feeley

Feeley is a really hard-working, knowledgeable, helpful and supportive prof. He built a complex simulator to help us understand how assembly works, and his web-page for displaying marks is awesome. It has detailed bar-graphs on how we are performing on key learning outcomes throughout the course. He is really patient during office hours and is really friendly after class. His classes attempt to give us the “big-picture” perspective, so we often have to figure out the details in the lab on our own. He also makes the lab problems quite challenging, to push us further. He does “redemptive grading”, so if you perform better on a learning goal later on in the course, your mark for that learning goal can go up to 80%.

Difficulty

The part of this course that took me the most time was the labs. Some of them were really hard, and we took ages trying to just understand the question because a lot of the concepts were just being introduced and were still new to us. The exam/quiz questions might require a little bit of thinking, because they often have little tricks to them, but are quite doable. Especially since it is clear what concept is being tested in each question, and because the practice material is similar to the real exams. On the midterm, the really challenging question was reading assembly and converting it to C. You only have about 10 minutes to interpret 20 lines of assembly, so I suggest getting a lot of practice for that before the midterm. Following the midterm, the class is less in depth and we blitz through a lot of big topics in computer systems at top speed. Since a lot of this stuff was new to me, it took me awhile to grasp the concepts. However, the way the concepts were assessed on the final was such that if you understood the example on the slides well, you could do quite well. The labs at the end of the course are intense though, so watch out!

Key Concepts

The basic hardware and software architecture of a computer running a single program

Compiling C-code into assembly (and Vice Versa)

Computer bugs at an assembly/hardware level

Event-based programming

 Hard Concepts

Reading assembly: Sounds easy, takes time. It might be worthwhile to draw pictures/keep track of variables while reading assembly.

Solving problems of asynchronous programming: Tested in the labs. Quite hard but really rewarding. Suggest testing ideas with TA before rushing to implement them.

Reference counting: A bit painstaking, it is important to understand when exactly something is losing and gaining a reference in a specific program.

Bitwise operations: Come in handy at random places in the course, so try to remember them

 

Conclusion

Hardest Comp Sci course so far. Probably matured the most as a student of computer science as a result of this class. Realized the limitations of abstractions.

Email, RSS Follow

Course Review: CPSC 210

Leave a reply

Software Construction

“The relationship between me and you, the class is zero-to-many, not one-to-many, since you could all get up and walk out right now'”

Text: (none)

Prof: Dr. Paul Carter

Dr Carter is an efficient and articulate prof. He also has a cool British accent. He is really good at balancing questions with getting ahead in the material. He also tries to give reasons for each structure or process, so that our conceptual understanding is good. He seemed omni-present on Piazza, constantly answering concerns, which was really helpful. He once made an error in the time the class ends. When people got up and started going to their next class, he started pleading them to stay, and not give up on his class. Poor guy!

 

Difficulty

In the first class we dived straight into the rather large code-base of a Space Invaders game. After guiding us through seemingly incomprehensible mazes of Java code, Paul Carter demoed a neat Android app for GPS with the London Underground. Then he informs us we have till the end of the course to submit that app to him. Panic ensues…

It wasn’t that bad. The first few weeks of the course were the worst, because I had no idea what I was doing. The project is fine (he gives you a skeleton) as long as you keep a cool head if things aren’t working out, and manage your time well. The midterm was just like the practice. The final was surprisingly heavy on implementation, but manageable. Labs and assignments are pretty reasonable and count for jokes.

Key Concepts

Object-oriented design/programming

Programming models

Building robust classes/methods

Design Patterns

How to learn a new language

 

 Hard Concepts

UML Sequence Diagram: Wasn’t covered in much depth at a time when we were still grappling with Java. Lots of details so needs a lot of practice.

Exception Handling: Exceptions are one thing that is pretty new from 110. Its important to learn the rules for throwing, catching and testing exceptions before implementing, because they are a bit different.

Observer Pattern: Sometimes its not clear which class to observe, but the rule of thumb is observe the ‘lowest’ possible class. Lots of little things as well, so make sure to have a mental check-list of all the steps in this pattern.

Iterator Pattern: Implementing a new Iterator can be pretty meta. Not to complex if you understand the basic purpose of an Iterator.

Parsing: Parsing can be a pain. It is really painstaking. Reading examples of parsing, reading the input file carefully and being painstaking are key factors in success.

Conclusion

Really useful course. First course where I actually got an idea of the job of a Software Developer. The excitement surrounding the project was also pretty fun.

 

Email, RSS Follow

Course Review: CPSC 110

Leave a reply

Computation, Programs, and Programming 

“Trust the natural recursion!”

Text: (online videos via Coursera on Systematic Program Design)

Prof: Dr Ronald Garcia

Ron is a cool guy. Great sense of humour. He spent a lot of time answering basic questions and doing (generally) simplified examples which annoyed some, since they had already grasped the basics from the videos, and wanted him to explain the more complex aspects of the course. I didn’t mind, since I failed to fully grasp some of the basics from the videos. And sometimes Ron’s simplifications can be applied to a more complex setting. For example, the way he explained built in abstract functions was simple but did not leave out any nuances.

Difficulty

I worked very hard in this course. Some people who had serious prior programming experience, or got really addicted to programming once initiated by this course, found the assignments and tests a breeze. I did not. I got a very good result, but I think that was a result of generous scaling and a lot of hard work on my part. Problem sets are increasingly difficult. Though the first midterm is really easy if you made the faintest attempt to keep up with the material, the second midterm and the final are exponentially harder.

Key Concepts

HTDF recipe

HTDD recipe

Recursion

Abstraction

Hard Concepts

Work-list accumulators: Required me to fundamentally alter the way I saw the structure of  my template, which was a challenge. Lots of moving parts as well.

Back-tracking search over generated trees: Most finals have a question on this, pretty tough, with so many moving parts, but the structure is pretty repetitive.

Abstract fold functions: Making one is easy, but using one to solve a problem is a challenge. Requires practice, insight and being methodical.

Lab

Generally okay lab, since the TA’s are on hand to help. This was in stark contrast to the problem sets which are generally harder, and you have to work on individually. I found the first few labs super-simple, but the one’s after the first midterm increased dramatically in hardness. I generally did not come close to the the 3-hour mark, though many people often remained till the end and many others would finish ahead of me within the first 30 minutes.

 Conclusion

If you are not really  into programming, or have no serious programming experience, be prepared to work very hard to get the most out of this course. I honestly felt that the course was rushed and I didn’t have time to digest what I had learnt.

Email, RSS Follow

Course Review: CPSC 121

Leave a reply

Models of Computation

 “The laptop that you are using is a lot more powerful than a DFA!”

Text: Discrete Mathematics with Applications 4th Edition by S. Epp (see website for other options)

Prof: Dr George Tsiknis

George Tsiknis is the kindest prof in the world. His amazing accent, and personal warmth really leave an impression. He also has a great sense of humour. Its unfortunate that he had family emergency towards the end. Even though he was really going through a lot, he came to class and made sure we were ready for our final. Great guy. Some of the questions in the slides are worded vaguely, making it difficult to get the I-clickers, but they are only for participation anyway, so its all good.  Really willing to slow down and take questions if you need help, in class. I suppose tutorials and office hours must have been equally beneficial.

Difficulty

I get the sense that the topics on this course are very deep. That said, we skirt at the surface of most of these topics, and as a result, the course is quite straight-forward for the most part.

Key Concepts

Elementary Logic

Proof Strategies

Logic Circuits

Hard Concepts

Algorithm Efficiency: The rigorous definition is quite long-winding. Knowledge of Big-Oh notation from Calculus class could help.

Interpreting Sequential Circuits: I found these really tricky in the lab and on exams. They are kind of puzzle like problems- in that you either get them or you don’t- but you can spend a long time just making sense of what’s going on, even if you understand the fundamentals really well.

Predicate: Conceptually easy, but also easy to make careless mistakes or you can confused in half-way through your own translation.

Lab

Fun lab. I kinda freaked out the first few days since I had no clue how to operate a Magic Box or breadboard, but after a while the labs started making sense and I started to enjoy simulating circuits with Logism (which is freely downloadable, btw) or cracking circuit puzzles. Ultimately you simulate a working computer, but it is still a long way a way from the real deal. Pre-labs are not too intense. Most labs are with a partner, so efficient teamwork can get you done a lot faster.

 Conclusion

Fun course. Useful in learning basic logic, mathematical proof and simple models of a computer. But I get the feeling that the computer models we use are so simplified that they are ultimately interesting but have appear to have little real world application. I was waiting to connect what we learnt in class with my PC at home but that happened only superficially for me…The surprising immediate application I got out of this class were proof strategies that helped a lot in Math 121.

Email, RSS Follow