Main links

Section links

There are hundreds of Java books! Why is this one special?

Section links

Why?

Thank you for wanting to learn programming! You will soon find that it is an enjoyable and brilliantly creative craft. And thank you for choosing to learn the most modern style of object oriented programming. And thank you again for choosing Java -- a serious and widely used programming language, not a noddy one specifically designed for teaching.

Ah, but therein lies the rub -- Java is a tricky language to use as a learning vehicle for programming because it is a real one. So there has been much debate on how to do it, with many conflicting views and failed experiments. As a result there are a great number of Java books for you to choose from, all different in various ways from each other, and from this one. But arguably, this one is more different than most!

What's more, it has been shown to work.

• This book is genuinely aimed at people who have never programed before -- it starts where you are now, based on your previous perceptions and relevant non-programming experience, rather than expecting you to somehow leap ahead.
• It is all based on a large number of example programs (well over a hundred), so the emphasis is on gradual acquisition of programming and problem solving skill, rather than the simpler, but less useful, topic of programming language. It does not assume that just by being shown Java concepts you can instantly be a programmer. Instead it shows you how to design code and gives you plenty of practice.
• Also, this means that the introduction of every programming concept is motivated by us wanting to use it in a real program straight away -- part of the just in time idea.
• Despite the above, the examples are arranged into chapters that focus on particular major topics, so each stage has clearly stated coherent aims.
• It never uses the `boiler plate' approach of telling you to ignore parts of Java that cannot be explained to you just yet. That leads to confusion and uncertainty. Neither does it go for the approach in which everything is explained right now in all its gory detail. Instead, it adopts the just in time principle: everything is explained when you first meet it, but only to a level of understanding that is appropriate for that stage of the learning process. Concepts are elaborated upon later in the book as required.
• It is not objects first -- meaning that it does not assume you naturally view the real world as a collection of interacting objects. Instead it recognizes that you probably have a `self centric' view, i.e. you see the world in terms of how it interacts with you, and the steps you must take to achieve a particular outcome. So our starting point is task oriented, rather than object oriented. For example, how do you view the process of running a bath? Do you: 1) put the plug in, 2) turn on the tap, 3) wait until full, 4) turn it off, and finally 5) get in. Or do you regard the plug, the plug hole, the tap, the bath and yourself as objects such that the plug interacts with the plug hole, and the tap interacts with the bath by passing water to it, and ...?
• It is not objects late either -- that approach spends a long time permitting you to learn programming without using objects, and then, just when you have gained your confidence, destroys it by changing the rules.
• Instead it has a basics first, objects soon, inheritance later order to the learning. This has proved to be most successful for students new to programming, allowing them to start from where they are, build up plenty of confidence, and then, just in time, meet objects and object oriented programming before the habit of not using objects becomes too ingrained.
• When objects are introduced, it is done by revisiting a previous program example and gradually simplifying its implementation by using object technology. Thus, there is never a point when the idea of objects lacks motivation -- their benefit is immediately obvious, which readily leads to seeing them as natural! In other words, you are painlessly taken to the point where objects first books assume you already are.
• When you do meet objects, you get an open box coverage of them, that is, your objects are created from code you have written, rather than from something hidden away. This means you see at the same time how objects are defined as well as how they are created and used -- so you properly understand an important principle called encapsulation.
• The presentation of the book is such that the need to flip back to previous pages is minimized. For example, when we have a program which is a variant of a previous one, the parts of the code which have not been changed are presented again, but using a small font. This also emphasizes the new parts, whilst being able to see their proper context clearly.
• The book recognizes that programming is at least 51% confidence, and reflects this by providing coursework exercises which collectively mean you write a huge number of programs.
• It has no end of chapter exercises -- they are too easily ignored because they all come in one lump. Instead coursework tasks are more usefully, and carefully, located at the end of examples within the chapters. This means you can practise the new skills and concepts in a timely and paced manner.
• Coffee time questions, sprinkled throughout the text, are designed to invite you to think more deeply about what you have just read.
• All the concepts introduced in a chapter are listed at its end, each with a self assessment question (and a reference back to the page it appeared on). So you can check your learning from each stage before moving onto the next one.
• There is a consolidation chapter just before we start talking about objects. This provides an opportunity to cement and review the foundations for those who were new to programming, but is also a possible entry point for those who already have significant (non-object oriented) programming experience.
• A collection of all the concepts covered, in an order suitable for reference and revision, is available on this website.
• The book does not depend on a particular programming environment, which makes it usable in any. However, it recommends reliance on the absolute minimum of programming tools to start with. Otherwise, confidence built during learning can be too centred on the particular environment used, and thus may disappear if you are placed in a different one.
• Further, it does not depend on the use of any non-standard library code to hide the grubby details early on to get you started. That would create another unhealthy dependency, and confuse you about what is standard Java and what is not. Instead, the book carefully avoids the need to hide things from you in the first place!
• The book is not unnecessarily rigid. For example, it does not incorporate a strangulating code style on the program code, such as using unhelpful systematic naming conventions or being obsessed with presenting named parts in, say, alphabetical order. Where there is a variety of approaches, such as in the way programs handle erroneous situations, the book does not arbitrarily choose one, but exposes you to different strategies in different examples.
• The important, but simple, topic of producing on-line program documentation is covered in appropriate places, but the overall learning process is not cluttered by it appearing everywhere.
• On the other hand, program testing, another important, and more complex topic, is centrally visible throughout the text. Every program is tested, but not in a way that encourages a reluctant view of testing, nor one that obscures the learning of other principles.

How? (Embedded pdf)

Dear Student, how should you use this book?
(Extract from the book.)
Expand: How? (Embedded pdf)

How? (Separate pdf)

Dear Student, how should you use this book?
(Extract from the book.)
How? (Separate pdf)

Pedagogical design principles

The book has been carefully crafted to follow a specific and possibly unique set of principles.
Pedagogical design principles