Variants Books

Arrived right on time. Book was in perfect condition. Great service, would order from them again.

You can find all of the source code and errata for this book here:

http://www.lclark.edu/~drake/dsaj.html

(I am the author. I hope it will not be seen as overhyping to rate my own book at 5 stars, but I couldn't find a way to post this information outside of a review, nor to post a review without giving a rating.)

The explanations are good but the examples are too thick and hard to follow if you haven't known the language that long.

Drake wastes little time in getting to his subject. You are expected to already know at least the rudiments of Java. Hopefully of version 1.5, which is the current major release of Java. The numerous code snippets in the text are drawn from this version. Because it has a very extensive set of native classes that implement many of the structures covered by the book.

The text can be read at one or both of two levels. Firstly, you might already be well familiar with such ideas as linked lists, hash tables, trees, graphs, sorting, searching etc. Perhaps from other languages. What you are looking for is a comprehensive description of how these are expressed or can be expressed in Java.

The other level is where you need to learn the data structures and algorithms for the first time. Here, there is a stark contrast with Knuth's classic "Art of Computer Programming". That is a far more advanced text. But the relevant difference in our context is that Knuth requires you to write all the code yourself, in some language. Whereas Drake demonstrates how, right out of the box with Java 1.5, you get so much already implemented, for free. The latter is not figurative. The Java 1.5 distribution is made freely available by Sun.

It should also be said that this book will still be germane when 1.5 is superseded by future versions of Java. You can safely expect that those versions will be supersets of the functionality used in this book, based on the prior history of the major Java versions and how each differed from its predecessor.

This was the first book I read regarding developing Java Beans with VisualAge. I have read many since and have not found a better book. Great read! I would love to be able to find more books like this one.

Few books tell you the proper way to use Visual Programming tools alongside Object Oriented concepts. Even when I use VAJ 2.0, this book avout VAJ 1.0 proved to be an invaluable guide.

If just the authors could write another book expanding on the subect of Visual Design patterns... :-)

Although fairly expensive, this book does an excellent job of walking you through the basics of VisualAge for Java. I once was skeptical about the benefits of IBM's fancy Java IDE, but no more. This is a big step for a dinosaur who three years ago insisted on a UNIX command line interface for everything. Buy a copy of this book.

This book is good for people who are familiar with Java and want to learn the powerful Visualage envionment. However, the CD was missing all the samples and data files referenced within the book. Maybe the authors can tell me where I can download them.

I found this book a pretty good intro for a Java Developer/Architect who knew Borland JBuilder and Ant very well but who "just didn't get it" in terms of Views / Perspectives in Eclipse etc.
This book was a good tutorial / introduction to the various features in Eclipse and how to us it (focuses on the 20% of those features you will use 80% of the time). I found Eclipse 3.1.2 was a bit different than the version he used and with Eclipse 3.2 now out (Q2 2006) I'm sure a few more changes have occurred but the exposition style is good and gets to the point.
Although I think it is the best book for the purpose, I think those who want to learn and use the Eclipse Java IDE don't have much in the way of quality choices to learn it in terms of books at least.

The latest Eclipse is well described here by Valcarcel. It has rapidly become perhaps the most popular IDE for Java programmers. Of course, being free didn't hurt the uptake.

He assumes you have already programmed in Java itself. The book has three parts and an Appendix. The first part covers the basics. Essentially, it shows how to write and debug a standalone Java application in Eclipse. Competently done. But frankly, little to distinguish from other Eclipse texts. At this level, we are basically in an IDE equivalent to IBM's earlier Visual Age for Java, circa 2000. From which Eclipse is derived, by the way.

The second and third parts of the book are far more interesting. Part two is all about using plug-ins to build up an application. Here is where Eclipse really shows its power. Also, the author describes how to make a Web Service using Eclipse. Web Services are a hot topic, and for those of you wanting to get into it, without giving up your familiar Eclipse environment, that chapter may justify the entire book.

