Musings of a Software Engineering Student

I’ve ben doing a decent amount of C and C++ coding recently - both for courses and for hacking on emacs. I ended up doing a bit of work on my C configuration, though probably not as much as I should.

Part of these efforts included improving h-file-create, the function that is automatically run whenever I create a new header file. Previously, it only created the #ifndef guards; While these are the only things I’ll always need, the vast majority of time I also wanted to define a class, and so I programmed the class to be inserted automatically.

(defun h-file-create ()
  "Create a new h file.  Insert a infdef/define/endif block"
  (interactive)
  (if (or (equal (substring (buffer-name (current-buffer)) -2 ) ".h")
          (equal (substring (buffer-name (current-buffer)) -4 ) ".hpp"))
      (let* ((buffer-name (buffer-name (current-buffer)))
             (class-name (substring buffer-name 0 (string-match "\\." buffer-name))))
      (when (equal "" (buffer-string))
          (insert "#ifndef "
                  (upcase class-name)
                  "_H\n#define "
                  (upcase class-name) 
                  "_H\n\nclass "
                  (capitalize class-name)
                  " {\npublic:\n\n\nprivate:\n\n\n};"
                  "\n\n#endif")
        (search-backward "public:\n")
        (next-line)))))

Another function I ended up needing was to insert includes to header files or forward declarations of classes. Previously, I’d have to go to the top of my file, interrupting whatever I was doing, and maneuver back. This was just an annoyance, so I wrote the following functions that would either include or forward declare something, defaulting to the current word at point. Since whether I #included or forward declared often depended on whether I was in a header or implementation file, so I wrote another function that delegates to one of the other two depending on which file you were in. String-match-any is a utility function I wrote to help do this.

(defun string-match-any (regexp-list string &optional start)
  "Returns whether the given string, starting at position start,
matches any regexp in the list"
  (if regexp-list
      (let ((result (string-match (car regexp-list) string start)))
            (if result
                result
              (string-match-any (cdr regexp-list) string start)))))
 
(defun-my c-include
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (if (search-forward "#include" nil t)
        (progn (beginning-of-line)
               (insert (concat "#include \"" (downcase arg) ".hpp\"\n")))
      (search-forward "\n\n")
      (insert "#include \"" (downcase arg) ".hpp\"\n\n"))))
 
(defun-my c-forward-declare
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (if (re-search-forward "class [a-zA-Z]*;" nil t)
        (insert (concat "\nclass " (capitalize arg) ";"))
      (search-forward "\n\n")
      (insert "class " (capitalize arg) ";\n\n"))))
 
(defun-my c-fwdinclude
  (interactive)
  (let ((buffer-name (buffer-name (current-buffer))))
    (if (string-match-any (list "\.h" "\.hpp") buffer-name )
        (c-forward-declare arg)
      (c-include arg))))
