CSC 430 Useful Links from Fall 2013

Matt Carson   Aaron Clark   Cody Driskill   Parks Frazier   Jennifer Gross   MiGyeong Gwak   Jerad Hobgood   William Holt
Emilee King   Jinbo Lin   Jason Mallory   Keith Neer   Xulong Peng   Tyler Roberts   Christian Vargas   Wissem Zrelli


Matt Carson:

http://www-cs-students.stanford.edu/~blynn/gitmagic/
An excellent source for beginners with no ideas on Git. It is very reader friendly and doesn’t have the long drawn out explanations, but instead, uses easy to understand comments to explain what is going on.

http://mijingo.com/products/screencasts/git-tutorial-video/
This video is roughly an hour, however, it covers everything from the installation of Git on both Windows and Mac, why you should use it, various examples of codes, client applications, and even the various services offered through Git like GitHub or Beanstalk.

http://www.youtube.com/watch?v=k6VVURkxNkk
Video of JeremyBytes Clean Code: The Refactoring Bits

http://www.infoq.com/presentations/TDD-Steve-Freeman
Presentation by Steve Freeman about TDD: How Do We Know When We’re Done

http://www.youtube.com/playlist?list=PLAD14D207F310701E
Programming Katas, this is a series. Solutions are available in the comments.

http://blogsprajeesh.blogspot.com/2011/03/solving-supermarket-coding-kata-using.html
Code Kata practice using TDD.

http://www.youtube.com/watch?v=f3G7gu1IHws
Lets Play” Video of TDD

http://biz30.timedoctor.com/git-mecurial-and-cvs-comparison-of-svn-software/
Comparison argument of version control softwares

http://www.vogella.com/articles/DesignPatterns/article.html
Information on design patterns with java understandings.

http://www.youtube.com/watch?v=O-ZT_dtlrR0
Palindrome checker via TDD. Has a little bit of static, but is still understandable.



Aaron Clark:

https://www.thc.org/root/phun/unmaintain.html
This shows you what not to do by telling you how to write unmaintanable code.

http://en.wikipedia.org/wiki/Comparison_of_revision_control_software
Offers a brief overview of most all known available revision control software.

http://simpleprogrammer.com/2013/08/26/dont-code-katas/
This blog offers a viewpoint that most coding Katas are not useful, as they are just repetative.

http://mikepackdev.com/blog_posts/36-the-first-step-to-applying-design-patterns-don-t
This blog suggests not to use design patterns, as people get too dug into them, and arn't true software engineers.

http://codingdojo.org/cgi-bin/wiki.pl?KataCatalogue
A list of Coding Katas for those who wish to try them appropriatley.

http://www.youtube.com/watch?v=vaNGbk6HN9Y
The first in a series about how to use Git.

http://www.youtube.com/watch?v=-h6cj6O94Gs
Video for tutorial on using TortoiseSVN

http://www.shokhirev.com/nikolai/programs/SVN/svn.html
Written tutortial on the usage of TortoiseSVN in windows.

http://programmers.stackexchange.com/questions/157343/how-to-determine-whether-design-pattern-is-implemented-correctly
While giving some helpful advice about how to tell if code is done correctly, of strongest note is the first large comment below the question.

http://misko.hevery.com/2008/08/25/root-cause-of-singletons/
This talks about the root cause of singletons, which they call an "anti" pattern, and why Singletons are bad.


Cody Driskill:  
http://net.tutsplus.com/tutorials/html-css-techniques/top-15-best-practices-for-writing-super-readable-code/
Contains some pretty basic, but still important tips that apply to pretty much any language.

http://lumiera.org/project/background/CleanCodeDevelopment.html
Breaks down different clean code techniques into karate style belts to indicate importance. Helps to clarify basics and even more advanced techniques to keep in mind.

http://www.macronimous.com/resources/writing_clean_secure_and_easy_php.asp
Has some tips to help write PHP code and could double up and helps a bit in the web programming class too.

http://www.newthinktank.com/videos/refactoring-video-tutorial/
A video series that covers code refactoring. I found the guy who does the videos a bit long winded but maybe some people can relate to him.