Finally, part 3 is about the basics of writing a plug-in. You can really dig deep into the Eclipse framework for this. It may be the most advanced part of the book.

The value in this book is it's breadth of coverage. It never digs very deep into topics. The coverage of UML editing, for example, is about 30 pages. But that's thirty more pages than most of the Eclipse books have on UML. And the coverage is of a wide variety of these topics, including Struts, web services, JSPs, and others. The basics are covered as well, starting with installation and the basics of starting up a project, going through source control, unit testing, and refactoring. It's all there. It's just set to a whirlwind pace that may leave you a little breathless. Good book, just not for very beginners.

I needed a book to get up to speed on Eclipse 3.0 for work, I found it with Carlos Valcarcel's book. The chapters are just the right length and cover a vast array of topics, from MyEclipse, GUI Layout, CVS, Struts, building your own plug-ins, its all there and then some. The book's site can be found here: http://www.eclipsekickstart.com/

Very helpful book for beginners to intermediate level java developers. Because,
this book starts with introduction to jsp and chapter 1 and 2 cover,
* The basics of the JSP2.0 specification
* Describes the syntax and commands, used to produce dynamic content.

After the two introductory chapters, you will move into the real thrust of the
book. Chapter 3 and 4 take the roles of developer and page designer, which
gives you,
* Introduction to javabean to deal with data,
* form handling to deal with html data
* Custom tags to build with reusable html tags.

The next chapters show you how to separate designer and developer role by
separating the application into layers, or tiers (View, Model and Controller).
Chapter 5,6 and 7 present about,
* Pattern for your web application design,
* MVC action for controlling your application
* Filter to intercept the HTTP requests and responses.

Chapter 8 finishes the pattern with,
* View helper pattern that you use to adapt data to the presentation
layer of application.

Now those chapters they have provided after 8 are surprised, personally I like this
very much about they have discussed on testing techniques and deployment techniques.
Which are very helpful chapters for some one who wants start to finish developing web
application.
I have liked chapter 3, 4, 5, 9 and 10 of this book.

A good reworking of what are now classic JSP design patterns, as codified by Sun and others. You need never have read about design patterns to appreciate this book. But chances are, you're already coding JSPs and Servlets. If so, you need a book like this. At the very least, a rough Model-View-Controller design will aid your coding.

But Patzer also goes into more detailed patterns. Like a decorator filler and a front controller. But perhaps as important as any specific pattern is that you get some idea of what to look for as a pattern that might arise out of your work. The patterns in the book show you code reuse, at a higher level than literal reuse of a given body of source code. A very powerful idea for you to grasp.

I reiterate. Understanding, using and looking for new patterns moves you into the realm of design. Increases your experience and your value. Design is higher margin work. Makes your skill sets more valuable.

He also introduces you to the discipline of testing. Especially having a unit testing framework. And since this is java, you have JUnit to help you.

For the front end of Java web applications JSP has never been given a lot of respect. It's always been the domain of lower paid 'front end programmers'. But that doesn't mean that it isn't difficult to do it right. This book takes the time to emphasize the patterns of implementation to make a solid web front end.

The book covers the web application page flow of forwarding and maintaining state. It also covers tag libraries, data validation and a host of other topics.

The text of the book is well written, and graphics are used effectively.

This is a great book for front end developers. This is the type of coverage this complex topics needs. Hopefully we can get similar books for PHP and Perl web development.

If you're familiar with JSP technology and you're ready to take the next step, you might find the book Foundations Of JSP Design Patterns by Andrew Patzer (Apress) interesting...

Chapter list: JSP Foundations; Using JSP; Role Separation with JavaBeans; Role Separation with Custom Tags; Development Using Patterns; The Decorating Filter Pattern; The Front Controller Pattern; The View Helper Pattern; Testing Techniques; Deployment Techniques; Application Frameworks; Putting It All Together; Index

