CSC 430 Useful Links from Fall 2012
Online resources from 430 students:

Bu, Ruwei    Burton, John   Byrd, Daniul   Cain, James   Clark, Jason    Clifford, Josh    Conner, Steven    Gertig, Jonathan
Green, Conal    Harper, Demis    Holt, Michael    Ladendorf, Kurt    Lott, Jessica    Owen, Michael    Vinson, Jonathan



Jason Clark:

http://www.youtube.com/watch?v=4E4672CS58Q&list=PLBDAB2BA83BB6588E&index=1 
This is a five video series on YouTube from GoogleTechTalks

http://www.garshol.priv.no/blog/105.html
Here are 7 tips on writing clean code

http://mindprod.com/jgloss/unmain.html
This is a somewhat humorous but very informative on code maintenance

http://www.oodesign.com/
Here are lots of design patterns with nice examples

http://sourcemaking.com/design_patterns
This is another site with lots of design patterns with examples

http://www.javacamp.org/designPattern/
Here are lots of design patters.. I especially like the "Where to use & benefits" section

http://www.altdevblogaday.com/2012/08/18/cleaning-bad-code/
Yes, this is just a blog, but it is a very informative blog on cleaning bad code.

http://www.planetgeek.ch/wp-content/uploads/2011/02/Clean-Code-Cheat-Sheet-V1.3.pdf
This is a pdf that has a great deal of rules to follow when cleaning your code.

http://www.authorstream.com/Presentation/Demian-8839-test-driven-devlopment-mock-objects-tdd-dev-session-education-ppt-powerpoint/
This is a nice powerpoint presentation on TDD.

http://www.ing.unal.edu.co/ColSWE/images/seminario/02Julio/TDD.ppt
This is a nice powerpoint presentation on TDD.

Steven Conner:

www.cleancoders.com/
Clean Coders is all about educational videos for software
professionals, by software professionals

http://ptgmedia.pearsoncmg.com/images/9780137081073/samplepages/0137081073.pdf
pdf version of a book called clean coder about a code of conduct for
professional programmers

http://www.e-reading.org.ua/bookreader.php/134601/Clean_Code_-_A_Handbook_of_Agile_Software_Craftsmanship.pdf
pdf version of Clean code textbook.

http://www.ziddu.com/download/9178969/9780596527358-HeadFirstSoftwareDevelopment.zip
(maybe illegal)
pdf version of Software Developement textbook

http://downloads.ziddu.com/downloadfile/9179225/0596007124-HeadFirstDesignPatterns.zip.html
(maybe illegal)
pdf version of Design Patterns

http://www.youtube.com/watch?v=4F72VULWFvc
Is your code full of if statements? Switch statements? Do you have the
same switch statement in various places? When you make changes do you
find yourself making the same change to the same if/switch in several
places? Did you ever forget one?
This talk will discuss approaches to using Object Oriented techniques
to remove many of those conditionals. The result is cleaner, tighter,
better designed code that's easier to test, understand and maintain.

http://www.lagerweij.com/2011/05/28/code-cleaning-a-refactoring-example-in-50-easy-steps/
shows bad code then 50 steps to clean it up

http://www.garshol.priv.no/blog/105.html
7 tips on writing clean code

http://java.dzone.com/articles/clean-code-four-simple-design
4 simple steps for clean code

http://sgoettschkes.blogspot.com/2012/02/path-to-clean-code.html
a bunch of stuff for clean coding
John Burton:
http://en.wikipedia.org/wiki/Coding_conventions
http://www.codinghorror.com/blog/2007/03/top-6-list-of-programming-top-10-lists.html
http://www.adaic.org/resources/add_content/docs/95style/html/cover.html
http://en.wikipedia.org/wiki/Software_design_pattern
http://en.wikibooks.org/wiki/Java_Programming/Design_Patterns
http://www.badprogramming.com/

http://geosoft.no/development/javastyle.html#Layout
http://www.erlang.se/doc/programming_rules.shtml
http://www.amazon.com/exec/obidos/ASIN/0201485672/codihorr-20
http://www.amazon.com/exec/obidos/ASIN/020161622X/codihorr-20
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

