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

Amber Bennett:
This 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.
This website has information on many different design patterns. There are examples and pictures and they should when to use each one and how to use it.
This GitHub cheat sheet outlines the basic and common command line instructions for using Git effectively.
A 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.
This 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.
This 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.
This 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.
This 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.

Kyler Branaum:

clean code-

most of these are pretty self explanatory in the URL.

software dev-
views on the approach of software development
tips on mobile software development
a powerpoint on the software life cycle

Design Patterns-
just some design pattern in Ada that I thought was pretty interesting
his is a little information about .NET design patterns

Brandon Burgess:

Clean code
1.           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              time. 

    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.

Version control
    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 as well.

     A very in depth article that introduces what version control systems are and gives insight into          why you might choose to use various systems. 

    This is a fairly lengthy pdf but it has all the information i could think of that you would need for     version control.

Cory Canter:


A somewhat comical collection of helpful tips and tricks for developing cleaner code.

A lengthy powerpoint presentation about making more maintainable code.

An interesting debate between self-documenting code and commented code

A very interesting article about clean-coding functional languages.

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.

Brett Gibson

Tony Hagerty:

Git References:

Design Patterns: (Java quick guide) (Quick overview) (Overview/Tutorial)

Clean Code: (Easy, free way to cleanup Javascript, HTML, and CSS code) (Advice on cleaning up code)

Unit-Testing: (Intro to Java Unit-Testing) (Javascript Unit-Testing framework)

Ryan Holland:

- 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 live by

- Code refactoring with agile software development

- Clean coding tips from the book "Clean Code, Evolved"

- An online program that will clean up HTML, CSS, and Javascript code

- Great article over the concepts of writing clean code, includes sample code for each concept.

Caleb Lawson:

Design Patterns
        A collection of design patterns specifically for cloud applications.
        An online book of design patterns for game development.
        An article exploring whether design patterns are effective or not.

Version Control
        Learn git from one of the most popular git hosting services.
        eBook, Video, or Webinar for learning git.
        Fairly comprehensive tutorial on git.

Clean Code
        An article about going beyond Bob Martin's clean code.
        Bob Martin's entire blog about clean coding.

Unit Testing
        Why unit testing and integration testing matters.
        How Agile and unit testing integrate.

Free stuff for student developers and those with a .edu address.

Dustin Morrow:

Java Design Patterns


Clean Code

Here are some other good links that deserve some recognition.

^-- Definitely check that out.

Michael Musick:

1. - a short article covering the implementation of the observer pattern in java in real world applications

2. - article comparing and contrasting factory pattern and the abstract factory pattern (lots of code samples in the article, download links available for the code)

3. - article covering multiple design patterns to include some not covered in class, contains code samples with download links as well as real world examples

4. - an article that covers the importance of variable names and documentation in software design

5. – an article covering good programming techniques to include formatting indentation and commenting

6. - an article that provides helpful tips for clean coding practices

7. - good and bad practices for unit testing

8. - another helpful article covering details and examples regarding unit testing

 9. - a very helpful article covering tips and advice for version control

 10. - a very brief article covering simple pointers in regards to version control

Kody Myers

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"
This 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?"
Blog 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"
Blog 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"
Writing 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"
Jeff 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 truly timeless.

Link 6 - "The Programmer's Bill of Rights"
Also 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:
Joel 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. 

BTW, 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:

Link 7 - "Scott Hanselman's Ultimate Developer and Power Users Tool List for Windows"
Scott 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 the job.

Link 8 - "This I believe... the developer edition"
Patrick 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"
The 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
This 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 themselves entangled.

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?"

Admitted, 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.

Ryan Sanders:

---Bad Code---

Kevin Taylor:
(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)

Stanton Vincent:

Design Patterns:
Lecture from MIT on Design Patterns. Gives explanations and examples of several types of patterns.
Wikipedia page with links to other Wikipedia pages on specific Design Patterns. Very helpful and organized. Gives explanations and examples of many design patterns.
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.
Amazing website to learn Git. Explains what Git is and does, explains how to setup Git and is very helpful with notation and explanation.
Fantastic 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.

Clean Code:
Tutorial 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.

Agile Development:
Tutorial on what Agile Development is. Great resource for starting off in understanding what Agile Development really is.

Kyle Young:

        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 of way.
    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.

Lindsey Young:

C# 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 guidelines.

C# Agile Development
Link 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.

C# Version Control
Tutorial on using Microsoft’s version control system, Team Foundation Server, in Visual Studio 2010

Clean vs Elegant Code
A brief-ish blog post highlighting the importance of writing code that other people will want to read and understand.

Design Patterns/Principles
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 repeat itself.
Concepts of what classes and objects in OOP should do, specifically.
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 need yet.
Covers six principles for organizing classes into more manageable and cohesive packages.

Tutorials on Python, Ruby, C, SQL, and Regex. The philosophy behind these tutorials is “Less talk, more code”.
Google 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.
Official Nunit resource for getting started using Nunit.