While this book does cover some basics of JSP, I wouldn't recommend it for a complete newcomer to the subject. This book is more designed for the person who has learned the basics, done some work with JSP, and would now like to learn how to better structure their code to separate business logic from presentation. Patzer does a good job in showing how a consistent approach to presentation/logic separation can avoid maintenance issues down the road, and how it allows developers and designers with different roles to work together on a project. By introducing patterns, the developer can build applications with a solid structure that follow proven architecture that works. The thing I appreciate most is that the pattern chapters have plenty of code that allows you to understand the pattern both by explanation and by example of a real application. That helps take the information from a theoretical to a practical level. The chapters at the end that deal with testing and deployment are also very valuable, and they should help the developer to follow a solid approach to JSP application development from design through implementation. Very good material here.

Saulpaugh is an architect on the JavaOS project within Sun so the information is first hand.

The book does cover the JavaOS fairly completely and covers how each component works. The writing is easy to understand and readable.

I would recommend this book for anyone who is using or considering to use JavaOS or Java-based Network Computers in their work. This book will give you a good background on how everything works so you can understand the pluses and minuses of the technology well.

Well written and thought provoking .. moreso than other textbooks of this type. Addresses those areas of Java which an OS needs to consider., and which I haven't seen discussed elsewhere. (ex: an API which provides a platform neutral equivalent to the NT registry).

The style is crisp and the implications of the original architectural goals are carefully tracked. Saulpaugh is apparently working towards a language-OS symbiotic relationship of the C-Unix variety, except here the language is Java, and the OS is ... JavaOS.

This book is an excellent case study in modern operating system design. It starts with a really good idea: take the programming abstraction provided by the Java Virtual Machine, and then add features for handling hardware (interrupts, memory management, booting, and so on). This makes it a lot easier to write and debug drivers, because you can write in Java, which makes device drivers only about 3 times harder than ordinary programs (as opposed to the 100 times on Windows or Unix).

The book is logically organized, and remarkably easy to read. (OS books, like OSs, can be very complex and difficult.) Its many diagrams are very clear, and they are great ways to visualize the constructions they're describing. The text flows well, and you can just read this book like a story.

There are a lot of clever ideas in JavaOS. It's the best-organized operating system kernel I've ever seen. I recommend this book to anybody interested in operating systems.

If you're going to be writing a device driver for JavaOS, or if you're planning on deploying for JavaOS, you need to read this book. It's definitely THE introduction to the subject, since it's straight from the designers.

I would give the book five stars except that I have to ding it one star for not including thread scheduling, and for not including a reference manual.

THIS IS NOT A REVIEW. There are only two authors. They are Saulpaugh and Mirho. Book is only ~200 pages, not 350.

Very nice introduction to NeuralNetworks and how to implement them in Java.
If you're looking for deep concepts on NeuralNetwork this isn't the best choice.
But if you're looking to figure out how NeuralNetwork works and how to begin codeing them that's it.

I have been reading through the book. Actually it provides very clear explanations, but I had the impression the author talks too much and keep saying the same things over and over again. The book could be half its volume with the same content of knowledge. Besides the provided examples are a bit too simple and obvious.
Nothing much to put under the tooth. After reading it I felt left with my hunger for something deeper and more consistent. The algorithms provided also merely implement and stick to the few examples introduced. On the course of the book, the author wanders from the main point which is first and foremost to discuss neural networks under all angles. He unexpectedly brings up Fuzzy logic and Genetic algorithms which is not what the book title purports to talk about: a bit of confusion.
Overall there is a bit of deception, but indeed the book does what its title says : it is really just an "introduction" to Neural Networks with Java and nothing more. I would recommend it to somebody seeking to embrace the field and who is really a beginner in the domain.