http://www.dreamincode.net/forums/topic/335368-refactoring/
A write up of refactoring techniques that pertain to VB. It also has some good tips that can apply to any OOP language.

http://www.perl.com/pub/2003/10/09/refactoring.html
This is an article about refactoring in the Perl language, and good practices to employ there. This is particularly useful because Perl, I feel generally doesn’t get too much individual coverage.

http://beyondrelational.com/modules/2/blogs/79/posts/11540/refactoring-of-c-code.aspx
This covers C# and the best part is that it actually has examples of before and after code.

https://github.com/thomasdavis/best-practices
Gives a good overview on how to write good code in general.

http://www.ucl.ac.uk/~ucappgu/seminars/good-practice.pdf
Powerpoint slides done at a London University that also give good tips.

http://www.cs.usfca.edu/~parrt/course/601/lectures/refactoring/refactoring.html
An overview of refactoring code from the University of San Francisco, includes links to a database containing patterns to watch out for.


Parks Frazier:

http://java.dzone.com/articles/what-clean-code-%E2%80%93-quotes
-Quotes from a few leading figures in the Computer Science field on clean code.

https://www.42lines.net/2012/07/06/clean-code-reducing-wtfs-per-minute/
-Interesting article that should sooth your pain a little

http://www.javapronews.com/using-finally-to-write-clean-code/
-Article for Java users on how to use a Finally statement to clean up code

http://sixrevisions.com/resources/git-tutorials-beginners/
-Some Git tutorials for beginners

https://www.atlassian.com/git/tutorial
-More helpful Git tutorials

http://net.tutsplus.com/tutorials/html-css-techniques/top-15-best-practices-for-writing-super-readable-code/
-Tips and practices for writing good, readable code

http://www.education.vic.gov.au/devreskit/appdev/standards/general/general-standards-summary.htm
-general coding standards

http://java.dzone.com/articles/10-subtle-best-practices-when
-10 good coding practices for Java

http://www.phptherightway.com/
-great help for coding in PHP

http://www.slideshare.net/theojungeblut/2013-106-clean-code-part-i-design-patterns
-good powerpoint on design patterns and more coding practices


Jennifer Gross:  

http://www.lynda.com/Git-tutorials/Git-Essential-Training/100222-2.html?w=0
Personally, I love lynda.com. I have had a membership with them for a few years and watch as many videos as I can on their site. These videos literally walk you through everything you can possibly want to do with Git.

http://ftp.newartisans.com/pub/git.from.bottom.up.pdf
What I enjoyed about this document was that it was different than all the other sources I found on Git. The fact that this source started with explaining concepts in context with other concepts that I already knew was welcoming, rather than immediately throwing code at me to wade through. Also, it was surprisingly sort in comparison to other sources that I found on this topic.

http://www.jeremybytes.com/Demos.aspx
There was too much information on this site for me to just choose a few. This site has information on both Clean Code and Design Patterns, including videos, pdfs, presentations, and downloadable code. Jeremy is very clear, thorough and easy to understand. This was probably my most visited site during this semester.

https://sites.google.com/site/tddproblems/all-problems-1
This page contains several TDD practice problems.

http://codingdojo.org/cgi-bin/wiki.pl?KataCatalogue
Kata practices

http://www.youtube.com/watch?v=uGaNkTahrIw
Agile Academy’s Agile in Practice: Test Driven Development.

http://www.fluffycat.com/Java-Design-Patterns/
Extensive list of design patterns with code examples.

http://www.newthinktank.com/videos/design-patterns-tutorial/
Video examples of design patterns in java.

http://oss-watch.ac.uk/resources/versioncontrol
Overview of what is version control

http://www.slideshare.net/Skud/test-driven-development-tutorial
3-hour tutorial on TDD.


MiGyeong Gwak:  

http://net.tutsplus.com/articles/general/a-beginners-guide-to-design-patterns/
(This is a nice and simple beginner’s guide to design patterns. It will be good for preview on design patter textbook.)

http://www.tutorialspoint.com/design_pattern/
(This is a good resource to learn design patterns in Java. There are a quick guide, useful resources, and a tutorial.)