I found many sites for bad programming but was not able to find many that clearly showed how to fix it, nor could I find a great compilation of code that was badly programmed in need of correction code.

Sadly because I really like to fix bad code. Something that might could assist in making better code might simply be having us rewrite code from one language, e.g. Java, and change it to C++ or another language. It would seem easy to tell what could be made better and might be done naturally adjusting comments and bad code.


Kurt Ladendorf:
http://www.richardrodger.com/2012/11/03/why-i-have-given-up-on-coding-standards/#.UL7Yx4PLR8E
 -  A different view on strict coding standards.

http://blogs.msdn.com/b/cashto/archive/2007/06/04/coding-against-the-grain.aspx
 -  Acts as a good summary to the clean code and design patterns book.  It puts them in a realistic perspective. 

http://www.oodesign.com/design-principles.html
-  Gives explanations and examples of multiple design patterns.

http://net.tutsplus.com/tutorials/html-css-techniques/top-15-best-practices-for-writing-super-readable-code/
-  Gives the author's opinion on how to write readable code.  It might be a good thing for people to read and critique.

http://msdn.microsoft.com/en-us/library/ms379618(vs.80).aspx
-  A tutorial on re-factoring C# code. 

http://www.youtube.com/watch?v=rYfm-s_TJ_k
-  TDD in Java in the Eclipse environment.

http://www.lagerweij.com/2011/06/08/code-cleaning-how-tests-improve-code/
-  Rather lengthy, but this is a series of posts that discuss cleaning Java code.

http://www.youtube.com/watch?v=3118sJuwOLs
- Covers a few software development styles.

http://www.hurricanesoftwares.com/most-important-coding-principles/
-  A few good coding principles to live by. 

http://www.codesimplicity.com/post/why-programmers-suck/
-  This might spark a lively discussion in a classroom setting....


Michael Owen:


Code examples that could be cleaned up:
http://www.happycodings.com/ 
     This site has lots and lots of code for many languages that could be used to clean up a bit
http://www.codegonewrong.com/
     A funny collection of bad code examples.  
http://oreilly.com/catalog/javanut/examples/
     Lots of Java code that could be used for cleaning up.

Sites that would go well with the Clean Code book:
http://www.exmsft.com/~hanss/badcode.htm  
     This page is hilarious.  It talks about what to do if you want to right BAD code!  It makes it pretty clear what you should avoid and it is an enjoyable read.
http://www.codinghorror.com/blog/2006/05/code-smells.html
     A good summery of things to consider when writing code to keep it clean

Design Pattern book:
http://sourcemaking.com/design_patterns
     Includes a lot of information about many different design patterns and also some good information about refactoring and UML diagrams.
http://refcardz.dzone.com/refcardz/design-patterns
     A useful reference for determining what many design patterns are good for and deciding what situations would be good for that pattern.

Testing:
http://www.youtube.com/watch?v=wEhu57pih5w
     The most useful thing I've found!  Very informative and very useful!  Highly recommended!  Talks about the importance of Unit Testing.
http://wiki.developerforce.com/page/How_to_Write_Good_Unit_Tests
     Good information about how to implement unit testing.
http://www.agiledata.org/essays/tdd.html
     Good introduction to TDD.

Ruiwei Bu:

Based on my experience, design patterns are designed to solve the problems with OOP (Object Oriented Programming). And the patterns actually differs from language to language.

The “PPP” Book: Agile Software Development Principles, Patterns, and Practices
http://www.amazon.com/Software-Development-Principles-Patterns-Practices/dp/0135974445

A awesome blog on software development 
Joel on Software: http://www.joelonsoftware.com/
And the book: http://www.amazon.com/More-Joel-Software-Occasionally-Developers/dp/1430209879/ref=pd_bxgy_b_img_y

Scrum Development (What we are trying to apply):
http://www.scrum.org/Portals/0/Documents/Scrum%20Guides/Scrum_Guide.pdf