Programming Neural Networks in Java will show the intermediate to advanced Java programmer how to create neural networks. This book attempts to teach neural network programming through two mechanisms. First the reader is shown how to create a reusable neural network package that could be used in any Java program. Second, this reusable neural network package is applied to several real world problems that are commonly faced by programmers. This book covers such topics as Kohonen neural networks, multi layer neural networks, training, back propagation, and many other topics. The content of the book is as follows:
Chapter 1: An Introduction to Neural Networks
The structure of neural networks will be briefly introduced in this chapter. Also discussed is the history of neural networks, since it is important to know where neural networks came from, as well as where they are ultimately headed. Finally, there is a broad overview of both the biological and historic context of neural networks.
Chapter 2: Understanding Neural Networks
A neural network can be trained to recognize specific patterns in data. This chapter will teach you the basic layout of a neural network and end by demonstrating the Hopfield neural network, which is one of the simplest forms of neural network.
Chapter 3: Using Multilayer Neural Networks
You will see how to use the feed-forward multilayer neural network and two ways that you can implement such a neural network. The chapter begins by examining an open source neural network engine called JOONE. JOONE contains a neural network editor that allows you to quickly model and test neural networks.
Chapter 4: How a machine learns
Every learning algorithm involves somehow modifying the weight matrices between the neurons. This chapter examines some of the more popular ways of adjusting these weights.
Chapter 5: Understanding Back Propagation
This chapter examines one of the most common neural network architectures-- the feed foreword back propagation neural network.
Chapter 6: Understanding the Kohonen Neural Network
The Kohonen neural network contains no hidden layer. The Kohonen neural network differs from the feedfroward back propagation neural network in several important ways. This chapter examines the Kohonen neural network and how it is implemented.
Chapter 7: Optical Character Recognition
This chapter develops an example program that can be trained to recognize human handwriting. It is not a program that can scan pages of text. Rather this program will read character by character, as the user draws them. This function will be similar to the handwriting recognition used by many PDA's.
Chapter 8: Understanding Genetic Algorithms
A chapter on an AI technology unrelated to neural networks.
Chapter 9: Understanding Simulated Annealing
A second AI technology that can be used to train neural networks.
Chapter 10: Eluding Local Minima
One of the most fundamental flaws is the tendency for the backpropagation training algorithm to fall into a "local minima". A local minimum is a false optimal weight matrix that prevents the backpropagation training algorithm from seeing the true solution. This chapter shows how to use certain training techniques to supplement backpropagation and elude local minima.
Chapter 11: Pruning Neural Networks
This chapter examines several algorithms that modify the structure of the neural network. This structural modification will not generally improve the performance of the neural network, but makes it more efficient. If a particular neuron's connection to other neurons does not significantly affect the output of the neural network, the connection will be pruned.
Chapter 12: Fuzzy Logic
Fuzzy logic is a branch of AI not directly related to the neural networks examined so far. Fuzzy logic is often used to process data before it is fed to a neural network, or to process the outputs from the neural network. Fuzzy logic is examined in reference to removing SPAM from emails.
Appendix A: JOONE Reference
Appendix B: Mathematical Backgrounder
Appendix C: Using the Examples on a Windows System
Appendix D: Using the Examples on a UNIX System
This book is currently available online. Since Amazon throws out reviews with web addresses in them, suffice it to say that you just need to type "HeatonResearch" into Google. The 2nd address is the one you want. This book couples accessible instruction with plenty of code that you can lift to make your own neural network applications. I highly recommend it.

I have received my copy of the book and I can't put it down. It has been great help with my AI research at the University. I have the other book from the same author "Programming Spiders, Bots and Aggregators in Java" and I have the same comments for both. Both are easy to read, have precise information and great code. Chapter 7 of this book "OCR with Kohonen Neural Network" makes the book more than worth it. Great stuff. I hope the author does not stop and keep writting books like these. I recommend this book for anyone interested in learning AI and also experienced programmers alike. The author makes though topics seem easy. Highly recommended.

Aug 2007 (see end for most recent updates)

I'm fairly pleased with what I've read so far in this book. I'm in the process of devouring it off my NetLibrary account and in the past five or so hours, I've sailed through the first five chapters. I can't comment on "significant" errors the previous reviewer posted, though I can say that some of the problems are really obvious. For example, in many cases where quotes (") were required, my copy shows double tick marks ('') instead. I'm not sure if this is a problem with NetLibrary or the text itself.

