example-of

Well witten and full of examples, but not a modern view of this field. Numerical computation has changed the way to solve this kind of problems, very interesting from an historical perspective.

This book is a fantastic "gateway" text into the vast and wonderful world of difference equations. It does have something of a dusty, "historical" feel to it, as one reviewer has alluded, since the field has changed a bit. Nonetheless, if you are trying to study time-series analysis for the first time, you will save yourself a ton of pain by picking up this magnificent little book.

In this 3rd edition, author David Flanagan has updated the book with coverage of Java 1.4. In keeping with the tradition of the other nutshell books, this book is an instant must-have book. This book is divided into 4 sections. The first section is a short yet very nice Java and OO tutorial. This book is not meant to replace your regular tutorial book, but can certainly act as that for someone who already knows the basics and is trying to bone up on the language API and usage.

The second section of the book covers the core Java API, including I/O, NIO, threads, networking, security and cryptography, serialization, and reflection. This section of the book is really solid and includes great working and commented examples of most of the core set of Java API. I really liked the network section as it includes code that will fulfill most of your needs in terms of network related development.

The third section of the book deals with graphics and user-interface including Swing, Java 2D graphics, preferences, printing, drag-and-drop, JavaBeans, applets, and sound. Not being much of a UI guy, I glossed over most of this section but it seemed complete and comprehensive. I know where I am going to turn if I ever need to work with Swing or applets.

The last section of the book includes coverage of the server-side Java or J2EE development, including JDBC, JAXP (XML parsing and transformation), Servlets 2.4, JSP 2.0, and RMI. Being a back-end or server side developer, I spent a lot of time consuming this section and I was very impressed with the quality of the coverage, explanation and examples included in this section. The section starts off with a nice introduction to JDBC, database metadata and includes some nice examples configurable example that are ready for use with little or no modifications. I think that's important to new developers that are getting familiar with an API. In reading the code, it was nice to see the author using the execute() method instead of executeUpdate() or executeQuery() method along with a simple explanation of why he is doing that. Sounds simple, but I can't tell you the number of times junior developers have come to me and asked me about this exact topic.

After JDBC, the book jumps into XML with a nice intro to SAX, DOM, and XSLT. Not a lot of meat here, but XML is always a moving target in terms of the API. I wish this section had a little more to it as it is missing the whole idea of Java-XML data binding which is a useful topic. After XML, the book moves over to Servlets and JSP. Nice intro to servlets and JSP, but leaves you wanting more. I think the whole server-side Java just needs to be another book and I think David should just come up with a Java Enterprise Examples in a nutshell. O'Reilly already has some great books in this category including the Java Servlet and JSP cookbook.

Having said all that, I still really like this book for how it deals with the core API. This book contains 193 complete, documented examples which makes it a must for any junior developer that knows or is learning Java and wants to know how to apply the API. The examples from this book are available for download from the author's website located at davidflanagan dot com.

Target Audience
Java developers who are looking for working examples of code that illustrate specific concepts.

Contents
This book is a companion volume to the Java/Java Enterprise/Java Foundation Classes In A Nutshell books. It provides code examples for many of the classes used in those books.

The book contains the following chapters:

Part 1 - Learning Java - Java Basics; Objects, Classes, and Interfaces

Part 2 - Core Java APIs - Input/Output; Threads; Networking; New I/O; Security And Crytography; Internationalization; Reflection; Object Serialization

Part 3 - Desktop Java APIs - Graphical User Interfaces; Graphics; Printing; Data Transfer; JavaBeans; Applets; Sound

Part 4 - Enterprise Java APIs - Database Access With SQL; XML; Servlets and JavaServer Pages; Remote Method Invocation; Example Index

Review
Often when you are learning Java or exploring a new aspect of the language, it's difficult to make the bridge from the raw documentation to working code. The O'Reilly "Examples In A Nutshell" series is designed to make that transition from theoretical to practical, and David Flanagan's Java Examples In A Nutshell is no exception. It should be an essential part of your personal library if you are a Java professional.

