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:

http://code.tutsplus.com/articles/a-beginners-guide-to-design-patterns--net-12752
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.

www.oodesign.com/
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.
https://training.github.com/kit/downloads/github-git-cheat-sheet.pdf
This GitHub cheat sheet outlines the basic and common command line instructions for using Git effectively. 
https://www.codeschool.com/courses/git-real
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. 

http://guides.beanstalkapp.com/
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.
http://www.tutorialspoint.com/software_testing/index.htm
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.
http://www.tutorialspoint.com/junit/
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. 
http://www.planetgeek.ch/wp-content/uploads/2014/11/Clean-Code-V2.4.pdf
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.
https://www.harding.edu/fmccown/writingcleancode.pdf
A short overview that would be useful if you needed a quick reference about clean coding.
http://www.onextrapixel.com/2011/01/20/10-principles-for-keeping-your-programming-code-clean/
10 tips for keeping your code clean.



Kyler Branaum:

clean code-

http://cvuorinen.net/2014/04/what-is-clean-code-and-why-should-you-care/

http://www.telerik.com/help/justcode/code-cleaning-clean-code.html

http://www.javacodegeeks.com/2012/05/top-7-programmers-bad-habits.html

http://blog.jetbrains.com/pycharm/2014/06/write-clean-professional-maintainable-quality-code-in-python/

most of these are pretty self explanatory in the URL.

software dev-
web.stevens.edu/njcse/Software.ppt
views on the approach of software development
http://www.intelligenceinsoftware.com/featur/feature/sw_dev_tools_and_tips/mobile_software_development/index.html#.VIZ2U5PF_2A
tips on mobile software development
http://www.powershow.com/view/247925-ZmU1M/Software_Development_Life_Cycle_All_Types_of_SDLC_Models_powerpoint_ppt_presentation
a powerpoint on the software life cycle


Design Patterns-
http://www.adacore.com/adaanswers/gems/gem-117-design-pattern-overridable-class-attributes-in-ada-2012
just some design pattern in Ada that I thought was pretty interesting

http://www.dofactory.com/net/design-patterns
t
his is a little information about .NET design patterns



Brandon Burgess:

Clean code
1.http://www.codeproject.com/Articles/539179/Some-practices-to-write-better-Csharp-NET-code           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.

2.http://dotnet.dzone.com/news/cleaning-up-your-c-closet-maki
     This article is specifically about cleaning c code, but could be used for any language

3.http://www.smashingmagazine.com/2008/11/12/12-principles-for-keeping-your-code-clean/
    These are 12 tips for cleaning up your html that may seem obvious, but people forget al lthe              time. 

4.http://conferences.embarcadero.com/en/article/33144
    Very Useful and easily understood slides for cleaning up your java. Make sure you click the link to download the slides.

5.http://www.codeproject.com/Articles/216077/Making-Your-Cplusplus-Code-Robust
     A tutorial on how to make your c++ code much simpler, cleaner, and robust.
 

Version control
1.http://www.smashingmagazine.com/2008/09/18/the-top-7-open-source-version-control-systems/
    References several useful version control systems such as git and libreSource.

2.https://github.com/evennia/evennia/wiki/Version-Control
    Explains how to download and install git. Also goes into detail on how to use evennia and how to     share your publicly and privately.

http://www.cimgf.com/2008/06/03/version-control-makes-you-a-better-programmer/
    Really focuses on git and how it shines when compared to other version control systems. The         comments are actually worth reading as well.

4.http://www.codeproject.com/Articles/431125/Choosing-a-Version-Control-System-A-Beginners-Tour
     A very in depth article that introduces what version control systems are and gives insight into          why you might choose to use various systems. 

5.http://ericsink.com/vcbe/vcbe_a4_lo.pdf
    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:

CLEAN CODE:
https://www.butterfly.com.au/thinking/blog/entry/clean-high-quality-code-a-guide-on-how-to-become-a-better-programmer

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