The examples given are all shown from a Windows command prompt (so far) and the author assumes the reader can use Notepad to enter code. I would prefer that the author takes time to move readers toward Eclipse IDE since it's free and can really help reduce the tedium of entering / debugging and running Java code, thus making it easier to learn and more fun to interact with. Granted - it takes a bit of effort to get Eclipse installed, but so did installing Java for the first time.

I've been writing software for the past twenty-five years and am just now starting to pick up Java (wish I had picked it up ten years ago now). The authors methods make me think beyond the printed text and do a good job of helping readers adapt from a procedural style of programming (identifying the steps to solving a problem) to a more object-oriented style (identifying unique classes of "stuff" and writing ways to make those classes interact).

As I said above, I haven't finished the book yet, and while I probably wouldn't have paid $50 for what I've gotten so far, it is clearly worth checking out. It got me interested enough to file a positive review here and I am acutally considering buying the book.

---

May 2008

I purchased this book a few months ago and found that my experience with the first five chapters has continued nicely up through chapter 12. While I haven't had as much time to devote to this book until very recently, I am pleased to report that I'm still finding that the quality level is about 4 / 5. When I peeked at chapter 18 - JDBC, it appears that one must have MS Access in order to use the examples. That frustrates me since I'm a Unix-based user and don't have MS Access. All-in-all, however, I'm glad I bought the book, though I have to admit, I was able to snag it used from Amazon for about $2 plus shipping. It's clearly worth that, but I'm still leaning more toward "Learning Java" (O'Reilly) for the more advanced concepts. I may just switch back over to "Learning Java" now that I've got the core concepts down (chapters 1-11).

By the way - the problem with quoting appears to be a NetLibrary issue, not one with the book.

I bought this book, expecting to get a working knowledge of the JAVA programming language. Already being proficient in C++ and Visual Basic, I wanted to add another programming language to my skill set. For the most part this book did help accomplish my goal, but in the later chapters too many mistakes and laziness by the author ruined my overall view of this book.

The first few chapters in this book are very straighfoward and easy to follow, the author did a very good job in explaining JAVA concepts as well as providing examples putting those concepts to work. Each Chapter also has Labs at the end of the chapter in which you must use the concepts explained throughout the current chapter to complete. Because the chapters were written so well I was able to complete all the labs without even looking at the solutions.

However in the later chapters, I begin to discover that the author got very lazy. This is apparant when during quite a few chapters instead of listing the entire exmple programs in the book, he refers you to the website. Meaning if you are not by a computer or don't have internet access at all, then you will miss out on critical things that he does in the program. Additionaly, even if you are by a computer, just the fact that you have to stop reading just to download examples that should be listed in this book is very distracting. This makes the chapters very hard to follow and frustrating to say the least.

Also while errors were relatively few, there were some critical errors in the book, that if you don't pay close attention you will be VERY confused.

While I expect even the best books of this nature to have errors in the text, I find it unacceptable that the example programs and lab solutions available on the website have errors in them. I have found that even the authors example programs and lab solutions don't work because of errors. There is really no excuse for this at all. I mean were these programs even tested before they were put on the website? Apparantly not. One lab solution is just an exact copy of a lab for a previous chapter and does NOTHING that the Lab is asking for. I was able to figure out how to do it nonetheless, but it would have been nice to see how the author solved the problem. The current chapter I am in right now, I am completely stuck on Lab 17.4 and even the author's "solution" does not work so there is nothing I can do. I sent an email to the author requesting help, but I don't expect a response anytime this century.

I will just continue on so I can at least finish the book, but it seems that I will need to get another JAVA book to get a full understanding of the concepts that this book failed to explain properly due to mistakes.

I can't recommend this book for beginners, even if you have prior programming language experience you will find the later chapters very frustrating because of the problems I have mentioned above.

For $50 I would expect at least the author's solutions and examples to be correct, but they are not. In my opinion this is not $50 well spent.