http://msdn.microsoft.com/en-us/library/ee817670.aspx
(It explains the singleton design pattern through the Microsoft .NET framework.)

http://www.gla.ac.uk/services/dpfoioffice/guidanceonrecordsandinformationmanagement/versioncontrol/
(A brief explanation of version control and guidance for a practice by University of Glasgow)

http://producingoss.com/en/vc.html
(This is a version control part in the book of “Producing Open Source Software.”)

http://www.youtube.com/watch?v=r5Ko3H8smks
(A brief overview of software development process by Damon Poole)

http://www.progress.com/~/media/Progress/Documents/News%20and%20Events/Exchange2013/Track%203%20-%20Beginners%20guide%20to%20continuous%20integration.pdf
(This is a beginner’s guide to continuous integration by Gilles Querret from Riverside Software.)

http://www.cs.usfca.edu/~parrt/course/601/lectures/refactoring/refactoring.html
(This is a lecture note about code refactoring. There are some JGuru examples to illustrate refactoring.)

http://www.vogella.com/articles/JUnit/article.html
(This is a tutorial for unit testing with JUnit. It includes how to run JUnit tests in Eclipse Environment.)

https://www.udemy.com/blog/php-oop-tutorial/
(This contains a definition of object oriented programming to keep code clean and a PHP OOP tutorial for beginners.)


Jerad Hobgood:

https://www.youtube.com/watch?v=ZDR433b0HJY
This is a great source for knowing what git is and how it works.
The man tends to get off track and can be hard to follow but is can help a beginner learn what git is.

http://gitimmersion.com/
Helps getting git setup and getting started using git for the first time.

http://www.theguardian.com/info/developer-blog/2011/oct/07/programming-developer-journalist
Sort of off topic a little but can help beginners who have only taken a few programming classes get to know clean code.

http://www.vogella.com/articles/JUnit/article.html
Great if you like a simple written instructions on juit testing.

https://www.youtube.com/watch?v=QEyxgtCEWMw&list=PL0951947FC3CB5BB3
this is a two part video, the speaker is a little dry but is great for learning about junit testing.(help me alot).

http://net.tutsplus.com/tutorials/php/the-newbies-guide-to-test-driven-development/
This is a good short intro about TTD. The code samples use PHP.

http://slashdot.org/topic/bi/battle-of-the-java-ides-eclipse-vs-netbeans-vs-intellij-idea/
This article is opinion bases but important for newbies. It talking about the difference between net-beans and Eclipse.
All new programmers need to sit down and play with both these IDE's and decide which one they prefer to use.
This link is to just open the ideas to new students about doing there own resource on the IDE's.

https://www.youtube.com/watch?v=vNHpsC5ng_E
This is one of many in the series about Design patterns. this video is just saying what is a design pattern. there are many other videos
about different patterns.

http://www.dofactory.com/Patterns/Patterns.aspx
This is .Net Design patterns. on the page is just a list of links of design patterns click them and will be taken to a tutorial of that pattern

http://www.lynda.com/GitHub-training-tutorials/1384-0.html
lynda.com is a great place to learn about so many great things. this link is about GitHub in all its glory.

http://www.lynda.com/
( For all your needs, Videos, Readings)



William Holt:

  1. SCRUM Development and Lean Thinking - http://msdn.microsoft.com/en-us/library/jj161049.aspx
  2. Extreme Programming and a Simple TDD Introduction - http://msdn.microsoft.com/en-us/magazine/cc163982.aspx
  3. Writing Clean Code in C# - http://www.codeproject.com/Articles/539179/Some-practices-to-write-better-Csharp-NET-code
  4. Essential Skills for Agile Development (A free ebook!) - http://elliottback.com/wp/essential-skills-for-agile-development/
  5. Simple Git (This has saved my bacon many times!) - http://rogerdudler.github.io/git-guide/
  6. A handy Mercurial Tutorial (some say it’s better than git!) - http://hginit.com
  7. A great video tutorial/coding sandbox site to learn a wide variety of topics such as git, php, css3/html5/js - https://teamtreehouse.com
  8. Getting started with Amazon AWS (easier than you think) - http://www.drdobbs.com/web-development/getting-started-with-the-cloud-amazon-we/231601598?pgno=2
  9. A free alternative to treehouse, with 100% less video. http://www.codecademy.com
  10. Another alternative to treehouse, though it’s free… to a point. https://www.codeschool.com