http://www.slideshare.net/avalanche123/clean-code-5609451

A lengthy powerpoint presentation about making more maintainable code.

http://programmers.stackexchange.com/questions/51307/self-documenting-code-vs-commented-code

An interesting debate between self-documenting code and commented code

http://programmers.stackexchange.com/questions/254631/applying-the-principles-of-clean-code-to-functional-languages

A very interesting article about clean-coding functional languages.

http://www.quora.com/What-are-tips-to-writing-clean-object-oriented-code-in-JavaScript

A forum for writing cleaner object-oriented code.


AGILE DEVELOPMENT:

http://www.jamesshore.com/Agile-Book/coding_standards.html

An article for help with Agile Development

http://glenngillen.com/thoughts/quickstart-guide-to-agile

A basic guide for Agile Development beginners

http://www.allaboutagile.com/what-is-agile-10-key-principles/

An article and powerpoint presentation regarding a few principles to use with Agile Development.

https://www.udemy.com/blog/agile-vs-waterfall/

A back and forth article debating the pros and cons of Agile and Waterfall Development.


VERSION CONTROL:

http://www.smashingmagazine.com/2008/09/18/the-top-7-open-source-version-control-systems/

A detailed review of 7 of the best version control systems.




Brett Gibson



Tony Hagerty:

Git References:
http://vogella.com/tutorials/Git/article.html
http://gitref.org/
https://www.atlassian.com/git/

Design Patterns:
http://www.tutorialspoint.com/design_pattern/design_pattern_quick_guide.htm (Java quick guide)
http://code.tutsplus.com/articles/a-beginners-guide-to-design-patterns--net-12752 (Quick overview)
http://sourcemaking.com/design_patterns (Overview/Tutorial)

Clean Code:
http://www.dirtymarkup.com/ (Easy, free way to cleanup Javascript, HTML, and CSS code)
http://www.ats.ucla.edu/stat/sas/library/nesug00/ap2004.pdf (Advice on cleaning up code)

Unit-Testing:
http://tutorials.jenkov.com/java-unit-testing/index.html (Intro to Java Unit-Testing)
http://qunitjs.com/ (Javascript Unit-Testing framework)



Ryan Holland:

1. http://www.onextrapixel.com/2011/01/20/10-principles-for-keeping-your-programming-code-clean/
- 10 Principles for keeping your programming code clean

2. http://www.cybercoders.com/insights/10-most-in-demand-software-development-skills-for-2014/
- 10 Most in-demand software development skills for 2014

3. http://www.tutorialspoint.com/design_pattern/
- PDFs and tutorials for design patterns in Java

4. http://www.slideshare.net/dhelper/writing-clean-code-in-c-and-net
- Powerpoint presentation over writing clean code within C# and .NET

5. http://www.codeproject.com/Articles/10105/Writing-Your-First-Unit-Test
- A good explanation of how to write a Unit Test.

6. http://www.planetgeek.ch/wp-content/uploads/2014/11/Clean-Code-V2.4.pdf
- Clean code cheat sheet to live by

7. http://www.versionone.com/agile-101/refactoring.asp
- Code refactoring with agile software development

8. http://davefancher.com/2014/05/28/clean-code-evolved/
- Clean coding tips from the book "Clean Code, Evolved"

9. http://www.dirtymarkup.com/
- An online program that will clean up HTML, CSS, and Javascript code

10. http://code.tutsplus.com/articles/how-to-write-code-that-embraces-change--net-29716
- Great article over the concepts of writing clean code, includes sample code for each concept.



Caleb Lawson:

Design Patterns
    http://msdn.microsoft.com/en-us/library/dn568099.aspx
        A collection of design patterns specifically for cloud applications.

    http://gameprogrammingpatterns.com/contents.html
        An online book of design patterns for game development.

    http://www.infoq.com/articles/design-patterns-magic-or-myth
        An article exploring whether design patterns are effective or not.

Version Control
   