Refactoring: Improving the Design of Existing Code:
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
This book provides very detailed examples of code refactoring, which is extremely worth reading.

Code Complete: A Practical Handbook of Software Construction
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670

Actually, for the code part. I have two suggestions
  1. Refactor old code written by students, explain why the choice is not so good and ways to improve it. However, there are difficulties to apply design patterns to student codes since design patterns only show their powers when the code base goes large, for example, thousands of lines. Applying design patterns to projects with only hundreds of lines just slows the development speed.
  2. Read open-source programs and libraries, especially libraries. Every popular libraries is a live example of what a good architecture is and the beauty of interface design.

Architecture of Open-Source Applications:
http://www.aosabook.org/en/index.html
This is a open source book and every one can contribute to it.

The Old New Thing: http://blogs.msdn.com/b/oldnewthing/
This is a blog written by a Microsoft employee, providing some explanations of the design choices behind the development of Windows and Windows softwares. There is also a published book that selects part of the blog posts.
http://www.amazon.com/gp/product/0321440307?ie=UTF8&tag=tholneth-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0321440307

And, all newer project hosting websites are extremely useful places to learn. For example, Github is actually a social network for project hosting.

Github: http://www.github.com
BitBucket: https://bitbuket.org
CodePlex: http://www.codeplex.com/

I don’t suggest GoogleCode or SourceForge because, these traditional platforms are only good for store project, but not communication and view the changes. For example, on the platforms mentioned above, you can view the diff of every commit. That gives the user a good chance to learn how a developer make changes to his/her code through the development.

StackOverflow: http://stackoverflow.com/
One of the most useful site to get answers for questions related to programming.

Channel 9: http://channel9.msdn.com/
Microsoft’s video share site. There are many useful videos on this site.

The best way to practice design patterns is to write projects. For example, after learning the instruction pattern, the best way to practice is to write a simple calculator or text editor that supports undo/redo.

A old book about design patterns in Java is 
http://www.amazon.com/Patterns-Java-Catalog-Reusable-Illustrated/dp/0471227293

Demis Harper:

http://sourcemaking.com/design_patterns -- This site has several examples of design patterns we go over in the book,and a few we that aren't in the book.  For each design pattern, there are example codes in languages ranging from C# and Java to PHP.

http://stackoverflow.com/questions/4910138/unit-test-examples-- contains a very good example and explanation of a unit test

http://www.research.ibm.com/designpatterns/example.htm--This one I'm iffy about, but it does list some reasons problems with the observer design pattern, as well as why it is still useful. I think it gives a pretty good all around look at that one.

http://www.codeproject.com/Articles/251885/Here-is-why-we-write-poor-quality-software-- This gives a pretty good explanation of how good code can go to bad code if coders aren't careful, and how it can be difficult to maintain code quality.

http://www.webkit.org/projects/cleanup/index.html -- this site details an open source project that relies on contributes to clean the code.  Perhaps the code could be used in class?

http://www.amazon.com/Designing-Mind-Simple-Understanding-Interface/dp/012375030X/ref=sr_1_1?ie=UTF8&qid=1355199996&sr=8-1&keywords=gui+software+design -- this book has great reviews on Amazon, and is oriented towards gui software design, which may help get a jump on the gui class

http://www.ambysoft.com/essays/userInterfaceDesign.html -- I know our class focuses on how to keep the code clean and which principles to use to help maintain it.  --This site lists principles on how the interface itself should be handled.

http://www.amazon.com/Coding-Software-Process-Jonathan-Locke/dp/0615404820/ref=sr_1_2?s=books&ie=UTF8&qid=1355200096&sr=1-2&keywords=software+design -- another highly recommended book from the author the Apache programming language.  It focuses on what makes a good coder, not just good code.

http://www.cs.umd.edu/class/fall2009/cmsc433/Lectures/design-principles.pdf -- now this pdf isn't a thrilling read. It's a copy of a powerpoint turned into a pdf.  However it does go over and some of the topics discussed in class, and phrase them in a different way.  It feels more like a stepy-by-step guide which might help drive the point home for some students.