Rather than spend time teaching the reader a particular class, the book assumes that you have one of the other Java Nutshell books for all the details of the class. In this volume, Flanagan jumps right into complete, well-documented examples of code that use those classes, thereby giving you a feel for how they work. Because he documents his code better than most of us do, there isn't that waste of time trying to figure out what the coder intended. The examples are easy to follow, and they are definitely helpful when you are working through the details of an unfamiliar class or concept. I often find myself looking through the chapters when I'm coding just to get a glance at how someone else would code a solution. It's almost like having a partner to bounce ideas off of.

In this latest edition, the author covers some of the new features in Java 1.4 like the New I/O and Sound APIs. Personally, I probably wouldn't do much with the sound code, but the New I/O section will be useful. He also covers the regular expression features which are new in the New I/O API. While I would also want documentation on regular expressions since I'm not a Perl expert, these examples will help me when I get to the point I need to use them.

Conclusion
Quite simply, this should be a "must buy" for your Java library. This book bridges the gap between reference material and your actual coding better than any other book of its kind.

This dictionary is strong where Dwelly's is weak and weak where Dwelly's is strong. It is, as far as I know, the only Gaelic-English dictionary that uses the new orthography for Gaelic. However, it is fairly slim and thus not comprehensive. However, I should think that this has everything that a beginning or intermediate learner of Gaelic would ever need. Combined with Thomson's English-Gaelic dictionary the learner will be quite well supplied with up-to-date Gaelic references.

Since this is only Gaelic to English, its not for a complete newbie. You need a little working knowledge of the language, it is also not a complete version, rather a thin, handy size. I found many words in it not in others such and MacLennans.

I think is super companion piece.

If you've ever been an angst-ridden, depressed teenager with out-of-touch parents, this book will resonate with you. Even if you've only experienced tinges of these things, or had friends who did, Porcellino's book will say something special. It is charmingly illustrated, and nicely written. A well-crafted book. His King-Cat Comics and Stories are worth a look too, if you can find them. Listening to his old Denver band Felt Pilotes while reading this book provides the compleat Porcellino experience.

John Porcellino's Perfect Example is exactly what comics need. It's got a sense of emotion and angst and beauty and fun that I frankly wish more people would aspire to instead of trying to be clever. Perfect Example isn't clever -- it's funny, it's genuine, it's beautiful, and it's moving. Check it out if you've ever been (1) sad and didn't know why (2) into skateboarding (3) on an impromptu a road trip (4) into Husker Du (5) a teenager.

Plus, I can't speak highly enough of Highwater Books' presentation of the material, originally printed in black and white in John P.'s excellent King-Cat Comics and Stories zine. It's gorgeously put-together with fine paper and multi-colored inks (as with Highwater's also excellent presentation of Brian Ralph's Cave-In). Highwater makes gorgeous books and this is certainly one of their best.

One of my favorite comics, I can't speak highly enough of it.

Authors have written a beautiful book that does indeed face many of the elementary and advanced subjects of statistics using Excel. Following an introduction that will prove useful to readers with no knowledge need of either Excel, or Statistics. Authors include detailed of advanced subjects including: 1.Huge data collection that allowing for instructors to teach statistics. 2. Statistical inference. 3.Regression analysis. 4.Analysis of variance. In short, Student and teacher interested in computing statistics using Excel should find the time to review this text.

This book is put together in text book format and contains instructions on using Excel to generate histograms; obtain confidence intervals; INTERPRET statistics; perform f, t, z, and ANOVA calculations; etc. The sections on ANOVA explain what it is, and why one would use single versus double. I bought this book as a reference/tutorial for our Technical department and found it to be extremely useful.

Highly recommended for the 2 and 3Ls struggling through SecReg also useful (but not to the same extent) for SecLit and SecMarketReg and for the Corporation/BusAssoc Course that dives heavily into 10b-5.

Only quibbles (that prevent it from getting 5 stars).
Rule 144/144A coverage is weak. Should expand the proxy (Exchange Act Section 14) coverage as schools/professors have slightly different lesson plans and some SecReg course may cover it in more detail. Also foreign private issuer Rule 3b-4/12g information was absent.

I bought this book while taking a Securities Regulation course in law school. I would encourage anyone studying the subject to purchase it. The SEC Regs are complicated and hard to understand. This book takes you through the whole subject in a very concise and thorough way. The examples and explanations are extremely helpful in preparation for a law school exam and helped me get a high grade. The only downer about the book is it is two years old and therefore lacks discussion of Reg FD and other important Regs from the past two years.