Emilee King:  
http://www.computing.co.uk/ctg/analysis/2305379/the-evolution-of-programming-languages

Interesting video on the evolution important languages and how they are still used and impacted current languages

http://repeatgeek.com/technical/a-list-of-coding-standard-websites/
Nifty list of coding standards for different languages, just to help keep things clean and readable 

UI Mistakes: 
1. http://www.voyce.com/index.php/2009/09/14/the-7-signs-your-ui-was-created-by-a-programmer/

2. http://flairbuilder.com/8-things-programmers-should-know-about-ui-design/

3. http://www.uxdesignedge.com/2010/03/dont-design-like-a-programmer/


http://repeatgeek.com/category/technical/

Awesome blog on programming. 

http://sourcemaking.com/antipatterns
We've been over design patterns, here's a guide on Anti-patterns
AntiPatterns provide real-world experience in recognizing recurring problems in the software industry and provide a detailed remedy for the most common predicaments. AntiPatterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes."

http://www.harding.edu/fmccown/WritingCleanCode.pdf
Tips on writing clean code

http://sixrevisions.com/resources/git-tutorials-beginners/
10 git tutorials for beginners

http://www.newthinktank.com/videos/refactoring-video-tutorial/
Refactoring video tutorials, I really enjoyed  this. It's easy to follow and actually fun to listen to.

http://www.artima.com/weblogs/viewpost.jsp?thread=331531
The Principles of Good Programming 


http://net.tutsplus.com/articles/general/a-beginners-guide-to-design-patterns/
Beginner's Guide to Design patterns. It gives examples of design patterns and how to use them

http://www.eecs.yorku.ca/course_archive/2003-04/W/3311/sectionM/case_studies/money/KentBeck_TDD_byexample.pdf
Test Driven Design by Example

http://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Test-Driven-Development/124398-2.html?utm_campaign=QCif_-r8eK4-yat-c1&utm_medium=viral&utm_source=youtube
This is really cool, this is an online course on TDD.



Jinbo Lin:  
  1. JUnit

http://www.tutorialspoint.com/junit/index.htm

this website contains every single topic of JUnit, and they provide code sample for every topic. Cons: too much details in all topics.

  1. JUnit

https://www.youtube.com/watch?v=qU9DmFa45rc

This video was uploaded 3 years ago. Although this is old technology, indeed this person use notepad to wrote the program instead of using IDE, this video still provide a clear view of JUnit.

  1. Strategy Pattern

https://www.youtube.com/watch?v=sdT2LkbrJtc

This video demonstrate the concept of strategy pattern. He explained this concept very well in his presentation. Cons: no captions in this video.

  1. Strategy Pattern

https://www.youtube.com/watch?v=-NCgRD9-C6o

Last link talks about the concept of strategy pattern and the condition it fit, so this video demonstrate the pattern by the sample code. Also, he provide his codes which people can download for the entire project.

  1. Design Pattern

http://addyosmani.com/resources/essentialjsdesignpatterns/book/

This book talks about the design pattern in Javascrpit.


  1. Version Control

https://www.youtube.com/watch?v=MLLkJ2rngk0

This video talks about the concept of version control.

7. Version Control

https://www.youtube.com/watch?v=dDJOb2wGLjY

This is the next episode of last video, in this video he use Git as example to demonstrate how version control system works. And he use his code to show you the function of almost all git command.

  1. Version Control

http://betterexplained.com/articles/a-visual-guide-to-version-control/

A visual guide to Version Control System.

  1. Clean Code

https://www.youtube.com/watch?v=RlfLCWKxHJ0&list=PL693EFD059797C21E

A presentation about clean code from Google Tech. However this guy is so familiar.

10.

http://www.lynda.com/

A Online video tutorial website about software.





Jason Mallory:  

