• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other all forums
this forum made possible by our volunteer staff, including ...
  • Campbell Ritchie
  • Liutauras Vilda
  • Paul Clapham
  • Bear Bibeault
  • Jeanne Boyarsky
  • Ron McLeod
  • Tim Cooke
  • Devaka Cooray
Saloon Keepers:
  • Tim Moores
  • Tim Holloway
  • Jj Roberts
  • Stephan van Hulst
  • Carey Brown
  • salvin francis
  • Scott Selikoff
  • fred rosenberger

"After The Storm..."

Posts: 3226
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
Passing the SCPJ2 exam is the easy part... (Listen to me talking without even having taking it yet!) In the real world, doing OO design will be an issue in any really significant job. I have done only functional/structured design. As soon as I pass the Sun exam, I need to concentrate in the design methodologies that are used in Java shops:
Posts: 23226
IntelliJ IDE Firefox Browser Java
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
UML is important. Patterns are important. For being up close and personal to code, I think the refactoring book makes a lot of things clear.
Above all: simplify.
Appropriate use of OO and the iterative process (with two week iterations) is good.
Hmmmm. Experience with existing stuff in Java is good cuz there is some good OO stuff there.
Posts: 6920
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
There's a whole lot of OO material out there, but a lot of it just clouds the issue or gets in the way of understanding. What I would recoomend is actually studying (and applying) some of the more modern light-weight design "methodologies" which concentrate on the problem to be solved rather than the technical details of the solution or the mountains of paperwork. The hard part is freeing your mind from structured/procedural assumptions so that you can see the "shape" of the problem.
Some practical hints:
1. (as Paul recommends) Study the Java APIs and constantly ask yourself "why did they do it this way?" Don't just use them and move on, but try to think of alternative (maybe structured/procedural) ways of doing the same thing, and see if you can spot any advantages or disadvantages in the OO approach.
2. Get into the habit of designing solutions in a completely language-independent way. Listen to the structure of the real problem before forcing it into the constraints of any one way of solving it. Real-world problems almost always consist of multiple "things" each of which has attributes, resposibilities and so on.
I use CRC cards as a technique for this, and I give a cut-down example of their use for OO thinking (and some references) in another forum/thread which I can't remember at the moment (search for CRC).
3. Read, study, internalize and apply some of the writings from the better authors. I strongly recommend the following:
"The Pragmatic Programmer: From Journeyman to Master" Andrew Hunt & David Thomas (ISBN 0201616224) - A really practical and accessible book which will improve your software development skills.
"Extreme Programming Explained: Embrace Change" Kent Beck (ISBN 0201616416) - A readable and, above all, do-able introduction to one of the most promising of the new light-weight methodologies. I use this for my own projects and without doubt I am much faster, less stressed, produce code which is more reliable and maintainable, and meet real requirements better. Much of the discussions and material which inspired this book is also online at http://c2.com/.
"Refactoring: Improving the Design of Existing Code" Martin Fowler (as discussed elsewhere here) - One of the major parts of Extreme Programming directly applicable to Java programming and usable on its own.
"UML Distilled" Martin Fowler (as discussed elsewhere here) - generally considered the best (and shortest!) UML book. Just like the others in this list it also covers general OO development practice. I don't necessarily recommend that you use UML, just that you understand the reasons behind it and the kind of interactions and relationships it is designed to describe. Stick with the lightest documentation process you can get away with.
You might find "Design Patterns" Gamma et.al. useful, but I don't like to recommend it to anyone who isn't already a fluent OO designer. Applying the patterns in it without thought and experience can lead to a lot of problems.
Paul always recommends "Just Java", but I've never read that myself. Others seem to like "Thinking in Java".
Read online, too. I like a pair of articles from the C/C++ Users Journal ( http://www.cuj.com/archive/1605/feature.html ) and ( http://www.cuj.com/archive/1606/feature.html ) but there's tons more ...
I hope some of these points are useful. Let us know how you get on.
Tony Alicea
Posts: 3226
  • Mark post as helpful
  • send pies
  • Quote
  • Report post to moderator
Thanks to both of you! You have been very helpful. For some reason, I was under the same impression about the DESIGN PATTERNS book. I'll skip that one for now...
Ah yes! Eckel. I think I'll start with the chapter that he has on design patterns if only because I already have the book, and the book is about Java!
Again, much thanks. I am doing a copy/paste of the info for keeping...
With a little knowledge, a cast iron skillet is non-stick and lasts a lifetime.
    Bookmark Topic Watch Topic
  • New Topic