https://try.github.io/levels/1/challenges/1
        Learn git from one of the most popular git hosting services.

    http://www.git-tower.com/learn/
        eBook, Video, or Webinar for learning git.

    http://www.vogella.com/tutorials/Git/article.html
        Fairly comprehensive tutorial on git.

Clean Code
   
http://davefancher.com/2014/05/28/clean-code-evolved/
        An article about going beyond Bob Martin's clean code.
   
    http://blog.cleancoder.com/
        Bob Martin's entire blog about clean coding.

Unit Testing
   
http://henrikwarne.com/2014/09/04/a-response-to-why-most-unit-testing-is-waste/
        Why unit testing and integration testing matters.
    http://www.stickyminds.com/better-software-magazine-article/you-cant-be-agile-without-automated-unit-testing
        How Agile and unit testing integrate.

Bonus
  
  https://education.github.com/pack
       
Free stuff for student developers and those with a .edu address.


Dustin Morrow:

Java Design Patterns

http://www.fluffycat.com/Java-Design-Patterns/

http://www.oodesign.com/

http://javabynataraj.blogspot.com/2011/05/factory-design-pattern-with-real-time.html

http://www.vogella.com/tutorials/DesignPatterns/article.html

GIT

http://code.tutsplus.com/tutorials/easy-version-control-with-git--net-7449

http://isis.apache.org/contributors/git-cookbook.html

Clean Code

http://www.lagerweij.com/2011/05/28/code-cleaning-a-refactoring-example-in-50-easy-steps/

http://javarevisited.blogspot.com/2011/08/code-comments-java-best-practices.html

http://www.javaworld.com/article/2077577/learn-java/java-tip-75--use-nested-classes-for-better-organization.html

http://code.tutsplus.com/tutorials/top-15-best-practices-for-writing-super-readable-code--net-8118


Here are some other good links that deserve some recognition.

http://programmers.stackexchange.com/questions/154228/why-is-it-good-to-split-a-program-into-multiple-classes

http://www.oracle.com/technetwork/java/codeconventions-150003.pdf

^-- Definitely check that out.

Michael Musick:

1.    http://java.dzone.com/articles/design-patterns-uncovered - a short article covering the implementation of the observer pattern in java in real world applications

2.    http://www.codeproject.com/Articles/716413/Factory-Method-Pattern-vs-Abstract-Factory-Pattern - 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.    http://www.codeproject.com/Articles/438922/Design-Patterns-of-Structural-Design-Patterns - 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.    http://www.cs.arizona.edu/~mccann/style_c.html - an article that covers the importance of variable names and documentation in software design

5.   
http://msdn.microsoft.com/en-us/library/aa260844%28v=vs.60%29.aspx – an article covering good programming techniques to include formatting indentation and commenting

6.    http://code.tutsplus.com/tutorials/top-15-best-practices-for-writing-super-readable-code--net-8118 - an article that provides helpful tips for clean coding practices

7.    http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/ - good and bad practices for unit testing

8.   https://developer.salesforce.com/page/How_to_Write_Good_Unit_Tests - another helpful article covering details and examples regarding unit testing

 9.    https://homes.cs.washington.edu/~mernst/advice/version-control.html - a very helpful article covering tips and advice for version control

 10.  http://www.git-tower.com/learn/ebook/command-line/appendix/best-practices - 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"
http://nvie.com/posts/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?"
http://www.hanselman.com/blog/ImAPhonyAreYou.aspx
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":
http://hanselminutes.com/302/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'"
http://blog.codinghorror.com/on-the-meaning-of-coding-horror/
"Sucking Less Every Year"
http://blog.codinghorror.com/sucking-less-every-year/
"We Make Shitty Software.. With Bugs!"
http://blog.codinghorror.com/we-make-shitty-software-with-bugs/

Link 3 - "The Joel Test: 12 Steps to Better Code"
http://www.joelonsoftware.com/articles/fog0000000043.html
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:
http://geekswithblogs.net/btudor/archive/2009/06/16/132842.aspx
So your team passes the Joel Test? How about Level 2?

