Sign in
MSDN Blogs
Microsoft Blog Images
More ...
Browse by Tags
Search
Archives
Archives
September 2012
(3)
August 2012
(19)
July 2012
(17)
June 2012
(16)
May 2012
(18)
April 2012
(21)
March 2012
(22)
February 2012
(24)
January 2012
(19)
December 2011
(21)
November 2011
(18)
October 2011
(18)
September 2011
(17)
August 2011
(24)
July 2011
(23)
June 2011
(21)
May 2011
(27)
April 2011
(25)
March 2011
(28)
February 2011
(20)
January 2011
(22)
December 2010
(19)
November 2010
(19)
October 2010
(21)
September 2010
(18)
August 2010
(20)
July 2010
(15)
June 2010
(17)
May 2010
(19)
April 2010
(24)
March 2010
(22)
February 2010
(22)
January 2010
(19)
December 2009
(20)
November 2009
(14)
October 2009
(17)
September 2009
(17)
August 2009
(19)
July 2009
(20)
June 2009
(22)
May 2009
(17)
April 2009
(22)
March 2009
(20)
February 2009
(18)
January 2009
(23)
December 2008
(21)
November 2008
(22)
October 2008
(23)
September 2008
(22)
August 2008
(23)
July 2008
(22)
June 2008
(22)
May 2008
(23)
April 2008
(22)
March 2008
(22)
February 2008
(24)
January 2008
(24)
December 2007
(23)
November 2007
(25)
October 2007
(24)
September 2007
(24)
August 2007
(23)
July 2007
(22)
June 2007
(24)
May 2007
(26)
April 2007
(21)
March 2007
(28)
February 2007
(28)
January 2007
(26)
December 2006
(24)
November 2006
(20)
October 2006
(26)
September 2006
(26)
August 2006
(29)
July 2006
(26)
June 2006
(26)
May 2006
(34)
April 2006
(41)
March 2006
(33)
February 2006
(28)
January 2006
(25)
December 2005
(16)
November 2005
(18)
October 2005
(10)
September 2005
(11)
August 2005
(10)
July 2005
(1)
Tags
C#
Careers
Computer Science Education
Conferences
Contests
CSTA
Diversity
education
Education Technology
first programming experience
fun
Game Programming
Imagine Cup
Kodu
Microsoft
Professional Development
Programming
Projects
rant
Robotics
teaching
Visual Basic
Visual Studio
Windows Phone 7
XNA
Common Tasks
Blog Home
Email Blog Author
About
RSS for posts
RSS for comments
Tagged Content List
Blog Post:
Seven Rules for Beginning Programmers
Alfred Thompson
Paul Vick posted these Seven Rules for Beginning Programmers earlier this week and I have been thinking about them a lot. They make sense to me. As a professional developer you have to understand that these are the rules for beginners. The last item concludes with “ You may go beyond these rules after...
on
19 May 2011
Blog Post:
Wisdom in Lists–Really?
Alfred Thompson
Like a lot of people I have an affection for lists that condense a lot of wisdom into a brief set of statements or items. Some time ago I wrote a series of posts on Programming Proverbs for example. That list (reproduced at the bottom of this post) came from a book that was every influential to me, especially...
on
17 Nov 2010
Blog Post:
Revisiting the GoTo Statement
Alfred Thompson
In yesterday’s post I named the “GoTo” statement as basically a bad thing. To my surprise this started a short Twitter discussion and also came up in the comments. So I did a bit more research. I found this fairly balanced article called “Using gotos” by Steve McConnell . And Mark Guzdial twittered a...
on
21 May 2009
Blog Post:
Programming Proverbs 26: Don't be afraid to start over
Alfred Thompson
The statement "Don't be afraid to start over" seems obvious to the breed of programmer today who starts off assuming that they will always throw away the first several versions of their program. There is some indication that this idea of rapid prototypes followed by several revisions, starting over from...
on
13 Jul 2007
Blog Post:
Programming Proverbs 25 Consider another language
Alfred Thompson
What's that old line about if all you have is a hammer all your problems look like nails? There are some programmers who only have one programming language in their tool box. They way they look at programming problems is colored by what can be done in that language and how things are done in that language...
on
11 Jul 2007
Blog Post:
Programming Proverbs 24: Re-read the manual
Alfred Thompson
I've been telling students and others that " reading the manual is the shortcut " for years. I really believe it. When a program isn't working out the way one expects re-visiting the manual is often a great short cut. Sometimes the manual in question is really the documentation for the project or the...
on
9 Jul 2007
Blog Post:
Programming Proverbs 23: When the program is correct, produce good output
Alfred Thompson
This proverb is a corollary to the last post in this series . While getting the program correct and the right results is the first priority that doesn't mean that the results can be tossed out in any old way. A programmer's program, a program written only to be used by the person who wrote it, can get...
on
6 Jul 2007
Blog Post:
Programming Proverbs 22: Get the program correct before trying to provide good output
Alfred Thompson
In some ways I think this is one of those proverbs that was more important back in the days when batch jobs were the way things worked. On the other hand there is an important, if perhaps more general, bit of advice here. That advice is to spend the time up front to get the right results before getting...
on
29 Jun 2007
Blog Post:
Programming Proverbs 21: Hand-check the program before running it
Alfred Thompson
Hand checking code seems to be a dying art. At least for students that is. Throw some code into the IDE and hit F5 to compile and run and then see what happens. "Ready, Fire, Aim" At the risk of sounding like the old guy reminiscing about the good old days that were not really so good I can't help...
on
22 Jun 2007
Blog Post:
Programming Proverbs 20: Provide good documentation
Alfred Thompson
Well what in the world is good documentation? Now there is a question for the ages. Lots of programmers hate to document their work. I've heard more than a few programmers over the years say things like "you want documentation? Read the code. The code is self explanatory." Ah, yeah, right. Most will...
on
15 Jun 2007
Blog Post:
Programming Proverbs 19: Prettyprint
Alfred Thompson
While compilers generally don't care about how code looks as long as it follows the rules on syntax. Those rules generally are there for the convenience of the compiler and not for to make the code easy to read by humans. In fact there is an annual contest to write the least understandable C program...
on
8 Jun 2007
Blog Post:
Programming Proverbs 18: Use Comments
Alfred Thompson
Is there anything so obvious to an experienced programmer that is so hard to get across to students than comments? Students know that they are so smart that they will remember everything about their programs. And of course they think they are smart enough to figure out any other program they come across...
on
25 May 2007
Blog Post:
Programming Proverbs 17: Never assume the computer assumes anything
Alfred Thompson
The computer doesn't know what you mean, it only knows what you tell it. How often do we tell people that? Pretty often if I am any indication. And yet people do assume all the time. They assume that variables will be cleared out by the system before being used. In some languages they are and in some...
on
18 May 2007
Blog Post:
Programming Proverbs 16: Build in debugging techniques
Alfred Thompson
When ever programming teachers get together one of the debates that often starts up is between using a built-in debugger or using other debugging tools - most commonly extra print/display statements. It is an interesting debate and can get quite religious at times. I have been a long fan of debuggers...
on
11 May 2007
Blog Post:
Programming Proverbs 15: Avoid tricks
Alfred Thompson
Tricks are fun. It is often pretty satisfying to add a bit of code that is tricky, difficult or perhaps something that not everyone is going to understand. Well it's fun when it is done but later when the code has to be changed, modified, or worse - debugged its not always so much fun. Tricks often...
on
13 Apr 2007
Blog Post:
Programming Proverbs 14: Avoid implementation-dependent features
Alfred Thompson
Implementation-dependent features are features or the the hardware or operating system or other part of the platform that is not available on other platforms. For example a specific piece of floating-point hardware or a language feature that is not part of the standard language specification or an operating...
on
6 Apr 2007
Blog Post:
Programming Proverbs 13: Do not recompute constants within a loop
Alfred Thompson
This was big in it's time because compilers were pretty dumb back then. If you added one to three inside a loop that ran a thousand times then the computer would add one to three a thousand times. Hopefully it would come up with four each time. This was of course very wasteful of time and processing...
on
26 Mar 2007
Blog Post:
Programming Proverbs 12: Leave loop variables alone
Alfred Thompson
Another way of expressing this is to use loop as if they were read-only constants. Loop variables should be initialized and changed only in the loop statement itself. The problem with doing it anywhere else is that it is too easy to either make the modification incorrectly or to do so in the wrong place...
on
19 Mar 2007
Blog Post:
Programming Proverbs 11: Use intermediate variables properly
Alfred Thompson
Intermediate variables are variables that are used to break calculations down into several steps. For example the use of intermediate variables takes something like this: x = a + b * (sqrt(y) + w) and turns it into something like this: var1 = a + b var2 = sqrt(y) + w x = var1 * var2 ...
on
15 Mar 2007
Blog Post:
Programming Proverbs 10: Use good mnemonic names
Alfred Thompson
Mnemonic names are names that make it clear what they are for. I've always viewed mnemonic names as being an important part or self-documenting code. There is little question that they make reading someone's code a lot easier. But there is probably a better reason for using them even if you are working...
on
12 Mar 2007
Blog Post:
Programming Proverb 9: Get the syntax correct now, not later
Alfred Thompson
How often does students say they'll fix the syntax later? They are in such a rush to enter their code that they let "little" syntax errors slide until later. Or worst still they enter code carelessly assuming that the compiler with find and highlight the syntax errors for them. It's a tempting way to...
on
8 Mar 2007
Blog Post:
Programming Proverbs 8: Avoid side effects
Alfred Thompson
Side effects are actions that change things outside of a procedure, function or method. Generally this happens when a procedure modifies a global variable. I'm tempted to suggest that this proverb might just as well be "avoid unnecessary global variables." The problem here is that since the activity...
on
8 Mar 2007
Blog Post:
Programming Proverbs 7: Avoid unnecessary GOTO's
Alfred Thompson
This was quite the controversy when it all started. Today some people go through a whole programming course without even learning that the language they are using even has a GOTO statement. An unconditionally GOTO statement barely exists in most programs today. It wasn't that way 40 years ago though...
on
7 Mar 2007
Blog Post:
Programming Proverbs 6: Use procedures
Alfred Thompson
The word "procedures" here is a bit of an anachronism I guess. Today we talk mostly of "methods " Perhaps we talk about "functions" or "subroutines" but we are really talking about the same things. We are talking about small routines with a defined way in and a defined way out. Generally we work pretty...
on
26 Feb 2007
Blog Post:
Programming Proverbs 5: Construct the program in logical units
Alfred Thompson
This is the fifth of a series of posts based on the book Programming Proverbs by Henry Ledgard . The index for the series is an earlier post and discussion of the list as a whole is taking place in the comments there . Comments on this "proverb" are of course very welcome here. To many Construct the...
on
22 Feb 2007
Page 1 of 2 (29 items)
1
2