I've read this book twice, it has a great simple explanation on the Core Java and little more. I suggest it to whom they have a basic to intermediate level in Java, This is the one ! The best point to begin Java with. Also a great future is the online ready to download source files, It realy helps you when your confused to complete the Lab exercises.

At last I think if there was a CD-ROM included with the book involving the SDK and some bouns it was much more better.

I bought gr8 many no. of books on java (almost 20). All those books disturbed me a lot becoz none of them is clearly explaining concepts in a simple way. Then I saw this book in a shop and then i thought it is god sent book for dumb-headed fellows like me. Now, I read this book fully and mastered it. All chapters are excellent. But my favorite chapters are -- input and output(ch-16); database programming(ch-18). These are so well written that it strikes deep into ur head. I shud mention here that the tough chapters were :: Getting started with Java(ch-1) and Understanding inheritance(Ch-6).

I suggest all remaining authors to keep in mind that --
"write in simple way and don't expect the reader to have any knowledge"....becoz i bet all readers have dumb head like me.

Finally the book is superu !!!!!!!!!!!!!!!!!!!.

Love,
A.K.Nag (Abdul Karim Nag)

This is the one and only book that I've ever used for JavaScript. It carefully explains all concepts in a method that is excellent for both experienced programmers as well as beginners. Highly recommended!

I used this book and made awsome homepage in the net. I am 12 and think this book rocks!!!

Poorly written and badly organized. A vociferous NO for beginners and almost useless for anyone with some experience

I concur with the author's assessment of Darkwynd comments. While this book does not attempt to compete with the reference tome written by David Flanagan, it is exceptionally well written with a highly consistent style. Of particular value, it seems that all of the examples are self explanatory. If you get lost in in a particular place, you can still learn something from the next chapter. Also, many technical books suffer from the "casting pearls of wisdom" syndrome, where it is apparent that the author is being influenced by his new fame. This does not appear to be the case with Mr. Manger. Good work !

I've read many books on Java, and they're all the same cr*p. For a small work, this book certainly packs some punch. It touches upon many interesting topics, such as MVC frameworks, Java for networking, and even Java3D! It is worded in a way which enables the reader to easily map what they read into a conceptual thought.

I found this book to be worlds better than most of the books I have looked at purporting to be about "Advanced Java". There is a lot of well-written and thought out information in this book. I find the emphasis on design issues very good, but ultimately, it reads like a collection of repurposed articles.

This is one of the very, very few Java books on the market that will give you any new insight into using the language. In a very small space, it provides an amazing amount of detail - at both the low implementation level and the high architectural level. The chapters on memory and speed optimization alone make it worth the price. This book manages to say a lot with very few words. It runs completely against the grain of all the wordy, useless, and incorrect Java books out there, and every serious Java programmer should own it.

I picked this book up as an impulse buy the last time I went book browsing in the physical world. It was one of the better purchases I made that day; I've been so impressed that I came here to search for more books by the same author.

The content level of Key Java is head and shoulders above most java books. Those few books with comparable content usually fail in some other dimension (clarity, accessibility, brevity, completeness, non-trivial examples). The writing style is a bit dry and academic, but the author is obviously no stranger to serious programming.

Many java books are filled with either relentlessly detailed - but not informative - examination of the topic, or with smoothly written but empty prose. Key Java's chapters are excellently written for "I need it NOW" reading, and each one clearly explains the topic, both in concept and in practice. I won't say you'll be able to read through a chapter and become a master of the topic; some of these topics are seriously complex and take some measure of mulling over and contemplation. But invariably, in the past, when I've tackled a new concept in Java, I've had to read the same topic in five or more different books to get the complete picture. This is not the case with _Key Java_.