(1)  Quick explanations with examples for template method, strategy, factory method, abstract factory, facade, and command patterns
 http://codebetter.com/jeremymiller/2006/04/11/six-design-patterns-to-start-with/

(2)  Short post on why you should learn and use design patterns.
 http://codebetter.com/jeremymiller/2005/09/01/learning-about-design-patterns/

(3)  Game development patterns focused on solving specific game related problems.
 Main page
  http://gdp2.tii.se/index.php/Main_Page
 Main listing of pattern articles
  http://gdp2.tii.se/index.php/Category:Patterns

(4)   Similar to (3).
 http://rpg-design-patterns.speedykitty.com/doku.php

(5)  Short post on not letting readability affect maintainability.
 http://thatextramile.be/blog/2011/07/clean-code-versus-great-code/

(6)  Article about cleaning bad code.
 http://www.altdevblogaday.com/2012/08/18/cleaning-bad-code/

(7)  List of things to help grow as a programmer. Comments were informative.
 http://www.codinghorror.com/blog/2008/06/the-ultimate-code-kata.html

(8)  Developing defined goals and understanding what you should be working toward.
 http://www.codinghorror.com/blog/2007/09/can-your-team-pass-the-elevator-test.html

(9)  Description of how agile works in the game development industry. Where it works, where it doesn't and how some aspects are modified.
 http://www.develop-online.net/analysis/the-four-pillars-of-agile-game-development/0117636

(10)  Article about how Scrum can help great game development teams form.
 http://www.gamasutra.com/view/feature/134412/agile_game_development_with_scrum_.php


Keith Neer:  

   This link summarizes the important clean code practices found in the Clean Code book

http://www.themememe.com/subversion-for-absolute-beginners
    This link explains how to use Subversion from installing it to using the basic features.

http://www.codeproject.com/Articles/567768/Object-Oriented-Design-Principles
    Useful link for understanding OO design.

http://net.tutsplus.com/tutorials/how-to-write-code-that-embraces-change/
     This link provides some tutorials on how to write cleaner code.

http://www.vogella.com/articles/JUnit/article.html
     A walk-through tutorial of JUnit testing in Eclipse.

http://java.dzone.com/articles/junit-tutorial-beginners
     This link is an introductory tutorial for JUnit.

http://visualstudiomagazine.com/articles/2013/06/01/roc-rocks.aspx
      This article gives some interesting reasons why you shouldn't comment your code.

http://net.tutsplus.com/tutorials/html-css-techniques/top-15-best-practices-for-writing-super-readable-code/
       List practices for writing clean code

http://www.slideshare.net/theojungeblut/2013-106-clean-code-part-i-design-patterns
     More on Clean Code practices.


Xulong Peng: 
//1. This website has summary of version control and good for beginner to know the basic concepts:
http://en.wikipedia.org/wiki/Revision_control

//2. this article outlines the fundamentals of version control. I really like it, clear and neat.
http://betterexplained.com/articles/a-visual-guide-to-version-control/

//3. This review article introduces several top open-source version control systems and tools.
//Good reference as it has reference links after each VCS tool!
http://www.smashingmagazine.com/2008/09/18/the-top-7-open-source-version-control-systems/

//4. eBook on Git, free download!
http://www.git-scm.com/book/en/Getting-Started-About-Version-Control

//5. this is a good website shows details how to use Git.
http://wiki.koha-community.org/wiki/Version_Control_Using_Git

//6. This is from NetBeans about versional control: CVS, Subversion, Mercurial and ClearCase
https://versioncontrol.netbeans.org/

//7. a good site for introducing TDD: What is TDD, Why use TDD and How to use.
http://www.agiledata.org/essays/tdd.html

//8. Good slides show for TDD tutorial!
http://www.slideshare.net/Skud/test-driven-development-tutorial

//9. Good site introduces Design Patterns and including
//Principles, Creational/Behavioral/Structural Patterns as well as Forum!
http://www.oodesign.com/

//10. This site introduces Design Patterns and Refactoring
http://sourcemaking.com/

//11. Java Design Patterns
http://www.javaworld.com/columns/jw-java-design-patterns-index.html