(define-key c-mode-base-map (kbd "C-c c f") 'my-c-fwdinclude)

I’ve also been using c-eldoc-mode more. It’s pretty awesome, but there is one problem with it: its speed. On a large project like emacs, it will frequently lock the input for some time. It’s useful enough that I’d for it to be faster. If there’s a later version that fixes this that you know of, please tell me; the latest I’ve found is v0.4. Otherwise, I’m going to look into it further to see if I can figure out how to speed it up some more.

As part of the raytracer I wrote for my CS488 (graphics) course, I rendered a pacman scene. This was fun enough that I’ve decided one of my projects over this next work term will be to try and write a real-time raytraced pacman clone, almost certainly using CUDA. I haven’t used CUDA before, so I’ll undoubtedly end up learning a lot. The goal will be to be able to render it at 30FPS on my laptop, which has a NVidia 8500 as a graphics card. I don’t know how feasible this is, but I can try.

While my raytracer had a few performance enhancements, it still took about three minutes to render my final scene. Clearly, this isn’t nearly fast enough, and I don’t think I’ll be able to get anywhere close to necessary on my CPU; an order of magnitude *may* be possible, but certainly not three. The natural solution is to try using the GPU; CUDA seems to be the most popular way of doing this, and I’ve wanted to learn it for a while.

A few additional things I’m going to have to add to my raytracer while porting it to CUDA:
CSG and better KD-Trees, for one. I didn’t end up implementing constructive solid geometry at all, although I have a pretty good idea of how to do that. Unfortunately, it’s going to require a decent amount of refactoring of my raytracer; currently, my Intersection objects only store one intersection point; this will have to change to store ranges of points. I may not have to end up doing this, depending on how much it helps; I’d probably only end up using it to render Pacman, who was a polygon I created using CSG in blender for my project.

The other main optimization I’ll probably have to make is to improve my KD-Trees. I used a good traversal algorithm for my project (Havran’s T_REC_B from his thesis, if you were wondering). However, I use the naive median tree-splitting algorithm instead of implementing SAH. Implementing a correct tree for a scene as complex as a Pac-Man level will probably give me enough of a performance boost that I’ll want to do this properly.

Those are my current concrete plans; I probably won’t be able to work on it very much for the next week or so due to finals, but I may be able to get started. If you know of any good resources, or have any advice, please let me know.

I haven’t had enough time to write a post for the last week, so instead I’ll post a link to the pictures the raytracer I was working on generated.

http://www.student.cs.uwaterloo.ca/~nflath/website

I decided to write a little bit about the courses I have this term. Overall, I’m pretty happy with them, although Graphics is the only one I have nothing to complain about. Since the term is nearly over, it seemed like a good idea to reflect on these.

Software Requirements and Specification - SE 457
This course wasn’t one I was particularly looking forward to, but it turned out to be better than I expected. Our prof turned out to be quite good, and while the material isn’t the most interesting I’ve ever learned, but it isn’t as boring as I feared. The assignments are unfortunately not that interesting and a lot of work; they involve reverse-engineering the graduate admissions system. I feel the course could be better if it was more integrated with our design project course. The assignments could be to gather requirements and document the design of our project, instead of something fairly useless.

Graphics - CS 488
This course has been a lot of fun so far, but also lives up to its reputation of being a lot of work. Our professor is good, so the lectures are pretty interesting. The assignments are difficult, starting from 3D tetris and going up to a raytracer, but they are not difficult to get good marks in if you just put in the work - the grading scheme is known and pretty objective. I wasn’t sure how I was going to like this course, not having any real graphics experience previously, but I’m glad I took it. However, I dislike the lack of midterm, since it means there is no indication of what the final will be like.

Introduction to Database Management - CS 348
This course hasn’t been particularly interesting so far. Our prof is decent, which helps, but the material is pretty basic. The assignments are fair, and were representative of what was on the midterm. I probably wouldn’t have taken this class if it weren’t required, but at least it’s not actively bad and is instead just boring.

Concurrency - CS 343
This course is a bit of a mixed bag. The prof is rather mediocre, and a lot of the value in the assignments is obscured by the use of uC++. For those of you that don’t know, uC++ is a C++ dialect that is used by essentially nobody. I really disagree with the use of uC++ for this; I think it should be taught in a higher-level language. As it is, the majority of the time in the assignments is spent debugging C++ issues instead of dealing with actual concurrency; even Java wuoldn’t have nearly as many problems in this. Since uC++ doesn’t use concurrency like any other language, the material from the assignments is also not particularly useful, and as long as this is going to be the case the assignments should be about concurrency, in my opinion. Some of the material is pretty interesting, as long as we are talking about the general form of the concurrency and not uC++, but this isn’t nearly as often as I’d like.

Formal Languages and Parsing - CS 462
The topics covered in this course are really interesting. I like a lot of the theoretical aspects of CS, and this course definitelly is on the very theoretically side. Unfortunately, the lecturer we have is fairly bad, which is disappointing as this was the class I was looking forward to most. The assignments have so far been pretty reasonable, although several of the problems are straight from the book. Again, the lack of midterm means there isn’t necessarily a good way to prepare for the final, but the final is take-home at least.

Design Project - SE 390
I’m still not entirely sure what I think about this course. The entire course revolves around a group project which we pick and continue developing for the next 3 school terms. This is a very cool idea, and a project of this length has brought up some issues that don’t generally come up in school assignments. The actual deliver ables for the project this term are very ill-defined, which is pretty annoying since we are getting an objective grade. The lectures, while entertaining, are also more or less useless - Paul Ward mostly just talks about whatever he wants. It seems a lot like an applied entrepreneurship course, which is neat, but I’m not sure it should be a required class.