"If you want to stand out amongst your peers while taking an interview then take Fluency! Fluency course is a microcosm in itself mimicking the real world practices. You come in contact with many industry wide practices but behind the safety net of an academic course. Some of the stuff you will learn includes working in a small & huge teams, working with a huge codebase, working with a version control system, learn how to identify tasks, organize the tasks according to priorities, use a bug/issue tracker, write JUnit & Functional tests, get to know about the build/ant scripts, learn how to use code review techniques like fisheye, bamboo, get schooled by professor on how to be disciplined both in coding & non coding afairs.... I can go on & on. Bottom line - a hell lot of work (I mean it! Not for weak hearted folks! Query professor about the course attrition rate :D) but lessons learnt will definitely give you a leg up in real world!"
Chintan Tank, Fall 2008 (masters)

"The first day of class I was told that I would be doing 20-30 hours of work a week and I didn't believe it. It turns out that you HAVE to put in that much time in order to be successful in this class. You will struggle. That is a given. But, if you stick with it you will learn A LOT. That is also a given. Professor Rawlins is one of the best professors you will find in computer science, which means you can trust him and follow his every direction and you will become a much better programmer and teammate. I feel that after taking part in this course I have leaped into my career as a future programmer. This is a great course that is worth a shot."
Thiago Rebello, Fall 2008 (undergrad)

"If you really want to understand modern programming you will need to understand design patterns. If you want to become a truly great programmer you will (in all likelihood) need to master design patterns. B629 is designed to provide not only a crash course and thorough introduction to design patterns but, also, to make sure the motivated student really understands the patterns used during the class.

Of course, you won't leave an expert. If you work hard on the assignments, however, you will leave with the tools you need to develop expertise and to, perhaps, someday develop into a truly top tier programmer. You will also have the opportunity to work on Fluency (an open source Java project) which will look great on any CS student's resume. No other course at IU is quite like this one. It is a great class but, beware, it is not for feint of heart or the Java novice!"
Michelle Wynn, graduated spring 2008 (masters student)

"You may have worked on several programming assignments or projects. Most of them are so simple that you finish them off in a night. Few of them are complex. You start writing code and then as you progress, you realize you did not consider certain design issues at the start. And because your design is not flexible now, you either start again from scratch or do some patch up work. You do eventually finish the code. you even earn good points for it, but the feeling always stays- "I should have done it in a better way". Though we realize this, we don't understand what is that BETTER WAY? How long are we going to continue like this? Our haphazard approaches are surely useless in the world outside of class assignments. We need to learn how to design big software systems and how to keep them flexible and extensible.

Welcome to the world of design patterns! You will learn a whole new approach of programming in this class. You will feel surprised that most of the problems could be categorized and solved using standard designs. You will get a whole new vision to design your programs. And when you start with a good design, you will be amazed to see how things fall in to place as your program grows. Also, you are not just going to learn textbook stuff, but you are going to get your hands dirty in Fluency which will give you ample opportunities to use all the knowledge that you have gained. It's tough but exciting! Best of luck!"
Abhijit Borude, graduated spring 2008 (masters student)

"Nobody builds a house brick by brick
rather they build walls, stairs etc.
Analogously, nobody builds software by creating objects
but by creating functionality to bind objects.
So, in my opinion, patterns and refactoring are no longer optional knowledge
but are required to build medium to large size software."
Aleksander Slominski graduated spring 2007 (phd student)

"Anyone can open "Gang of Four" or some other design patterns book and learn about design patterns. In the class, however, you will go beyond the trivial examples given in these books and learn how to apply design patterns to a large project. You'll not only learn when to add a pattern to the project, but also when to remove one if it is overkill. But design patterns are not the sole focus of this course; you'll also get first hand experience with the extreme programming (XP) philosophy in a collaborative effort on a large scale application. This class is not for the faint of heart - be ready to work hard and earn your grade. I really enjoyed the class and I'm sure you will also."
Nathan Deckard, graduated spring 2006 (undergrad)