http://www.amazon.com/Art-Unit-Testing-Examples-Net/dp/1933988274/ref=sr_1_1?s=books&ie=UTF8&qid=1355201252&sr=1-1&keywords=unit+testing -- Out of all the material we covered, I felt I grasped unit testing the least.  I mean I understand what it is, why it is, and how to do self contained tests in the small, but I feel like there's something I can't put my finger on I don't grasp.  The book has good reviews and is supposed to have great examples in it.

Daniul Byrd:

Some articles about good programming practices:
http://www.omninerd.com/articles/Coding_Practices
http://www.kmoser.com/articles/Good_Programming_Practices.php
http://www.codeproject.com/Articles/31011/Bad-coding-Practices

This one has some good tips about writing clean/readable code:
http://www.codeproject.com/Articles/8971/C-Coding-Standards-and-Best-Programming-Practices

About cleaning bad code:
http://www.altdevblogaday.com/2012/08/18/cleaning-bad-code/

About Agile Development:
http://www.agilemanifesto.org/principles.html
This one has a lot of resources/links for Agile Development:
http://www.agilealliance.org/resources/

I couldn't find any good site for code that needs cleaning. Maybe you could find some old java projects and remove student names or give some code bad variable names/functions.


Jessica Lott:

1.) Book that teaches design patterns by looking at code:
http://www.amazon.com/Holub-Patterns-Learning-Design-Looking/dp/159059388X

2.) Possible test question or assignment: Choose a design pattern and tell about its features and where you would use it. List of Computer Science Design Patterns:
http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns

3.) Interesting article on Clean Code by IBM:
http://www.ibm.com/developerworks/rational/library/nov06/pollice/index.html

4.) Possible test question: Tell which piece of code is cleaner and explain why. This would be better when just learning about clean code. It is much easier to see the differences when comparing two programs that do the exact same thing, then to just look at a program and tell what is wrong.

5.) Interesting blog on Unit Testing:
http://blog.stevensanderson.com/2009/08/24/writing-great-unit-tests-best-and-worst-practises/

6.) Another blog that has many different topics, including entries about how to write clean code:
http://avalanche123.com/

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

8.) I have used code project tutorials several times to learn new subjects. Here is one of their tutorials on writing your first unit test:
http://www.codeproject.com/Articles/10105/Writing-Your-First-Unit-Test

9.) Jeff Atwood is just a fun guy to learn from. Here is some more on Unit Testing:
http://www.codinghorror.com/blog/2006/07/i-pity-the-fool-who-doesnt-write-unit-tests.html

10.) Here is a link to a complete guide on Software Construction. I am not sure how it would compare to the Head First books, but it has good reviews.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670


Joshua Clifford:

  1. http://msdn.microsoft.com/en-us/library/ee817669.aspx
    Exploring the Observer Design Pattern in .NET. This resource does a good job of explaining the pattern both generally, as well as through C#/VB code and .NET Framework Patterns.

  2. http://www.youtube.com/watch?v=Ex2WpvpZfsg

    http://www.youtube.com/watch?feature=endscreen&v=VuPAw5svj3Q&NR=1

    http://www.youtube.com/watch?v=xDmXe4-tI_I
    In addition to #1, this professor has a series of lectures on the Observer Pattern that takes a look at an application he wrote and rewrites it to fit the Observer pattern. The lecturer rewrites the application in both a direct clone of the Observer pattern, as well as using the .NET implementation of delegates and events.

  3. http://www.codeguru.com/csharp/article.php/c19335/Guide-to-Implement-the-Factory-Pattern-in-C.htm
    This link goes through the Factory Pattern in C#, using a fairly straightforward example, correct C# naming schemes, diagrams, and more to explain the pattern.

  4. http://think-like-a-git.net/
    This link I found to be extremely helpful. It helps explain Git in a very informal, colloquial manner. It starts by explaining graphs and then relates graph theory to the concepts in Git.

  5. http://msdn.microsoft.com/en-us/library/ms182532.aspx
    A walkthrough for creating and running unit tests for managed code in C#.

  6. http://www.planetgeek.ch/2011/01/04/clean-code-and-clean-tdd-cheat-sheets/
    Cheat sheets for both Clean Code and TDD.

  7. http://www.sourcemaking.com
    Great, user-friendly site covering topics like design patterns, refactoring, and UML by using diagrams and pictures for visual learners.

  8. https://github.com/blog/120-new-to-git
    A mixture of different Git resources such as a cheat sheet, beginners guide, screencaps, behind the scenes looks, etc.

  9. http://decomp.ulb.ac.be:9090/FrepSite/Cours/0506/TechnoFutur3/dp_presentation_solutions.pdf
    A good exercise that tests students' knowledge on the different design patterns.

  10. http://www.techrepublic.com/blog/tech-manager/four-variants-of-agile-development-methods/3664
    This resource goes into more detail about four different agile development methods and can be used as a jumping off point for students to investigate other real world examples.