This book gives very good overall overview of UPnP for somebody that is new to this matter. It is done from the Intel tools perspective, which is not surprising given writers affiliation. But, all in all, they try to give an objective picture.
I would like to see more concrete comparisons with Jini though. None of the other, non-UPnP compatible, service discovery methods explicitly mentioned in the book but advantages and shortcomings of UPnP (and there are quite a few) could be understood only in conjunction with other developments. There are currently some domains, for example, where UPnP will simply not work. For somebody, that is interested what other similar technologies are available I can recommend the book "Jini technology: An Overview" by S. Ilango Kumaran because this book gives a broader view of the state of technolgy today (not just Jini).

I found this book to be a great introduction to the UPnP technology. The authors start with some reasonable assumptions about the skills of the reader, then methodically build a foundation for understanding and implementing the UPnP technology. Highly recommended.

The 'Unix Shells By Example' is a well-known book in the field of shellscripting. It has about 640 pages with a CD-ROM included. The book is well edited, with good white-spacing and clarity in layout. Having taught the unix shells for over 15 years, the author really knows her stuff, and the text is factual and to the point.The index seems complete and one doesn't have a difficulty in finding the right info one is looking for. These properties should be normal for books, but computer books seem often an exception.

The chapters deal about the central unix-commands for scripting (Grep, AWK,SED) and the big three shells (korn, bourne and C-shell). The author explains the subject in great detail by showing examplescripts. First you're given the data or text to be edited, then the script or commandlines and finally a lenghty line-by-line explanation of the scriptsyntax. The subjects of the scripts range from explaining the basic unix-commands to complex intertwining regular expressions, functions, obscure nawk options etc. The author also touches the subject of shell-history, making comparisons of the three shells, giving 'lab-exercises' and some unix background about commandtypes,login and inheritance. The apparent subject that is missing in this book is the Bash shell, the preferred shell in the Linux community. However, a seperate book on this subject is available (Linux Shells By Example). As with all books that have an extensive coverage of the subject, this book too can be overwhelming for the absolute beginners in shellscripting. It takes some time before one writes sytax like:

nawk -F: 'BEGIN{printf("What vendor to check?");\

getline ven <"/dev/tty"};$1 ~ ven\

{print"Found" ven "on record no" NR}' vendor

Instead of searching the pages for the basics, beginners should consider buying an entrylevel book. Conclusion: For the intermediate scripter who visits shellsites like shelldorado and lurks newsgroups in search of advanced programming constructs to steal this book is a great find. You won't be left with a feeling that you'll outgrow this book. For newcomers in scripting this should however not be the first book to buy, they're better of with titles like "learning shellscripting in 24 hours". But once through these 24 hours, this book can only be warmly recommended.

This books is great--the three most popular shells, and the regular expression manipulation tools as well, all in one place.

I've recently changed from using csh to using ksh, and finding examples of how the syntax is handled in the new shell has been invaluable. My boss now thinks I'm a shell programming wizard!

The best thing about this book is that it is compiled from the author's coursework. These examples have all been tried in classes through the UC Extension, and they're designed to teach students at various levels of expertise. I've been a unix system administrator for several years now and I use this book on a regular basis. I recommended this book to a novice sys admin who had never written a script before, and he was able to get started quickly using this as a reference. Some books just seem to make your job easier. This is definitely one for me.

I cannot imagine anyone tryng to learn UNIX shell scripting without this book. I've used this book countless times to teach shell scripting to programmers and neophytes alike. Plenty of books provide shell script examples, but none give such thorough, line-by-line explanations of what the examples are doing.

There is no question that the book is a valuable resource. It draws on classic references such as Bevington's 'Data Reduction and Error Analysis...' or other good books such as Acton's 'Numerical Methods that Work.' Very nice when you need a quick understanding on how to approach/attack a problem.

I find myself disappointed with the software on the disk you purchase separately. What I was expecting/hoping was ASCII files with the source code so that I wouldn't have to type it in myself from the book; however, it is in Windows DLL format. This is not very useful if you'd like to use the code on different platforms. One puzzling thing is that the Windows disk is about $35, while they offer an on-line download Unix version for $50 ($150 for the multi-user license). I don't understand why there would be differences between the two unless the NR software is not ANSI-C compliant. If this is the case, then I'd consider the software useless.

