CSC 430 Useful Links from Fall 2014
Amber Bennett Kyler Branaum Brandon Burgess Cory Canter Brett Gibson Tony Hagerty Ryan Holland Caleb Lawson
Dustin Morrow Michael Musick Kody Myers Ryan Sanders Kevin Taylor Stanton Vincent Kyle Young Lindsey Young
article explains some of the more commonly used Design Patterns using
code samples, pictures an analogies to make it easy to understand and
visualize how the patter ultimately works.
website has information on many different design patterns. There are
examples and pictures and they should when to use each one and how to
This GitHub cheat sheet outlines the basic and common command line instructions for using Git effectively.
free online Git course. It starts with an intro level and has
challenges after each video for practice. The challenges have an
in-browser console that allows you to try git without downloading
anything to your computer.
website has a lot of resources about version control. "An introduction
to version control" goes through some of the specifics of version
control, explaining why you should use it and what you should use. They
also show how to use Git on OS X, Windows, and Linux.
is a tutorial that talks a lot about software/unit testing. It includes
links to a Quick Reference Guide, useful resources, and a PDF of the
actual tutorial. The Quick Reference Guide itself has a lot of good
information itself, including when to start and stop testing, types of
testing and testing methods, etc.
tutorial for JUnit is for beginners to learn the basic functionality of
JUnit testing. There are code samples included and step-by-step
instructions to learn these basics. The tutorial also includes links to a
JUnit Quick Reference Guide, useful resources, Java tutorials, JUnit
interview questions with answers to help you know what to say if someone
asks you these questions, and a PDF for a quick JUnit tutorial.
is a clean code cheat sheet that has information on just about anything
you can think of from naming to class design to unit testing.
A short overview that would be useful if you needed a quick reference about clean coding.
10 tips for keeping your code clean.
of these are pretty self explanatory in the URL.
on the approach of software development
on mobile software development
powerpoint on the software life cycle
some design pattern in Ada that I thought was pretty interesting
is a little information about .NET design patterns
Although this article is a little hard to read due to a
language barrier, i found it to be very useful in practicing writing
clean code to begin with.
This article is specifically about cleaning c code, but could be used for any language
These are 12 tips for cleaning up your html that may seem
obvious, but people forget al lthe
Very Useful and easily understood slides for cleaning up your
java. Make sure you click the link to download the slides.
A tutorial on how to make your c++ code much simpler, cleaner, and robust.
References several useful version control systems such as git and libreSource.
Explains how to download and install git. Also goes into detail on
how to use evennia and how to share your publicly and privately.
Really focuses on git and how it shines when compared to other
version control systems. The comments are actually worth reading
A very in depth article that introduces what version control systems
are and gives insight into why you might choose to use various
This is a fairly lengthy pdf but it has all the information i
could think of that you would need for version control.
A somewhat comical collection of helpful tips and tricks for
developing cleaner code.
A lengthy powerpoint presentation about making more
An interesting debate between self-documenting code and
A very interesting article about clean-coding functional
A forum for writing cleaner object-oriented code.
An article for help with Agile Development
A basic guide for Agile Development beginners
An article and powerpoint presentation regarding a few principles
to use with Agile Development.
A back and forth article debating the pros and cons of Agile
and Waterfall Development.
A detailed review of 7 of the best version control systems.
- 10 Principles for keeping
your programming code clean
- 10 Most in-demand software
development skills for 2014
- PDFs and tutorials for
design patterns in Java
- Powerpoint presentation
over writing clean code within C# and .NET
- A good explanation of how
to write a Unit Test.
- Clean code cheat sheet to
- Code refactoring with
agile software development
- Clean coding tips from the
book "Clean Code, Evolved"
- An online program that
- Great article over the
concepts of writing clean code, includes sample code for each
A collection of design patterns specifically for cloud
An online book of design patterns for game development.
An article exploring whether design patterns are effective
Learn git from one of the most popular git hosting services.
eBook, Video, or Webinar for learning git.
Fairly comprehensive tutorial on git.
An article about going beyond Bob Martin's clean code.
Bob Martin's entire blog about clean coding.
Why unit testing and integration testing matters.
How Agile and unit testing integrate.
Free stuff for student developers and those with a
Java Design Patterns
Here are some other good links that deserve some recognition.
^-- Definitely check that out.
I'm not really sure how to classify most of these. The first
one is obviously a Git link, but the rest are really just very general
topics aimed at helping developers hone their craft.
Link 1 - "A successful Git branching model"
is the branching strategy that we currently use at my place of
employment. Though we use SVN instead of Git, the same basic concepts
apply and has worked out pretty well so far for us.
Link 2 - "I'm a phony. Are you?"
post from Scott Hanselman, a "rock star" developer from Microsoft. When
you first begin your career as a developer, you're going to get into
situations where you start to lose confidence in yourself. It can reach
the point where you start wondering if you have any business being a
programmer at all. "Maybe I'm just not smart enough for this? Everyone
else seems so much better than me." Scott provides some insight on how
even the most seasoned developers share this sentiment and that it's
actually a good thing. Arrogance has no place in our profession, but
occasional feelings on inadequacy can push us to become better at our
craft than we were yesterday.
Bonus - "Being a Phony with Jon Skeet":
Even Jon Skeet, one of the biggest StackOverflow contributors, can be a phony.
More bonus thoughts from Jeff Atwood et al:
"On The Meaning of 'Coding Horror'"
"Sucking Less Every Year"
"We Make Shitty Software.. With Bugs!"
Link 3 - "The Joel Test: 12 Steps to Better Code"
post by Joel Spolsky, CEO and cofounder of StackOverflow and founder of
Fog Creek Software, developer of bug tracking software FogBugz. Written
all the way back in 2000, Joel provided 12 criteria to use to measure
the effectiveness of an agile software development team. Sadly, there
are still many organizations out there that still fail this test, which
really wasn't all that revolutionary even 14 years ago. This is a useful
tool that you can use as a job candidate to evaluate the teams with
which you may be working. As a rule of thumb, good, healthy development
teams score high (if not perfect) on the Joel Test.
Bonus - "The Joel Test - Updated for 2010" by Bill Tudor:
So your team passes the Joel Test? How about Level 2?
Link 4 - "My Thoughts on Work/Life Balance at Microsoft"
good quality code for your organization expands beyond the walls of
your office. If you're tired, overworked, or suffer from low morale,
your code quality is going to suffer no matter how experienced you are.
It's going to take you longer to come up with optimal solutions - if you
come to them at all. Jon Gallant's blog post explores maintaining a
healthy work/life balance in order to help maintain the most important
tool in your toolbox: you.
Link 5 - "Recommended Reading for Developers"
Atwood of the blog Coding Horror (also cofounder of StackOverflow)
lists his top books for becoming a better programmer. I've read through
Code Complete 1 and 2, The Design of Everyday things, The Pragmatic
Programmer, and will be starting on The Mythical Man-Month soon. Though
some of these books are many years old, I would argue that they should
be considered "required reading," as the wisdom contained within them is
Link 6 - "The Programmer's Bill of Rights"
from Jeff Atwood, this is another blog post stressing the importance of
the tools that lie outside of your IDE. We spent a lot of time in class
talking about software tools that can help make you an effective
programmer, but what about your physical environment? Slow computers,
slow internet, and distracting working conditions can totally negate any
productivity you might gain from writing maintainable code.
Bonus - "A Field Guide to Developers" by Joel Spolsky:
paints a picture of the company that every programmer dreams of working
for, though directed mostly toward owners of software companies (hence a
bonus link). Happy developers are productive developers.
Joel has a book out called "Joel On Software" that I would add to
Jeff's recommended reading list. It's a compilation of his best blog
posts that have been edited, annotated, and reformatted for print
publication. Or just find the articles directly on his blog: http://www.joelonsoftware.com/
Link 7 - "Scott Hanselman's Ultimate Developer and Power Users Tool List for Windows"
has been maintaining this list of productivity tools since 2003. This
guy has been in the trenches for over 15 years and like any veteran
craftsman, lives and dies by making sure he's using the right tool for
Link 8 - "This I believe... the developer edition"
Cauldwell outlines a set of guiding principles that he drafted up for
his project's new team members, but are generic enough to apply to any
project. This is pretty much "The Joel Test" on steroids.
Link 9 - "Up and Down the Ladder of Abstraction"
phrase "levels of abstraction" is thrown around quite frequently in
computer science, but it's a difficult thing to explain. Most seasoned
programmers will tell that abstraction is something you'll only learn
once you've spent months working on a complex application. Bret Victor
systematically steps us through thinking about a problem and helps us
visualize the different layers of abstraction as we try to solve it.
This is a great introduction to object-oriented design, though the term
"object-oriented" is never once mentioned.
Bonus - "Inventing on Principle" also by Bret Victor
is an hour-long talk by Bret in which he inspires others with his
belief that creative people have a duty to make their ideas manifest.
"Ideas are very important. I think that bringing ideas into the world is
one of the most important things that people can do." To that end, Bret
demos some really amazing software concepts that challenge the whole
"write code, compile, run, test, change code, compile, run, test
changes, change code, compile, ..." cycle in which many developers find
Link 10 - "StackOverflow Deleted Questions"
is a great resource for questions that have a specific answer, but
questions that are considered "opinion" questions are quickly killed off
by the moderators. This is a repository of deleted questions from
StackOverflow which don't fit the site's guidelines, but contain a
fountain of wisdom.
Some of the top items include:
- "I'm graduating with a Computer Science degree but I don't feel like I know how to program."
- "What is the single most effective thing you did to improve your programming skills?"
- "How do you clear your mind after a day of coding?"
- "What do you use to keep notes as a developer?"
many of these are survey questions, but I find it very helpful to get
insights on questions like these from other programmers. Learning from
each other and building off each other are crucial if our industry is to
grow and flourish.
I find it kinda sad that
these topics have been suppressed, as it's quite obvious that they have
value to the community. Thankfully, someone out there went through the
trouble of preserving them.
(great git tutorial)
(clean code cheat sheets)
(unit testing run-down)
(git cheat sheet)
(git tricks that could come in handy)
(cleaning code, but in HTML)
(agile development tools - brief but good information)
(Never went over much, but scrum is good agile development)
(More info. on scrum)
(lots of design patterns described in detail - very useful if wanting to learn a lot of the patterns)
Lecture from MIT on Design Patterns. Gives explanations and examples of several types of patterns.
page with links to other Wikipedia pages on specific Design Patterns.
Very helpful and organized. Gives explanations and examples of many
Slides from Duke University on understanding the basics of Design Patterns. Gives a great explanation on OO Design Patterns.
Tutorials for newcomers on using Git. Includes advanced Git tutorials for the more experienced Git individuals.
A tutorial introduction to Git.
website to learn Git. Explains what Git is and does, explains how to
setup Git and is very helpful with notation and explanation.
website! Teaches you the basics and advanced uses of Git by giving
descriptions and explanations all while you are actively using Git!
Fantastic way to learn Git! Hands-on and interactive.
that describes and shows through examples how to make and implement
clean code. It also describes methods for keeping code clean rather than
having to go back and clean after the "nasty" code is complete.
Describes the top 15+ practices and facets for writing clean code.
Describes and lists the top nine qualities clean code should have.
Tutorial on using JUnit. Very descriptive and uses examples.
Describes what JUnit is and how to use it. Starts off very basic. Good resource for beginners.
Great tutorial and introduction to EasyMock. Starts off with descriptions, then gives examples.
Tutorial on what Agile Development is. Great resource for starting off in understanding what Agile Development really is.
This talks about a programmers personal experience in growing
to understand and appreciate clean code.
An interview with two people that developed the Clean Code
Developer School. They talk about the most common mistakes with Clean
Code and their personal mistakes in their journey in programming and
become a Clean Code Programmer.
A awesome tutorial that takes you step by step teaching you git and
showing you some amazing things you can do with it.
A detailed article with graphs that show what git is and does in a
more computer science theory way then a "this is how you use git" kind
A Microsoft site explaining how to use the team project and source
control built into the Visual Basic Studio, for a look into how to use
source control in a .NET environment.
Talks about the purpose of a unit test, the two major types and how
to properly make one and the bad practices that come some of the usual
created unit tests.
IBM's advice on how to have a good environment for software
construction and how to achieve less headaches in the future when
dealing with the software your developing. There is some IBM propaganda
but overall it is good advice.
The URL is pretty self-explanatory.
This gives more advice if you were starting a company then
something most people would be doing in the present but I think it is
still important to understand what the idea modern environment is today.
This article talks about how someone should understand that the
best practices and the best core principles are the same and that new
"best practices" are just things that programmers can get lost in and
never actually create code well and effectively. The principles are
simplistic and might seem obvious but are always good to be reminded.
3.0, 4.0, and 5.0 Guidelines
A list of guidelines for C# developers. Covers
concepts like class design, member design, maintainability, naming,
performance, framework, documentation, layout, and other minor
explains itself pretty well. The entire book on agile principles,
patterns, and practices in C#.
A summary of a very recently (October 2014)
released book on agile development in C#. It touches on SOLID
principles as mentioned later in my links.
using Microsoft’s version control system, Team Foundation Server,
in Visual Studio 2010
vs Elegant Code
A brief-ish blog
post highlighting the importance of writing code that other people
will want to read and understand.
The mentioned principles will ideally in practice
yield a more maintainable system.
While a fairly simple concept, it’s important to
keep in mind that you should avoid repeating information or code in
your work. Databases should be efficient, documentation should not
Concepts of what classes and objects in OOP should
This kinda stays in line with the DRY link
earlier, this concept states that just as you shouldn’t rewrite
things you already have, you shouldn’t write things you don’t
Covers six principles for organizing classes into
more manageable and cohesive packages.
Python, Ruby, C, SQL, and Regex. The philosophy behind these
tutorials is “Less talk, more code”.
Developers University Consortium. A load of resources, including
courses, stories, discussions, and dev tools for development.
The first in a
series of 3 tutorials on Nunit testing in a C# developer environment.
resource for getting started using Nunit.