//12. Wikipedia website outlines software development: good introduction
http://en.wikipedia.org/wiki/Outline_of_software_development

//13. About Testing for software construction
http://msdn.microsoft.com/en-us/library/aa292484%28v=vs.71%29.aspx

//14. 12 Unit Testing Tips for Software Engineers
http://readwrite.com/2008/08/13/12_unit_testing_tips_for_software_engineers#awesm=~ooPCm0MKfGpAYF

//15. How to write good unit tests
http://wiki.developerforce.com/page/How_to_Write_Good_Unit_Tests

//16. This is from MSDN for patterns and practices.
http://msdn.microsoft.com/en-us/magazine/cc188707.aspx

//17. How to write a clean code without comments
http://www.wikihow.com/Write-Readable-Code-Without-Comments

//18. How to write a readable source code
http://software.ac.uk/resources/guides/writing-readable-source-code

//19. Good article for cleaning bad code.
http://www.altdevblogaday.com/2012/08/18/cleaning-bad-code/

//20. Really good post/comments to avoid bad coding habits for beginner
http://www.reddit.com/r/learnprogramming/comments/1i4ds4/what_are_some_bad_coding_habits_you_would/



Tyler Roberts:  
1. http://taskinoor.wordpress.com/2011/09/21/the-abuse-of-design-patterns-in-writing-a-hello-world-program/
Using design patterns in places where they aren't needed (hello world)


2. http://www.brandonsavage.net/how-using-design-patterns-is-like-baking-a-loaf-of-bread/
Changing design patterns to fit your coding needs


3. http://codekata.pragprog.com/2007/01/code_kata_backg.html
Taken from our Clean Code book, refractoring functions


4. http://www.planetgeek.ch/wp-content/uploads/2013/06/Clean-Code-V2.2.pdf
Clean code cheat sheet

5. http://blog.goyello.com/2013/05/17/express-names-in-code-bad-vs-clean/
Short clean code lesson

6. http://www.youtube.com/watch?v=k6VVURkxNkk
Refractoring code (35 minutes long)


7. http://codekata.pragprog.com/
Site for using code kata's


8. http://codingdojo.org/cgi-bin/wiki.pl?KataCatalogue
Another site to practice code kata's


9. http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata
Robert C Martin's bowling game kata


10. http://c2.com/cgi/wiki?TestDrivenDevelopment
Introduction to test driven development


11. http://www.youtube.com/watch?v=U8GBXvdmHT4
Learning the basics of GitHub (1 hour long)


12. http://www.youtube.com/watch?v=dWayn0QsJr8
Intro to Learning TDD


Christian Vargas:  
1. this site contain tools and management for software construction.
http://www.shlomifish.org/open-source/resources/software-tools/

2. this is a google software toolkit site with downloads
https://code.google.com/p/swtoolkit/

3. A Github site that contains an outline of a software construction 2012-13. It contians link to slides that are apart of the course. 
https://github.com/software-engineering-amsterdam/software-construction/wiki

4. this link contains a software construction and testing powerpoint that might be very helpful
http://www.docstoc.com/docs/133248915/SOFTWARE-CONSTRUCTION-AND-TESTINGppt

5. Link that contain another powerpoint that will help in software construction. Give information about software construction.
http://www.slideshare.net/sasanabhishek/software-construction

6. Link that contains seven tips pn how to construct software successfully
http://www.construction-software.com/Company/Articles/CBO-7-Tips-for-Success.aspx

7. This is a short pdf of some tips to write clean code. its only two pages and is a very short read that wont take up anytime
http://www.harding.edu/fmccown/WritingCleanCode.pdf

8. Link to a detail report of 12 principles for keeping clean code along with examples
http://coding.smashingmagazine.com/2008/11/12/12-principles-for-keeping-your-code-clean/

9. Tips for a clean programming code
http://www.yourhowto.net/tips-for-a-clean-programming-code/

10. link to a blog where "7 reasons why clean code matter" is discussed and debated 
http://blog.pluralsight.com/7-reasons-clean-code-matters


Wissem Zrelli:

Wissem's Links