Link 4 - "My Thoughts on Work/Life Balance at Microsoft"
http://blog.jongallant.com/2013/05/work-life-balance-at-microsoft.html
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"
http://blog.codinghorror.com/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"
http://blog.codinghorror.com/the-programmers-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:
http://www.joelonsoftware.com/articles/fieldguidetodevelopers.html
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: http://www.joelonsoftware.com/

Link 7 - "Scott Hanselman's Ultimate Developer and Power Users Tool List for Windows"
http://hanselman.com/tools
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"
http://www.cauldwell.net/patrick/blog/ThisIBelieveTheDeveloperEdition.aspx
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"
http://worrydream.com/LadderOfAbstraction/
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
http://vimeo.com/36579366
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"
http://stackoverflow.hewgill.com/questions/282/357/1.html
StackOverflow.com 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:

http://www.rapidtables.com/prog/devtips/design_tips.htm
http://www.liquidplanner.com/blog/designing-better-software-5-rules-to-follow/
http://lifehacker.com/5983680/how-the-heck-do-i-use-github
http://www.developer.com/design/article.php/1502691/A-Survey-of-Common-Design-Patterns.htm
http://sourcemaking.com/design_patterns/Adapter/php
http://www.codeproject.com/Tips/595716/Adapter-Design-Pattern-in-Cplusplus
http://javapapers.com/design-patterns/adapter-pattern/
http://www.lagerweij.com/2011/05/28/code-cleaning-a-refactoring-example-in-50-easy-steps/

---Bad Code---
http://www.cio.com/article/2448952/developer/10-bad-coding-practices-that-wreck-software-development-projects.html
http://www.chilton.com/~jimw/goodbad.html


Kevin Taylor:

http://www.git-tower.com/learn/
(great git tutorial)
http://agilescout.com/infographic-clean-code-and-test-driven-development-cheat-sheets/
(clean code cheat sheets)
https://developer.salesforce.com/page/How_to_Write_Good_Unit_Tests
(unit testing run-down)
https://training.github.com/kit/downloads/github-git-cheat-sheet.pdf
(git cheat sheet)
http://git-scm.com/book/en/v1/Git-Basics-Tips-and-Tricks
(git tricks that could come in handy)
http://www.smashingmagazine.com/2008/11/12/12-principles-for-keeping-your-code-clean/
(cleaning code, but in HTML)
http://www.infoworld.com/article/2606822/agile-development/125232-Developer-picks-7-hot-tools-for-agile-development.html
(agile development tools - brief but good information)
http://www.brighthubpm.com/agile/6549-a-quick-scrum-tutorial/
(Never went over much, but scrum is good agile development)
http://www.allaboutagile.com/how-to-implement-scrum-in-10-easy-steps/
(More info. on scrum)
http://www.avajava.com/tutorials/categories/design-patterns
(lots of design patterns described in detail - very useful if wanting to learn a lot of the patterns)

Stanton Vincent:

Design Patterns:

http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-170-laboratory-in-software-engineering-fall-2005/lecture-notes/lec18.pdf
Lecture from MIT on Design Patterns. Gives explanations and examples of several types of patterns.

http://en.wikipedia.org/wiki/Category:Software_design_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.

http://www.cs.duke.edu/~ola/patterns/talks/sigcse98.pdf
Slides from Duke University on understanding the basics of Design Patterns. Gives a great explanation on OO Design Patterns.

Git:

https://www.atlassian.com/git/tutorials/
Tutorials for newcomers on using Git. Includes advanced Git tutorials for the more experienced Git individuals.

http://git-scm.com/docs/gittutorial
A tutorial introduction to Git.

http://www.vogella.com/tutorials/Git/article.html
Amazing website to learn Git. Explains what Git is and does, explains how to setup Git and is very helpful with notation and explanation.

https://try.github.io/levels/1/challenges/1
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:

http://code.tutsplus.com/articles/how-to-write-code-that-embraces-change--net-29716
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.

