What do you hope to learn?

| No Comments

As a student still in the lower division of computer science, I haven't done any big project development in
my life but after studying two years on campus, I have come to know the significance of good programming
practice -- effective comments, good programming style, consistent layout specifications, and defensive
codes, which will make teamwork easier and more efficient. I know for every programmer, what matters
most is technique but for every single student who wants to be an excellent programmer, how to work with
their team is as important as perfect technique. However, at this stage of software development, most have
to rely on teamwork. The world programmer is no longer synonymous with personal heroism. On one
hand, a programmer's complement of codes has to depend on others', on the other hand, his or her codes
will be accessed by others, which implies that the codes must provide reliable function, followed by a clear
expression of author's idea. As a result, standardized and defensive code is necessary. Such as how can
we name our variables and functions properly so that people read it can precisely know their functions,
whether the layout specification is consistent through the whole code, and whether the comment is
accurate and concise? Standardized and straightforward code will be more reusable, more maintainable,
and more convenient to extension. What's more, in a large-scale application software system, a complete
system consists of many fragments, which means the interaction between these fragments is a big deal. If
an error occurs, it maybe won't give feedback immediately, instead it will delay for some time after
transiting among certain functions. When things like this happen, it is very time consuming to find errors.
How can others use functions properly and avoid such problems as much as possible? The answer is
defensive code. In defensive code, there should be no input that can lead to an error. If unexpected data is
used, warnings will remind a programmer at once.
All of the above are what I learned from Csci1901--the most fundamental class for all students of computer
science. At the beginning of the project "railroad", I suffered. We had to build a railroad without knowing all
the specifications and wrote changeable code because the professor would give the "railroad" more
functions week by week. Obvious, having a partner could lessen one's burden, but working well with your
partner was not so easy -let her or him know how your functions worked, how to use it with appropriate
variables, and never get errors when bad data is inputted. Once you mastered the skill to operate with your
partner, it would be done in the twinkling of an eye. I enjoy the great benefit of this class very much--
effective comments, good program style, consistent layout specifications, and defensive codes should
always be use.
In addition, at the end of this course csci3081w, we will learn many useful tools and techniques, but what
attracts me most is debugging because for all programmers even the most talented ones, error is
unavoidable. I think every programmer suffers when they can't find the error even if they think the code is
perfect and it should give the right result. But unfortunately, things do not turn out as one wish. When we
check the code until going mad but still can't find an error and once click on the "execute", it crashes, a
debugger is our last hope. Maybe someone will say it can only help us to find some stupid hidden logic
errors but is of no use to our program development. It's true, but we can't depend on machine to do all our
duties. However, although I'm not skilled at it, but I know the debugger of visual C++ has set breakpoint,
trace the call stack, and disassembly debugging. Even the most common function breakpoint is really
powerful. We can set breakpoint everywhere we want and then execute the program step by step until we
find the problem.
To sum up, if you let me choose one that I want to learn most, it is definitely debugging and I will keep the
good programming practice in my further programming life.
Yujing Sun

Leave a comment

About this Entry

This page contains a single entry by Yujng Sun published on September 27, 2011 7:37 PM.

Challenges of working in teams is the next entry in this blog.

Find recent content on the main index or look in the archives to find all content.



Powered by Movable Type 4.31-en