This book easily makes it into my top five favorite java books, and is contending with a few others (Bruce Eckel's _Thinking In Java_, etc) for the #1 position. However, Key Java's approach and nuts 'n bolts discussions of advanced-but-not-theoretical java topics make it much more of a complementary book than a competitor, a fine addition to any java bookshelf.

One thing I'm particularly happy about is the form factor of the book - too many java books are tomes that risk breaking your wrist (or your foot if you drop it). There's a prevailing mindset in technical book publishing that the thicker the book, the better (the thicker the spine, the more bookstore shelf real estate you get for your book to advertise itself). Key Java is concise and focused, and the form factor reflects that; I carried it around in my large coat pocket to read as the mood struck me for a couple of weeks.

A vagrant sleeping under a Paris bridge is brutally attacked and thrown into the Seine. He is rescued by two bargemen and Inspector Maigret is brought in to investigate the attempted murder. Who is the vagrant and why was he attacked? Another classic set up for an Inspector Maigret novel.

I recently finished reading "Maigret and the Yellow Dog" which was written in 1931, near the very beginning of the series. It was very interesting to see how Georges Simenon was beginning to create the character of Jules Maigret. It was a good story but one discovers that Inspector Maigret had not yet become fully realized. In contrast, "Maigret and the Bum" was written in 1962 and George Simenon had over thrity years of working on the Inspector Maigret character. In this novel, Simenon is much more in control. The writing is more fluid and Maigret's interior world is more developed.

Simenon wrote 75 Inspector Maigret novels and over 500 million copies have been sold. "Maigret and the Bum" is well written but it is not one of his classic, five star Maigret stories. For those who love the series, this is an ejoyable story. For someone new to Inspector Maigret there are better stories in which to become acquainted with the venerable inspector.

As the previous reviewer indicates, this book and others in the Maigret series are about humanity, smells, sights and intuition even more than physical clues. Maigret doesn't get his man in this story. But, the book is still a sheer pleasure to read. I couldn't put it down until I had finished it.

Although not commonly heard of nowadays (in the English speaking world at least) Georges Simenon was a very prolific writer of the detective genre, most famous for his Maigret series (with well over a hundred books stretching from 1931 all the way to 1972!!). Maigret is basically a French response to detectives like Sherlock Holmes. Not as interested in physical evidence and the rational, he seeks to understand the characters behind the cases and their often tragic lives. Maigret has an aspect of humanism and warmth throughout the books, especially for those less fortunate in French society. His cases present an element of uncertainty that is natural when dealing with people and are thus much more realistic than Sherlock Holmes type stories (although less satisfying "logically").

In this particular book Maigret investigates what others would probably have dismissed as a nothing case. The attempted murder of a vagrant fails as he is fished out of the river. Who would want to kill a homeless mand and who cares anyway? But contrary to this common attitude of his environment, Maigret treats this case as one of primary importance. We see Maigret's warmth and humanity as he uncovers the life of Tubib, his family that he left and the circumstances that led to this seemingly petty case.

The Maigret novels may not be profound literature but they are extremely well written, compassionate and involving detective stories.

As others have written elsewhere (see The Madman of Bergerac), George Simenon was a prolific author of over 100 Maigret novels and many other darker psychological investigations that he called 'romans durs' or 'hard novels' (see Simenon's Dirty Snow (New York Review Books Classics)).

Set in Paris, as nearly all Maigret stories are, 'Maigret and the Bum', published in 1963, comes fairly late in the series. Maigret does not live outside of time. He shows signs of weariness and a desire to reflect back on days of a more vigorous youth as he strolls along the Seine in the book's opening pages. A down-and-out bum has had his skull cracked and been thrown in the river.

Maigret is there to investigate. Rescued by two rivermen, the bum survives and Maigret learns much about the man's past - he is, or was, a doctor. Who would try to kill a down-and-outer? Does the man's distant past hold the answer? Or was it something more recent? Can Maigret get to the bottom of it? Well, yes, but can he get the truth out of the perpetrator.

Simenon unwinds the tale in a way that compels the reader to rush to the finish; the book is only 147 pages and so the task is not so difficult. Having finished one Maigret tale, the reader wants more of Maigret's compressed psychology.