"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
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
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
Nirmal Mukhi, graduated fall 1999 (masters)