James Cain:

Web Pages

1. Good Programming Practices: What to Do (or Not)
http://www.kmoser.com/articles/Good_Programming_Practices.php
Kim Moser, a computer consultant and web programmer, offers a few good programming habits that are widely accepted but rarely used.

2. Design Patterns | Object Oriented Design
http://www.oodesign.com/
This website contains a large number of known design patterns in programming, grouped into three separate categories: creational patterns, behavior patterns, and structural patterns. Each pattern is explained in detail, as well as its applicability and examples of where it can be used. Some also include “When to Use” and “Common Usages” sections.

3. Lecture Notes | Elements of Software Construction | Electrical Engineering and Computer Science | MIT OpenCourseWare
http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-005-elements-of-software-construction-fall-2011/lecture-notes/
These lecture notes have been collaboratively authored; this collection of PDFs (and supporting ZIP files) contains helpful information on a variety of subjects, such as test-first programming, state machines, concurrency, and graphical user interfaces.

4. Design Patterns---JavaCamp.org
http://www.javacamp.org/designPattern/
This website covers many details of design patterns in detail, as well as many specific ones. Its focus is on Java programming, but can be used to learn about object-oriented programming in general.


Videos

1. Design Patterns by Mike Abyss
https://www.youtube.com/watch?v=ffQZIGTTM48&list=PL8C53D99ABAD3F4C8&index=1
Mike Abyss, a Vietnamese-Canadian who is enthusiastic about programming (specifically C#) has created a series of online videos in which he describes several different design patterns, using Visual Studio and Wikipedia to walk through the details of each pattern, as well as an example program that uses it. The real-time application of each pattern will make them easier to learn -- Mike even learns a few things himself in his videos!

2. Code Practices by Brian Will
https://www.youtube.com/watch?v=ho4VjHliP68&list=PL28704BC3557868CB&index=1
This playlist, part of a larger series of programming material at codeschool.org, is provided by Brian Will; it focuses on the essentials of good software, such as correctness, robustness, and security. Its format is similar to that of a Powerpoint presentation, but with live narration added.

3. Design Patterns Video Lecture, IIT Bombay
http://freevideolectures.com/Course/2318/Software-Engineering/15
This video lecture (part of a series presented by IITBombay, India, under the program NPTEL), covers a few details of design patterns. If you can ignore the instructor’s accent, this will be a helpful resource!

Articles

1. 7 tips on writing clean code | Larsblog
http://www.garshol.priv.no/blog/105.html
This blog entry includes some helpful programming tips from Lars Marius Garshol, a Norwegian technologist living in Oslo. These tips are based on problems that tend to recur again and again in code written by other people.

2. Coding Style and Good Computing Practices
http://www.nyu.edu/classes/nagler/quant2/coding_style.html
This article appeared in the Political Methodologist; it includes helpful practices related to modularity, formatting, documentation, and other topics that can be used to make it easier for code to be “replicated” -- thoroughly explained and reused.

3. Why clean code is more important than efficient code | TechRepublic
http://www.techrepublic.com/blog/programming-and-development/why-clean-code-is-more-important-than-efficient-code/4284
Chad Perrin, an IT consultant, developer, and freelance professional writer, discusses his reasons for putting clarity ahead of efficiency at certain times, while putting more emphasis on efficiency at other times. As an example, he talks about a program that he once made, which became very inefficient due to its surplus of clarity and lack of efficiency.

Jonathan Vinson:

http://www.garshol.priv.no/blog/105.html
a condenced version of clean code.

http://www.amaxus.com/cms-blog/refactoring-to-clean-code
a good example of step by step refactoring using ideas from clean code etc.

http://www.codeproject.com/Articles/3460/Agile-Programming
step by step methods of using agile programming methods

http://www.techrepublic.com/blog/tech-manager/four-variants-of-agile-development-methods/3664
all about XP agile programming

http://www.devx.com/architect/Article/32761
an easy read with a lot of info on 7 agile programming methods

http://sourcemaking.com/refactoring/when-should-you-refactor
some ideas on when to refactor code

http://geekswithblogs.net/akraus1/archive/2010/04/04/139091.aspx
some code to be cleaned with steps of cleaning it

http://www.google.com/#hl=en&tbo=d&sclient=psy-ab&q=code+that+needs+refactoring&oq=code+that+needs+refactoring&gs_l=serp.3...18333.27274.0.27425.38.33.5.0.0.0.433.5620.10j11j11j0j1.33.0.les%3B..0.0...1c.1.e-FQoVu5aAY&pbx=1&bav=on.2,or.r_gc.r_pw.r_qf.&fp=e48dc5e2e2f95bfb&bpcl=39650382&biw=3456&bih=617
a simple presentation on refactoring code

http://www.youtube.com/watch?v=XcT4yYu_TTs
GoogleTech Talks about writing clean code

http://theholyjava.wordpress.com/2011/02/14/clean-code-four-simple-design-rules/
some basic rules to follow if you wanna start writing clean code


Michael Holt:

http://www.tigris.org/nonav/scdocs/ddCVS.html
Source code version control with Concurrent Versions System (CVS)
 
http://www.ericsink.com/scm/source_control.html
Introduction to source control using centralized version control tools
 
http://www.onextrapixel.com/2011/01/20/10-principles-for-keeping-your-programming-code-clean/
10 Principles for clean code
 
http://www.ibm.com/developerworks/rational/library/nov06/pollice/index.html
About keeping clean code with examples
 
http://drupal.technicat.com/writing/programming.html
Seven habits of highly effective programmers
 
http://repeatgeek.com/career/5-types-of-comments-to-avoid-making-in-your-code/
Examples of bad comments and how to avoid them
 
http://www.cs.arizona.edu/~mccann/style_c.html
How to develop a good programming style
 
http://www.ehow.com/how_6769859_improve-programmer-productivity.html
How to improve programmer productivity
 
http://www.jaysonjc.com/opinion/top-10-traits-of-a-good-programmer.html
10 traits of a good programmer
 
http://betterexplained.com/articles/a-visual-guide-to-version-control/
A visual guide to version control


Conal Green:


CC-TDD & Software Development:

<https://sites.google.com/site/tddproblems/>
A TDD Problem Repository... it has good ideas, but possesses no resources for pursuing them. However, they may be handy in developing labs, or for students to pick from on their own.

<http://osherove.com/tdd-kata-1/>
This is a neat lab/kata, and it has a video solution in eclipse/LamdaJ (terribly fuzzy), and another for NetBeans, the Video Solution for which is found at:
<http://vimeo.com/8506325> (use HD for goodness sake, or you can't read a thing!)

<http://www.micsymposium.org/mics_2005/papers/paper10.pdf>
A full lab assignment emphasizing TDD, but also ustilising a software development approach, as it is team based. You could use it part-and-parcel, or adapt it as you see fit. Oh, and its linked lists, which is always good.

<http://gojko.net/2009/02/27/thought-provoking-tdd-exercise-at-the-software-craftsmanship-conference/>
Another TDD exercise, this time implementing the game "Go". As it stands, it is an example, but it seems it was and possibly again could be a Lab, and might be used as the template for a custom Lab.

<http://sourceforge.net/projects/flagsemaphore/>
This supposedly works, but the code (c++) is hideous!! It has several hundreds of lines, obscured by as-much commentary, which apparently is all the documentation. Overkill.

<http://sourceforge.net/projects/svideoconverter/?source=directory>
A simple project to clean and/or enhance, but there is some *.form stuff that I know nothing about... oops. Each student could try and then later compare the results as an exercise.

<http://sourceforge.net/projects/emergentmerc/>
Straightforward, yet big enough for teams. It is a game, but is AI primarily concerned with emergence. Perhaps the class could develop project for it as part of software development section? For cleaning projects you get (100+ files / 20 students) = 5+ each. (it didn't look really grubby though...)

<http://sourceforge.net/projects/gcalc3/?source=directory>
Probably a bit too big to tackle in its entirety, but some of its components might be worth a look.

<http://sourceforge.net/projects/borg-calendar/>
-- Big project; under "\borg_src\BORGCalendar\src\net\sf\borg\model" there're a bunch of 500-liners...


Design Pattern Specific:

<http://www.javaworld.com/columns/jw-java-design-patterns-index.html>
Seems to be a really in-depth hands-on pattern walk through, especially this next guy:
<http://www.javaworld.com/javaworld/jw-02-2002/jw-0222-designpatterns.html>
But that column actually starts here:
<http://www.javaworld.com/javaworld/jw-10-2001/jw-1012-designpatterns.html?>

<http://userpages.umbc.edu/~tarr/dp/lectures/Factory-2pp.pdf>
This seems to follow a more "and so, class" approach, which may be useful to contrast alongside HeadFirst for some folks.

<http://www.freejavaguide.com/java-design-patterns.pdf>
22 Pages of summary, a handy tourist version before jumping in HeadFirst Design Patterns...

<http://www.javacamp.org/designPattern/>
 This is Quick & Handy, with simple hello-world-level code examples of each pattern, minus long explanation. Kind of a reference sheet, if you follow me.

<http://www.csi.ucd.ie/staff/meloc/DesignPatterns/Practicals/Abstract%20Factory.htm>
This is just a Factory & Singleton Exercise, but with no solution provided...

<http://www.decis.fr/Documentation/Thinking/TIPatterns-0.9/TIPatterns.aspx>
Another book, but with "do-this-to-the-following-code" exercises. The exercises, while without solutions, are marked and would probably make good homework.


Jonathan Gertig:

http://code.google.com/p/agamepad/
Cool project using android phones as game controllers for PC over wifi.

http://rosettacode.org/wiki/
Awesome this site has examples of different code in a lot of languages on every page. Nice for code translation.

http://www.lagerweij.com/2011/05/28/code-cleaning-a-refactoring-example-in-50-easy-steps/
A interesting example of re factoring a project from a guy in the business.

http://www.gginc.biz/jfront/index.html
jFront is cool it allows you to to operator overloading in JAVA! Sort of you write it as if you had oo then it translates you code in to the nasty nested function calls you need for Java.

http://www.howmvcworks.net/Zoo/LookAtTheMonkey
A nice view on how Model View Controler works. This is from a .NET stand point.

http://railscasts.com/?page=34&type=free
Ryan Baits is really good at explaining and giving examples. Want to learn ruby on rails Well his web casts are great. He has all the basic beginner videos free so don't worry.

http://www.minecraftforum.net/topic/1468550-145-mcreator-make-minecraft-mods-without-programing-knowedge-updatedminecraft-forgelansmp/
Wanna learn to mod video games here is a simple learning tool for minecraft.

http://mcp.ocean-labs.de/index.php/Main_Page
Understand how to mod now get the Mincraft coders pack a look at the code behind the game.

http://stackoverflow.com/questions/60658/rails-model-view-controller-and-helper-what-goes-where
What is the best structure in MVC?

http://www.1stwebdesigner.com/tutorials/css3-tutorials-2012/
Nice web design tutorial and info site.