Recommendation: Buy the book as a reference. Use different software.

I give the book 4 stars to maintain the current level. I own a Fortran copy of NR, but like the other authors, I like NR for the explanations of algorithms, but not for the code.

There is a VERY good alternative to Numerical Recipes in C, namely GNU Scientific Library. You can find the source code and manual from:

http://sources.redhat.com/gsl/

or

http://www.gnu.org/software/gsl

As typical GNU software, GSL is licensed under GNU General Public License, so it is ABSOLUTELY free ! You can download it, modify it, linked it with your own code, without feeling guilty of copyright violation (Not in the case of NR, NR comes with a copyright license to prohibit modification and linking).

GSL is written in C from scratch by its author. The design is modern, much better than NR in C, and also allowed linking with C++ or modern scripting language like Python. Some of the leading authors have background in theoretical physics and astrophysics, just like NR authors.

Check it out. You lose nothing to check GSL first, you may ended up saving some $$$.

I had to endure reading this book for 2 long semesters, and I've come to know some parts of it pretty well. I'll try to be short and say that the book is an excellent reference for the practicioner (and for the poor student:) - however, the ill-placed "jokes" have terribly annoyed me and my fellow class mates. Entire pagagraphs in almost every section dedicated to some second-tier humor were not so helpful in solving numerical problems.

The license for the code is just bad and I found it rather pointless, given the cost of the book (for me it's expensive; and I know it's downloadable). The authors should maybe reconsider this at a later stage...

PS: The GNU Scientific Library implements most, if not all, of the NR routines. It might be worth checking out, since it's also in plain C.

I picked this book up a couple months ago and can't imagine how I got along without it before. The first section includes simple examples of common uses of the java packages. I find this extremely useful. There are realms in Java where the intricacies often slip my mind, particularly in java.io, and the small examples of these packages shown in section 1 serve as a perfect reminder of how exactly to accomplish my task.

Section 2 is the meat of the book and includes a reference to the classes and their members. This is similar to the online API, but lacking the descriptions for the methods / classes. This is strictly a quick reference of the methods, their arguments, return types and modifiers, and the variables belonging to a class. For a description of every method, use the online API. Personally though, I find this reference quicker to use than the online API when searching for a particular class. It probably comes down to personal preference, though.

Sections 3 and 4 I honestly haven't found a need for. The first two sections alone are worth the (relatively) [inexpensive] price of the book.

For reference, my qualifications include Sun Java Programmer Certification 1.4 (Passed with an 86%), Graduated Magna Cum Laude from UMass Dartmouth with a Computer Science degree.

1) See the title .. All info you ever need about API structure, classes, details .. in your hand and not in 100 IE bookmarks.

2) I have to deal with class files on the bytecodes level and didn't expect this book to be much useful for me - suprise !!! It has an excellent table "Class File Format" ( I had to built one such for myself long time ago ) and some others regarding bytecodes issues - very nice and comfortable. It's only ~5 hours I own this book but already pulled it 5 times from the shelf. So, it's not a question of "buy or not" - buy !

3) We all enjoyed reading this in preface : "There was a time, not long ago, when I intimately knew all of the Java class libraries .. ( of course, it helped me that I was on of the original developers :-) But aside from the occasional inability to remember which argument of Vector.insertElementAt() is the index, I rarely had to refer to any reference documentation .."

Thank you, Patrick !

This book condenses the vastness of Java 1.4 GUI classes into a hefty 1000+ pages. It's divided into 4 sections. Part 1 contains examples of usage of the different classes, with a focus on how to accomplish something specific, from creating a JLabel component to playing MIDI audio. Part 2 contains detailed information about the classes themselves, and contains references to code examples from Part 1 to see how the class is used in code. This is essentially the documentation that SUN's website provides, but in my view, it's more condensed and the references to code are a bonus.

Part 3 contains topics on the transition of Java from 1.0 to its current incarnation, detailing deprecated classes, new classes, etc. Part 4 is the cross-reference section, where if you know the name of the method, but not the class that contains that method, you can simply look it up. There's much more than just methods, though; subclasses, descendants, fields, and "extended by"'s are also some of the details here.

This book is quite an impressive achievement, and I hope to get my hands on Volume 1 sometime soon.