>>If you've reached this point in the class doing the readings and successfully doing
the exercises, congratulations. You may now call yourself a computer programmer. Welcome
to a very elite club. Up to this point we've worked on relatively small programs. We usually
measure the length of programs by the number of lines of code they contain. Lines with
only comments and blank lines don't usually count. Some people count lines with single
curly braces and others don't. Lines of codes is one of the ways that employers keep track
of how much work a programmer has done. The biggest program that you've probably written
as a part of this class was around 2-to-300 lines long. That's a substantial intellectual
achievement. The programs that commercial Software Engineers write can have millions
or even billions of lines of code. The next big challenge that you'll encounter in programming
is learning how to organize programs to better be able to manage the complexity of larger
programs. To do this effectively, you need to be able to control more complicated relationships
between classes. So far we've seen two relationships between classes. One class can use another
class. For example, most of our classes use the String class, because their twoString
method returns a String. Another relationship between classes is called aggregation. This
happens when one class has instance data from another class. For example, a class that stores
addresses or aggregates String objects. If you look back at your code you'll see that
these are the only relationships between classes that we've used so far. An example of a more
complicated relationship is inheritance. Inheritance is used when you need to create a class that's
similar to an existing class, but has some special properties or actions. For example
when we program Graphical User Interfaces, there's a class called AbstractButton that
has all of the functions you'd expect. When it's pressed or released some action happens.
There are lots of Java classes that inherit from AbstractButton, like JButton, JMenuButton,
and JToggleButton. JButton is is a plain, regular button like the buttons that let you
de-bug or run programs in Eclipse. A JMenuItem is also an AbstractButton. That one may not
be as obvious, but if you think about it, you select a menu item and some action happens--
and that's button-like. JToggleButton is used to allow users to select a button that works
like a light switch. An example of a JToggleButton is the PButton in Eclipse that either shows
or conceals the whitespace characters. The action that happens with JToggleButton includes
keeping the button down or up until it's hit again. So each of these buttons has some special
action that's related to the general idea of being...button-like, but they do something
special. Inheritance plays a very important part in object-oriented programming, and is
one of the relationships between classes that you need to master if you're going to continue
programming in Java. One of the sad facts of programming is that commercial Software
Engineers produce only about six lines of code per day of programming that's actually
delivered to customers in the product. That probably sounds impossible to believe, but
it is true. Of course Software Engineers write many, many more lines of code than this, but
those lines don't make it into the final product. We know that the difference in productivity
between the most productive and the least productive Software Engineers is more than
a factor of ten. Some people think it may even be a factor of fifty. That's a huge difference.
If you want to be one of the more productive programmers, you'll need to continue to learn
about Java or some other programming language, and continue to practice programming. There
are lots of ways to do this. Of course you can take more classes, like CS 2334 Programming
Structures and Abstractions at the University of Oklahoma. This is a second-semester Java
class that covers more complicated relationships between classes like inheritance, shows how
to manage user and program errors better using Exception handling, and helps you use the
Java API more effectively, amongst other things. You can also read books about Java. The challenge
you'll run into right now is that you're probably somewhere between a beginner and an expert.
There are lots of books for beginners and there are lots of books for experts, but there's
less in the middle. Some books for beginners are so big, sometimes eight or nine pounds,
because they try to give beginners enough information to bridge that gap, and those
books can be a good place to start. As you move towards being a more advanced programmer,
a book you might enjoy is "Java Puzzlers" by Bloch and Gafter. Joshua Bloch has also
written several books on how to program well in Java, and some of the pitfalls that Java
programmers encounter. One of my favorites is called "Effective Java"-- it's considered
required reading by anyone who programs professionally in Java. O'Reilly is a publisher with some
outstanding books on many computational topics, including Java. I like their nutshell series
of books, particularly "Java In A Nutshell." I have more than a dozen O'Reilly books within
arm's reach right now. Another way to learn about programming is by visiting programming
websites. Be careful which ones you choose, because there's a lot of really bad code and
even worse advice out there. One of the better websites is the Oracle website on Java [http://java.sun.com].
They have lots of great learning materials, although they're usually pretty advanced for
beginning programmers. Although it can be frustrating to read materials for more advanced
programmers at first, it does get easier with practice. Another way to grow as a programmer
is to pick a pet project. This is one of my favorite ways to learn to program in a new
language. As you encounter new challenges you use books and websites as resources to
learn the parts of language that you need at that moment. Many of the big international
companies that employ our graduates have told me they won't consider hiring anyone who hasn't
done some programming project just for the love of programming. Choosing a personal project
can be tough. Many students want to program games, but unless the game is modest it can
be so overwhelming that it never gets started, let alone finished. It's probably better to
write a program to play Tic-Tac-Toe or Tetris rather than to try to program your own personal
World of Warcraft. You'll have more fun if you find some friends to program your project
with you. You'll also be more likely to stay committed to the project and get it finished.
A finished personal project, even if it's small in scope, will make a much bigger impression
on a future employer than an unfinished, massive code that doesn't run. And just because you're
programming for yourself doesn't mean that design and documentation aren't important.
No future employer ever wants to see undocumented code. So we will part company, at least for
now. I hope that you've discovered the love of programming in this class, and that you
have as much joy building amazing software as I've had. Good luck, and happy programming.