"The world is absolutely mind-numbingly, staggeringly complex. Be very afraid. Most software we write mirrors this complexity but when done properly manages to hide most of the monstrosity behind a wall of simplicity, be it a clean API for a framework or a polished interface that's eminently usable. It's great that amidst all of that chaos we've been able to uncover a common set of reusable concepts to manage this complexity in a flexible, elegant way. It's not so great that it can be misapplied just like any other powerful tool, and with similarly disastrous results. If you intend to write or work with large pieces of code, please, for the sake of the software community... learn them, and then learn when to use them."
Allen Lee, graduated fall 2005 (masters)

"[F]rom my personal experience, a lot of the patterns that we end up studying are nothing ground breaking in concept (though some are fairly complex) - many are things you think up in your own personal work to solve various problems when you sit and think about your design - before you even know they have a name. What is ground breaking is taking the time to step back and look at the big picture and see how they can apply to so many scenarios and be generalized to concepts that eventually guide your code without always consciously doing so. A design patterns course is the time to sharpen you skills for doing this, and regardless of whether you know the names or UML diagrams afterwords, the pieces of the puzzle start coming together a lot more easily."
James Ellis, graduated spring 2005 (undergrad)

"[A]s I am preparing for performance reviews at my company I started thinking back to when I took your design patterns class in fall 04. I wanted to email you and tell you that I am now starting to realize the benefits that class has given me. I've already been informed that I'm up for a promotion to a leadership position and a raise because I have gained a reputation in my company as one of the best programmers here, and I graduated only this past May. I can attribute this to my interest in design patterns and software architecture which was sparked by B490 that semester. You should seriously consider expanding the class to include more undergraduates."
Nick Durcholz, graduated spring 2005 (undergrad)

"Design patterns are a wonderful tool. Their main help to me has not been in the smallish homework assignments that you get in the typical class, but in the real world. In my current job we would be completely lost without them. In fact I don't even want to think about what the system would be like without them. However, it was in searching for a job that they helped out the most. When I was doing the technical interviews for my new job that I start this summer, it was design patterns that sparked their interest the most. It was kind of fun to watch their eyes open a little wider when I applied a design pattern to the problem they gave me, and hear them say, 'So, know design patterns, eh?'"
Bryan Dawson, graduated spring 2002 (undergrad)

"The knowledge of how to use design patterns should be an integral part of any serious programmer's discipline. They allow one to reason about and build complex systems in a way that wouldn't be possible without them. Building sophisticated and professional software without the use of design patterns would be like building a house without a blueprint. You may be able to hack something together, but what you'll end up with is a piece of junk that is a nightmare to maintain."
Eric Westfal, graduated spring 2002 (undergrad)

"Any programmer can hack together some code. This class will teach you what you'll spend 2 or 3 years learning in 'The Real World'. Programmers are a dime a dozen, developers are not. Knowledge of design patterns and refactoring help make the difference."
Gordon Murphy, graduated spring 2001 (undergrad)

"To be an OO developer you must be good at: creating designs, reviewing designs, writing code, reviewing code, refactoring a system, creating and using test suites, and working within a project infrastructure. Most courses focus only on writing code, but working on KnownSpace taught me about all of this. The insights into OO development that I gained on the course helped me both to find a job as a developer and to do very well at that job."
Sean Broadley, graduated spring 2001 (masters)

"I took [B649] in 1999. I remember right before I took the class, John Vlissides came and gave a talk on patterns at Lindley. Design patterns was a new idea to me back then, and although I enjoyed sitting there and watching the power of several simple patterns unfold on the whiteboard, I did not have much belief in design patterns until after I took [B649], which provided me extensive exposure to various design patterns and great (although challenging) opportunities to apply patterns to practical programming problems. To these days, I firmly believe that my research and development work have benefit greatly from the idea of patterns. I do hope others would take on [B649]'s challenge and benefit from the experience for a long time to come."
Yuchen Zhang, graduated fall 2001 (phd student)

"You need to first understand that you probably have never seriously designed software before. Software design is an essential skill when you are involved with large projects. It is part application of known patterns and part artistry. Gregory Rawlins will teach you the principles behind good software design, which will help you absorb the intent and usefulness of existing design patterns and, more importantly, give you the grounding to develop the necessary intuition for creating your own patterns - that's where the artistry comes in. This course will give you these essential skills and help you appreciate the complexity and beauty of software design."
Nirmal Mukhi, graduated fall 1999 (masters)