http://code.tutsplus.com/tutorials/top-15-best-practices-for-writing-super-readable-code--net-8118
Describes the top 15+ practices and facets for writing clean code.

http://blog.goyello.com/2013/01/21/top-9-principles-clean-code/
Describes and lists the top nine qualities clean code should have.

JUnit:

http://www.vogella.com/tutorials/JUnit/article.html
Tutorial on using JUnit. Very descriptive and uses examples.

http://tutorials.jenkov.com/java-unit-testing/index.html
Describes what JUnit is and how to use it. Starts off very basic. Good resource for beginners.

EasyMock:

http://www.vogella.com/tutorials/EasyMock/article.html
Great tutorial and introduction to EasyMock. Starts off with descriptions, then gives examples.

Agile Development:

http://code.tutsplus.com/articles/the-principles-of-agile-development--net-25732
Tutorial on what Agile Development is. Great resource for starting off in understanding what Agile Development really is.


Kyle Young:

  1. http://blog.pluralsight.com/7-reasons-clean-code-matters
        This talks about a programmers personal experience in growing to understand and appreciate clean code.
  2. http://blogs.telerik.com/justteam/posts/13-05-16/clean-code-developer-school
        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.
  3. http://think-like-a-git.net/
    A awesome tutorial that takes you step by step teaching you git and showing you some amazing things you can do with it.
  4. http://eagain.net/articles/git-for-computer-scientists/
    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.
  5. http://www.asp.net/web-forms/overview/deployment/configuring-team-foundation-server-for-web-deployment/adding-content-to-source-control
    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.
  6. http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/
    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.
  7. http://www.ibm.com/developerworks/websphere/library/techarticles/0306_perks/perks2.html
    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.
  8. http://effectivesoftwaredesign.com/2013/11/20/35-agile-development-best-practices/
        The URL is pretty self-explanatory.
  9. http://www.computerworld.com/article/2572077/app-development/best-practices-for-software-development-projects.html
    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.
10. http://simpleprogrammer.com/2013/02/17/principles-are-timeless-best-practices-are-fads/
    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
http://csharpguidelines.codeplex.com/releases/view/98254

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
http://druss.pp.ua/wp-content/uploads/2013/10/Agile-Principles-Patterns-and-Practices-in-C.pdf
Link explains itself pretty well. The entire book on agile principles, patterns, and practices in C#.

http://blogs.msdn.com/b/microsoft_press/archive/2014/10/22/new-book-adaptive-code-via-c-agile-coding-with-design-patterns-and-solid-principles.aspx
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
http://blogs.msdn.com/b/jasonz/archive/2009/10/21/tutorial-getting-started-with-tfs-in-vs2010.aspx
Tutorial on using Microsoft’s version control system, Team Foundation Server, in Visual Studio 2010

Clean vs Elegant Code
http://blogs.encodo.ch/news/view_article.php?id=167
A brief-ish blog post highlighting the importance of writing code that other people will want to read and understand.

Design Patterns/Principles
http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29
The mentioned principles will ideally in practice yield a more maintainable system.

http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
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.

http://en.wikipedia.org/wiki/GRASP_%28object-oriented_design%29
Concepts of what classes and objects in OOP should do, specifically.

http://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it
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.

http://en.wikipedia.org/wiki/Package_principles
Covers six principles for organizing classes into more manageable and cohesive packages.

Learning
http://learncodethehardway.org/
Tutorials on Python, Ruby, C, SQL, and Regex. The philosophy behind these tutorials is “Less talk, more code”.

https://developers.google.com/university/
Google Developers University Consortium. A load of resources, including courses, stories, discussions, and dev tools for development.

Testing
http://csprogrammer.net/en/nunit-tutorial-part-i-introduction-to-unit-testing/
The first in a series of 3 tutorials on Nunit testing in a C# developer environment.

http://nunit.org/index.php?p=quickStart&r=3.0
Official Nunit resource for getting started using Nunit.