Product Description
Get the information you need for programming applications in the rich, managed-code environment of the Microsoft .NET Micro Framework. You’ll learn how to extend your experience with the .NET Framework and Microsoft Visual C# through real-world examples, expert insights, and code samples—and efficiently build robust applications for the smallest devices.Discover how to:Use an object-oriented approach for programming embedded devicesCreate input and output port objectsDevelop detailed text and graphical displays that support complex user interactionsAdd Windows SideShow functionality into your applicationImplement functionality from existing applications to embedded applicationsBind physical hardware events to Windows Presentation Foundation elementsEstablish embedded-network connections using TCP/IPUse emulation techniques for rapid-prototyping, experimentation, testing, and debuggingOptimize performance of resource-constrained devicesPLUS—Get code samples in Visual C# on the Web ... Read more

Customer Reviews (1)

The book is okay, the subject matter is questionable
The book seems well written, there are examples with commercial development boards in the examples that most any developer can follow.However, the whole Micro Framework is very disappointing as it there is no native code compiler.

If you are interested in this book then chances are that you are a MS developer. While I do have a MCSD certification I have been an embedded software engineer (usually with Linux or VxWorks) for over 10 years and most/all embedded development work is generally done in C/C++ or assembly language for a reason; size and speed. If you don't count something like a Cisco OC-192 router most embedded systems run with the minimum possible hardware. Every nickel that you need to add to compensate for lacking development tools hits the bottom line much more than it does in the PC world.

While I believe that the Windows CE environment would produce adequate runtime performance something like this Micro Framework which always runs as interpreted code is only suitable for a research tinker toy. IMHO I still believe that embedded projects are better done with C/C++/Linuxbut if you want to work with MS tools then focus on Windows CE. There are Windows CE books that cover the same ground and the end result would probably be more marketable than one based on the Micro Framework.
... Read more

Product Description
(Matthew Tagliaferri) wanted a way to introduce the important principals of OOP and .NET, and games seemed like a way to do it that everyone could appreciate and understand. I think he really succeeded.

— Dan Mabbutt, Visual Basic Guide on About.com

• Teaches object-oriented programming quickly and easily
• Game examples make for fun learning
• Shows both the wrong way and the right way through an intuitive and innovative approach to learning
• Written in a peer-to-peer language, easily accessible to young coders

Beginning programmers often motivate themselves by creating a first project in a subject that they are interested in. Many young programmers are interested in game programming. Learn VB .NET Through Game Programming is a self-paced learning tutorial designed to help any developer master the basics of object-oriented programming (OOP) with Microsoft Visual Basic .NET. Unlike other books on OOP, this easy-to-understand book provides readers with peer-level language, while illustrating concepts with definitive and intuitive game programming examples.

Customer Reviews (7)

And interesting read, but not really helpful
I bought this book on a few reviews and the price of the book. What it offers is sadly not able to run. I mean, I downloaded the source from the publishers' site, and that ran fine. However, I compared it to my hand-typed version (following the books' examples) and my program is a mirror image (it seems to me, anyway) of the authors' code. However, it continues to give me an error on something that already has a value, and it reports it as having a 'null' value.

And this is just the first program in the first chapter of the book. I

'm sorry, but if you are going to put code in a book, please make it ALL consistent with every other part, there were a few places where the compiler warned me about some names not being defined because the author got lazy and put an abbriviated name in for another variable or procedure.

I will continue to read this book and try to code it, but I will be wary of other programming books that come from this publisher.

Don't make this your first choice
I've studied from tons of books over the years and this is my least favourite ever. The subject matter is presented in what I feel is mostly a haphazard way. The author uses games to illustrate concepts about vb.net. However, if you wanted to search the book for a particular subject for reference, it would be hard to do. It does sort of build on topics, but not like a book should. The worst problem is that the first program, a cheesy dice rolling program is packed with coding errors. The errors weren't bad, but they were numerous. I did find the coding example interesting, but it did seem more like random mixture of stuff than an organized explanation. I guess my biggest complaint is that I shouldn't have to debug the code examples in the book this much. Overall, I am unhappy with the book and I'll not buy another APress book again. It seems to me that this book suffered from bad editing and rushed production.

Good concept, poor execution.
If you want to learn some game programming, its pretty good. If you want to learn .NET its not so good. I use and enjoy VB.NET and thought this would be a good way to learn game programming. It does a pretty good job of introducing that. It would be better if it had some exercises for you to try on your own, rather than just copying the book programs, thats the only way to learn something is to do it yourself. On the positive side, if you are an experienced programmer, this book does a good job of teaching VB.NET and introducing games.

If you want to learn VB.NET from scratch this book is not for you. It doesn't teach you how to get started with Visual Studio, let alone VB. If you don't already know some programming, you won't be able to follow it. Also, it has many typos and errors that break the code examples. If you are an experienced programmer, they are easy to spot. If not, you can use the downloaded code to fix them, but save yourself the aggravation, get a book that is really geared toward beginners.

Don't be fooled
The reason I'm giving this book a low score is because I don't think it does what it promises.First of all, it's very hard to learn ANY programming language(including Basic) through game programming.If you know VB.NET well, go ahead and give it a try.I, however, am a newbie to game programming, and after reading through the first few chapters and finding the text confusing and having to frequently read lines over and over because it doesn't explain itself in a fasion it should to it's target audience, still don't know how to program a game.

Good but no PacMan!
Andrew said this book was good so i am gonne get it too!! I hope it DOESN'T taste like chicken either... ... Read more

Product Description

Do you need to develop flexible software that can be customized quickly? Do you need to add the power and efficiency of frameworks to your software? The ADAPTIVE Communication Environment (ACE) is an open-source toolkit for building high-performance networked applications and next-generation middleware. ACE's power and flexibility arise from object-oriented frameworks, used to achieve the systematic reuse of networked application software. ACE frameworks handle common network programming tasks and can be customized using C++ language features to produce complete distributed applications.

C++ Network Programming, Volume 2, focuses on ACE frameworks, providing thorough coverage of the concepts, patterns, and usage rules that form their structure. This book is a practical guide to designing object-oriented frameworks and shows developers how to apply frameworks to concurrent networked applications. C++ Networking, Volume 1, introduced ACE and the wrapper facades, which are basic network computing ingredients. Volume 2 explains how frameworks build on wrapper facades to provide higher-level communication services.

Written by two experts in the ACE community, this book contains:

• An overview of ACE frameworks
• Design dimensions for networked services
• Descriptions of the key capabilities of the most important ACE frameworks
• Numerous C++ code examples that demonstrate how to use ACE frameworks

C++ Network Programming, Volume 2, teaches how to use frameworks to write networked applications quickly, reducing development effort and overhead. It will be an invaluable asset to any C++ developer working on networked applications.

Customer Reviews (22)

c++ network programming
If you want to learn C++ network programming architecture , design patterns and want the source code to be portable , this is the book for you . If you cant afford to have your own copy at least suggest your company to buy it . If your in C++ network programmingand dont use ACE , think again , you might be reinventing the wheel.

Good ACE book
ACE becomes popular in the world of system programming these years because of it's portability, low difficulty by providing wrapper encapsulating the complexity of low-level thread usage. However, going on development on ACE without thorough knowledges of system level details is hazardous and therefore further readings are recommended.(e.g. Hart's book)

Quite not what I expected it to be
After reading the Vol. 1, I expected quite a bit from the volume 2. May be I am not there yet to understand what the authors are trying to emphasize here. I found some of the material from vol.1 covered to much deeper extend. But the framework from the reusability point of view is missing. Some of the topics covered here are great indeed, especially chapter 5, 6 and 7. Other than that I found this book to be a quick browse and keep it away.

Well-written book for eligant power code warriors
This is a well written book documenting many of the eligant and powerful frameworks and idioms used in the ACE library.I've been using ACE for over 7 years to implement portable, concurrent, networked, distributed applications and it's great to see a well-written book like this finally being published. I would highly recommend it as a must have reference for all serious ACE programmers who strive to develop powerful, flexible and portable networked applications.It is also an extremely valuable resource for programmers who want to get introduced and up and running on the concepts and application of some very valuable frameworks.

Open-Source Framework Facilitates Network Programming
Writing networked applications using modern operating
systems and languages looks like it should be easy, but it
is emphatically not. The na‹ve designer of networked
applications will encounter a thicket of problems including
lack of portability, distributed performance bottlenecks,
maintaining correctness during shutdown, and managing
recovery from partial failures.

"C++ Network Programming, Volume 2, Systematic Reuse with
ACE and Frameworks" by Douglas Schmidt and Stephen Huston

provides some powerful help in the design and implementation
of networked applications. This help comes in the form of
several frameworks.

A few words about the definition of "framework." The first
step up from writing applications that interface directly
with operating systems is to insert object-oriented wrappers
between the application and lower level services. These
wrappers are classes that encapsulate the low level,
functionally specified, services such as operating systems

and protocol stacks. This first step was taken in the
predecessor volume to the present book, "C++ Network
Programming, Volume 1: Mastering Complexity with ACE and
Patterns", by the same authors, where a collection of
wrappers, called the ACE wrappers, is provided that not only
raises the level of the application interface from
functional to object-oriented, but also provides portability
at the same time.

For example, consider an application that directly uses
sockets. This application would depend on the syntax and
functional details of that operating system's s operating
system's socket implementation. By inserting the ACE
wrappers, the application acquires an object interface to
socket capabilities, and in addition becomes portable across
a large number of compilers, operating systems, and
communication protocols.

But a set of wrapper classes does not solve the networked
application designer's problems, any more than a pile of
bricks is a house.

Frameworks, which are the subject of the present book, are
the next step up in power from wrappers. A framework is an
integrated set of classes into which application designers
plug code that is unique to their applications. The
frameworks described in the present book handle a large part
of the difficulty inherent in network programming, leaving
application designers to deal primary with their
applications' local functionality.

For example, one of the frameworks described in the book is
the Acceptor-Connector Framework. This framework relieves
the user of dealing with the numerous tricky details
inherent in the conceptually simple process of connecting
clients with servers, such as address formats, protocols,
initialization, and message queue locking.

Readers should be aware that the present book is not a
general-purpose text on network programming using C++; this
book is a focused exposition of the ACE frameworks. Readers
will be most comfortable reading this book if they are
already familiar with software design and architecture
patterns, including those described in "Pattern-Oriented
Software Architecture: Patterns for Concurrent and Networked
Objects, Volume 2" by Douglas Schmidt et al, and in the
famous Gang of Four book: "Design Patterns: Elements of
Reusable Object-Oriented Software" by Eric Gamma et al.

The large amount of code that implements the wrappers of
volume 1 and the frameworks of volume 2 is available for
download for free. This code is in wide use today.

Designers of networked applications, when offered a large
pile of code that purports to do a lot of what needs to be
done, must trade off the anticipated saving in design and
implementation time against the anticipated time to
understand what the offered code is intended to do and what
it actually does. This tradeoff can lead a reasonable
designer to ignore existing code in favor of hand-writing an
entire application. In the case of the ACE wrappers and
frameworks, as documented and explained by the two books
mentioned here, combined with the open-source nature of the
implementing code and its widespread employment in real
applications, make the result of this tradeoff pretty clear:
read the books, use the code. ... Read more

Product Description
An introduction to the Java language and programming for beginners or students in an Introductory computer science class. The text also reviews systems topics. The Eclipse integrated development environment is illustrated in detail.Other aspects of Java programming, such as JavaDoc and JUnit testing, are presented.The final Chapter includes an extensive design example based on the card game of Solitaire.

The examples are formatted for the Kindle. The Chapters, Programs and Appendices are hyper-linked to facilitate navigation. Programs are best viewed in rotated, Landscape mode if available.

The reader is expected to compile and execute the 75 examples as a component of the learning experience. A compressed file of the examples can be obtained from the author by purchasers at no charge.

The author has forty-five years of programming experience and has worked at Microsoft in the position of Software Architect. ... Read more

Customer Reviews (1)

Nice try, but maybe wait for improved versions
The book seems to be hastily thrown together solely for the Kindle market.Not well laid out. Clumsy. Examples of how to use Eclipse need improvement.

Unfortunately, this book is also crippled by Kindle in as much as you can't copy and paste examples.Gotta type them all in by hand. Not useful as a programming book -- but that's not the author's fault, that's fault of the current Kindle implementation. ... Read more

Product Description
Your Ultimate "How-To" Guide to Java Programming! Legendary programming author Herb Schildt shares some of his favorite programming techniques in this high-powered Java "cookbook." Organized for quick reference, each recipe shows how to accomplish a practical programming task. A recipe begins with a list of key ingredients (the classes, methods, and interfaces) followed by step-by-step instructions that show how to assemble them into a complete solution. Detailed discussions explain the how and why behind each step, and a full code example puts the recipe into action. Each recipe ends with a list of options and alternatives that suggest ways to adapt the technique to fit a variety of situations. Whether you're a beginner or an experienced pro, you'll find recipes that are sure to satisfy your Java programming appetite! Topics include: String Handling. Regular Expressions. File Handling. Applets. Servlets. The Collections Framework. Multithreading. Formatting Data. Learn how to: Find substrings that match a regular expression. Use regular expressions to tokenize a string. Compress and decompress data files. Create a ZIP file. Format time and date. Use printf( ) to display formatted data. Reverse, rotate, and shuffle a list. Use a Comparator with a collection. Create a simple Swing application. Create a Swing-based applet. Create a simple servlet. Use a cookie with a servlet. Synchronize threads. Monitor a thread's state. Set and obtain a thread's priority. Use ScrollPane to automate scrolling. Access a resource using HttpURLConnection. Schedule a task for future execution. Use reflection to dynamically create an object and call methods. Much, much more. ... Read more

Product Description

Here is the CORBA book that every C++ software engineer has been waiting for. Advanced CORBA® Programming with C++ provides designers and developers with the tools required to understand CORBA technology at the architectural, design, and source code levels. This book offers hands-on explanations for building efficient applications, as well as lucid examples that provide practical advice on avoiding costly mistakes. With this book as a guide, programmers will find the support they need to successfully undertake industrial-strength CORBA development projects.

The content is systematically arranged and presented so the book may be used as both a tutorial and a reference. The rich example programs in this definitive text show CORBA developers how to write clearer code that is more maintainable, portable, and efficient. The authors' detailed coverage of the IDL-to-C++ mapping moves beyond the mechanics of the APIs to discuss topics such as potential pitfalls and efficiency. An in-depth presentation of the new Portable Object Adapter (POA) explains how to take advantage of its numerous features to create scalable and high-performance servers. In addition, detailed discussion of advanced topics, such as garbage collection and multithreading, provides developers with the knowledge they need to write commercial applications.

Other highlights

• In-depth coverage of IDL, including common idioms and design trade-offs
• Complete and detailed explanations of the Life Cycle, Naming, Trading, and Event Services
• Discussion of IIOP and implementation repositories
• Insight into the dynamic aspects of CORBA, such as dynamic typing and the new DynAny interfaces
• Advice on selecting appropriate application architectures and designs
• Detailed, portable, and vendor-independent source code

Final sections examine strategies for betterscalability, including multithreading and optimizing network trafficfor CORBA objects. The authors provide numerous short excerpts of C++code, though it must be said that much of this book is referencematerial rather than a hands-on programming tutorial. --RichardDragan ... Read more

Customer Reviews (30)

Great CORBA Book
This has to be one of the best CORBA books that I have read. It has helped me debug code and fix some really knotty problems. I found the exposition clear and easy to follow, and the index a useful tool. I don't think the authors intended it to be read cover-to-cover.

If I am working on a CORBA project I alway like to have this book to hand.

Excellent introduction to CORBA
For my money, this book is worth every cent and more. The authors are knowledgeable and articulate. If you know of a better book on CORBA, please let me know.....

A good book for advanced users
As the title states this is a book for advanced programmers. Not the kind of book I would recommend to someone looking to pick up a book and the learn from it. Might serve as an excellent reference source.

Advance CORBA with C++
Good book. Worth the money. There is a a lot of material here and it is pretty well organized. Some of the examples assume to much - they would be better if they showed complete code segements. If you needed to get one book on C++ and CORBA, this would be the one.

One book to buy? This'd be it..
Don't wish to wade through book after book? This book would be the one to buy! The concepts are clearly defined and the code examples are fairly easy to follow. (The thermostat example grows too complicated at the end of the book to even comprehend all pieces - authors could use other smaller constructs to show the concepts.)

The authors are well-versed in the topic and it shows in every chapter. There is no hand-waving on topics, as I have seen in other treatments of this subject.

I've been a Corba programmer for the last 3 years and this has been my bible...

Can't wait to see a second edition of this book from the authors! ... Read more

Product Description

Programming .NET Compact Framework 3.5 is a book whose time has come. Windows Mobile outsold the iPhone last year and is poised to grow. If you’re interested in developing for this burgeoning platform, there is no one better able to get you up to speed than industry veterans, master programmers, and teachers Paul Yao and David Durant.

Completely revised and updated for .NET Compact Framework 2.0 and 3.5, Visual Studio 2008, and Windows Mobile SmartPhones, Programming .NET Compact Framework 3.5 teaches you how to write killer applications for handheld wireless devices with small screens, limited memory, and finite battery life. In this book, you will learn

• When to use each of the ten API sets available for Windows Mobile, and especially when to use Win32 and the .NET Compact Framework 2.0 and 3.5
• How to write programs that make the most of a Windows Mobile device’s limited battery life
• How to efficiently invoke Win32 APIs from the .NET Compact Framework
• How to write sizzling, data-driven applications using data binding and .NET controls
• How to manage device data with the object store, file I/O, and the registry
• How to work with databases using ADO.NET and LINQ
• How to synchronize mobile data with remote databases and program ActiveSync
• How to make a mobile device work with the Windows Communication Foundation
• How to create graphical output and print on Windows Mobile devices

If you want to learn Windows Mobile development and have a modicum of experience with the .NET Framework, this is the only book you need.

Customer Reviews (3)

Good book, could have been better
Reading this book after reading books like PHP 3rd Edition by Larry Ullman and Flash HOT (Hands on Training) I came in expecting more.I'm a fan of Win32 myself and the author showed his true colors a lot as well with many comments about it and shortcomings of .NET. I'm all for that and if he is that big of a fan he should make a good Win Mobile Win32 book since not much exist (Direct Show with the Camera would be a good chapter too since .NET CE's Camera Dialog is worthless and rendering pictures as a bitmap takes up a lot of memory).I bought this book to learn the latest 3.5 .Net though and didn't feel I gained much more than what I figured out on my own in the last couple years. There are many differences in .Net CE that need explained and the examples just assumed that since we knew Full .Net that he can just tell us the function name and we know everything about it. There are interesting sidebars and explanations of Win32 which make up for some but not all shortcomings. I've read certain chapters of this off and on over the last few months and ended up turning to the internet. It was missing a lot of common topics that are needed for the Mobile world too. In contrast I read the PHP and Flash books in less than a week cover to cover enjoying every minute and leaving each chapter feeling I've learned more than the internet or the users claiming to know all could ever give. I wish this would have been the same, but after finishing this the book will probably be on Ebay...

quick and enjoyable
good information for the CF 2.0 to 3.5 covering most of the important changes, with some good depth on differences between the Full and Compact versions.
Skipped the database sections, as I don't tend to ever use any db's so I can't tell you if those chapters were good or not.

A fine recommendation for any advanced computer reference library
Programmers working in advanced Microsoft programming will find this has been completely revised and updated for .NET Compact Framework 2.0 and 3.5, Visual Studio 2008, and Windows Mobile SmartPhones, and shows how to create effective applications for all these handheld wireless devices. From blending mobile data with remote databases to integrating data-driven applications, it's a fine recommendation for any advanced computer reference library.
... Read more

Product Description
Are you an SQL programmer that, like many, came to SQL after learning and writing procedural or object-oriented code? Or have switched jobs to where a different brand of SQL is being used, or maybe even been told to learn SQL yourself?

If even one answer is yes, then you need this book. A "Manual of Style" for the SQL programmer, this book is a collection of heuristics and rules, tips, and tricks that will help you improve SQL programming style and proficiency, and for formatting and writing portable, readable, maintainable SQL code. Based on many years of experience consulting in SQL shops, and gathering questions and resolving his students' SQL style issues, Joe Celko can help you become an even better SQL programmer.

+ Help you write Standard SQL without an accent or a dialect that is used in another programming language or a specific flavor of SQL, code that can be maintained and used by other people.
+ Enable you to give your group a coding standard for internal use, to enable programmers to use a consistent style.
+ Give you the mental tools to approach a new problem with SQL as your tool, rather than another programming language - one that someone else might not know! ... Read more

Customer Reviews (8)

3.5 stars: Has good stuff but very undercooked
I'll expand on that when I have time; but for now, real quick:
PROs:

- As usual for Celko's books, you get this feeling of conversing with a knowledgeable and overall very likeable individual with a good sense of humour (he got me laughing on page 2, see his comments on the making of fine furniture).

- Good justifications are given for many rules of thumb that, as of now, you're likely to be adhering to on faith.

- A number of unobvious, sharp, mind-stretching tidbits (an ever-present feature of Celko books).

- Very good bibliography. Celko is not a "narrow specialist": reading pointers he gives are varied and very interesting. Also, links to a lot of net material. Great.

- He writes simply.

-----------------------

CONTRA, the one and only problem: the book appears to be written in a terrible hurry, which is manifested by the following occurrences (not exhaustively):

- Sometimes the author has something to say, but does not say it intelligibly (e.g., section 1.2.7)

- Sometimes he doesn't have anything to say, but gibbers on anyway (e.g., section 3.15)

- Sometimes he belabours the obvious or maybe even spurious: for example, there's too much of this "unlearn OO to understand SQL". One doesn't need to unlearn what one knows to learn something he doesn't; there's no clear-cut distinction: for example, operating on STL collections is very set-like, quite SQL'ish actually: you provide a predicate and it's then applied internally in a set-scoped operation. Matlab is very similar. BLAS is very similar. Fortran is similar. Iow, thinking in sets is an important thing to point to -- once; but after that it's beating a dead horse; move on already. Especially since it isn't really as black-and-white as the author suggests.

(4) The book is very inadequately indexed: index is very small; nothing can be found. What's SQL/PSM? I don't think it's been defined anywhere, but perhaps I missed it; off to index I go... and find nothing there. How nice. I mean, come on -- a five-page index in a technical book?

(5) Dropping French. Is it really necessary? "Sistemé International d'units", OK.

There's more stuff to talk about, both good and bad; but I've no time to write it up right now. So, finally: is it a worthy book?

Well, the book is flawed but not useless by any means. It's not a must read, but if you got a few discretionary bucks and a bit of free time, it's worth reading. I've learned a few interesting things here; ~1/3rd of the reading has been pleasant: in addition to knowing a lot of stuff, DB-related and beyond, Celko's got a real good sense of humour and a gift of gab. Were this book a brochure one-third its current size sold for five bucks, I'd give it five stars. OK, ten bucks.

This is the nth try to post this review
If this review finally goes in, I shall be pleased but surprised, There is something wrong with Amazon's linking. I have spoken to support and they don't know what it is. Anyway...

This is a mixed bag, but mostly very good. Lots of excellent information about different versions of SQL vs. standards, and fascinating excursions into the underpinnings of coding systems, measurements, scales, ratios, etc. We should all be a lot more aware of the work that has been done and codified in many international standards. Apart from anything else, it would save people from re-inventing so many wheels - and making some of them square!

There is an excellent and much-needed stress on the need to use relational thinking when you are working in the SQL environment, with the focus on natural keys and set-oriented processing. He rightly decries the use of "external locator" keys (which most of us call "surrogate" keys, though he defines that term differently) - anyway, basically the "Identity" type. He is perhaps a little too extreme in pretty much absolutely outlawing them, but I agree with the general principle. They are an expedient pushed by people who don't understand relational design. Natural keys are much better. (But I have to agree with another reviewer that the SSN is problematic. Coming to the US from Canada, I couldn't believe the SSN was not a check-digited number, unlike the Canadian SIN, or any credit card number, or banking ABA's. I guess the age of the system was one issue. But the result, anyway, is that duplicate SSNs exist and that they are frequently invented or stolen.)

As a self-described "old fart" he castigates the design errors that may be committed by those (like me!) who grew up in the age of punched cards and magnetic tape. But surely few current database designers have ever seen a punched card, and rarely encounter a good old sequential fixed-length-record file, let alone a mag tape. The model that leads them astray these days is not the sequential file, but the Excel spreadsheet! Time and again I see HORRIBLE designs, violating all the normal forms from 1 to 3 and beyond, based on the columns of an Excel spreadsheet. Another factor is the lack of relational training- how many people have read Codd or Date?and the harm done by the early PC databases that were just a kind of disorganized dumping-ground for data, draining meaning from the term "database."

Some of his mandates are perhaps a little too absolute "Don't use cursors" - well, 99% of the time, very true. You should be thinking sets, not serial access. But there are a few occasions where a cursor can be a useful weapon in your armory and can even execute faster than a set manipulation. Not many, but a few - beyond the outlying cases he describes. Similarly withtriggers - yes, generally DRI is far preferable (if your DBMS supports it). But if you want customized transaction audit capture, triggers are the natural way to go.

A few beefs:

There's a sprinkling of typos, and I did spot one actual error: on p 114, he presents "WHERE a = b + 2" as the alternative to "WHERE a + 2 = b - 4." Oops! Obviously the valid alternative is "WHERE a = b - 6."

The discussion of Camel Case is too limited: there are a lot of variations and his definition is at odds with the widely used Microsoft definition, which would have been worth mentioning. For MS, camel case is like "thisCase" and Celko's camel case, "ThisCase," is called Pascal case.

I found his advice on formatting and display of code sometimes odd. Often when he showed example A and then "see how example B is more readable " - I thought example A was clearer!He refers to studies on visual perception, eye movement, etc., but I am not sure that such studies done in the context of reading normal prose are valid for SQL, or other programming-type text. Comprehension likely occurs in different stages or chunks.

Also, surely Hungarian notationis found in strongly-typed, not weakly-typed, languages. In a weakly-typed language like REXX, a variable can be a string one minute, an integer the next. What prefix can you use? Whereas in VB, for instance, up to version 6, MS recommended prefixes to remind the programmer of the fixed type as defined, so he would not be tempted to write "intAccountID = "New Customer" or suchlike.[...]

Summary? Well, OK, I've listed a few problems, but overall, get this and study it- there's lots of fascinating and rewarding material, from someone who has been working in this field a long time and has gone very deeply into many aspects of it. Many of the SQL examples will really stretch your brain - his other books do that too!

Great SQL Style Reference
This is a great reference for how to write clear, concise, and efficient SQL. If you are looking for good ideas for SQL coding standards, you will find them here.

In my career, I've seen a lot of poorly written, nearly incomprensible SQL, which is always harder to maintain. I just wish more novice SQL developers and DBAs had read this book.

I really enjoyed this book
Wading through badly written SQL is a nightmare on the best of days.Proper--and consistent--attention to capitalization, indentation, and other formatting standards makes SQL much more readable and therefore maintainable.The standards outlined in this book are for the most part very well thought-out, and a great starting point for creating a set of enterprise SQL development standards.If more SQL developers would read this book, I would have many less headaches in my day-to-day work, so I believe this is a valuable purchase.

Excellent book in excellent style
Too many database books are written by developers whose expertise is OOP and not SQL.While I don't agree with Mr. Celko on every point, keep in mind that he was on the SQL Standards Committee for 10 years.Even if you don't agree with him on every point, his level of expertise is undeniable - unless, perhaps, the questioner can provide evidence of greater knowledge and expertise.

This book is to SQL grammar and style as "The Elements of Style" by Strunk and White are to English grammar and style.Mr. Celko explains, in terms that should be easily understood, why SQL should be written in standard SQL while still allowing that there can be exceptions just as verbal communications, in any language, should follow the standard grammar of the language unless there is good reason to slip into a localized dialect.

Where one reviewer rated the book with 1 star because that reviewer disagrees with Mr. Celko on a single point of database design, his antagonistic remarks have nothing to do with the point or the value of this book.

As the editorial review states, this book is not for beginners.If you have been programming SQL for a year or more and you want to fine tune the quality of your work, this work is something you should surely read.

... Read more

Product Description
Develop and fine-tune your programming skills the easyway - by example!For beginning and intermediate users, SASProgramming by Example guides you, with a series of annotatedexamples, through basic tasks to more complex ones. Problems andsolutions are provided to make the most of the programming toolsavailable in base SAS software. Conversational in tone, this book isuseful both as a tutorial for learning programming and as a convenientquick-reference filled with tips and strategies for solving yourprogramming problems. Among the clearly explained examples are modelsthat show you how to build SAS data sets, use SAS functions for datatranslation, program more efficiently, relate information frommultiple sources, and chart and plot data. You will also learn to workwith SAS date values, produce descriptive and summary statistics, andwrite reports.

Supports releases 6.09E and higher of SAS software. ... Read more

Customer Reviews (12)

Perfect for New Users and Reference
I have been writing SAS code off and on for quite some time and this is my favorite go-to reference book.If you are new to SAS, I recommend you start with "The Little SAS Book".This book would be my second purchase, and finally, I would also pick up "SAS Functions by Example".Between these three books and learning a strong fundamental knowledge of SQL, you should be able to do about 95% of what you'll ever need to do in SAS (unless you are doing hard-core stats).

Along with these books the most valuable concepts I have learned in SAS are 'by group' processing, and the first. and last. statements.

I also recommend not attempting to memorize programming statements or syntax; keep examples of code that you may find useful in the future and keep good reference books - like this one - don't try to memorize what you can look up.

Finally, my recommendation is to KISS....Keep It Simple Stupid.You can do many things in SAS (actually almost anything), often in many different ways; some are very straightforward, and some are convoluted.I go with straightforward any day as you never know who will inherit your code for review or maintenance (believe me you'll often curse the code you'll soon inherit from someone else!).My experience is that programmers by nature often want to complicate code by using by using obscure techniques(remember, this is their 'art'!), avoid that trap and do everyone a favor.

Good luck and I hope you enjoy using SAS as much as I have!

Replacement for SAS Programming by Example
This book, while very useful when it was written, is now replaced by a more update book containing approximately twice the material as the old book.I recommend that you look at Learning SAS by Example before you buy this book.Here is a link:
Learning SAS by Example: A Programmer's Guide

Good book for data restructuring algorithms
Hi,

There are times when you may get data sets that were entered in formats that are not compatible with the PROC you are using. In terms of teaching one how to use arrays and loops to restructure data sets, this book is a gold mine. If you analyze data from PROC SQL against databases then you probably won't need all of what is in this book. I have used this book for several consulting engagements and even if you program in SPSS, this s a great book to have in your arsenal.

SAS Programming
I enjoyed the book by Cody and Pass. It is very "user-friendly" and even though it may not be as comprehensive as other comparable books on the subject, I did find it excellent. It clarified many concepts which I was not able to from anywhere else. The authors may consider adding PROC REPORT, a very important and powerful tool.

Ok--rather above average
On the whole, the book is very good in that in general it consists of short self-contained programs: the input, the code, and the output, with discussion. Unfortunately, later in the book the authors got tired of the above and in many cases do not provide the output.

Also, the authors indulge in numerous parenethetical asides that are supoosed to be humorous but are just silly and interruptive.

Still, on balance it is a good (though outrageously overpriced) book. ... Read more

Product Description
With a worldwide community of users and more than a million dedicated programmers, Perl has proven to be the most effective language for the latest trends in computing and business.Every programmer must keep up with the latest tools and techniques. This updated version of Advanced Perl Programming from O'Reilly gives you the essential knowledge of the modern Perl programmer. Whatever your current level of Perl expertise, this book will help you push your skills to the next level and become a more accomplished programmer.O'Reilly's most high-level Perl tutorial to date, Advanced Perl Programming, Second Edition teaches you all the complex techniques for production-ready Perl programs.This completely updated guide clearly explains concepts such as introspection, overriding built-ins, extending Perl's object-oriented model, and testing your code for greater stability.Other topics include:Complex data structuresParsingTemplating toolkitsWorking with natural language dataUnicodeInteraction with C and other languagesIn addition, this guide demystifies once complex topics like object-relational mapping and event-based development-arming you with everything you need to completely upgrade your skills.Praise for the Second Edition:"Sometimes the biggest hurdle to problem solving isn't the subject itself but rather the sheer number of modules Perl provides. Advanced Perl Programming walks you through Perl's TMTOWTDI ("There's More Than One Way To Do It") forest, explaining and comparing the best modules for each task so you can intelligently apply them in a variety of situations." --Rocco Caputo, lead developer of POE"It has been said that sufficiently advanced Perl code is indistinguishable from magic. This book of spells goes a long way to unlocking those secrets. It has the power to transform the most humble programmer into a Perl wizard." --Andy Wardley"The information here isn't theoretical. It presents tools and techniques for solving real problems cleanly and elegantly." --Curtis 'Ovid' Poe" Advanced Perl Programming collects hard-earned knowledge from some of the best programmers in the Perl community, and explains it in a way that even novices can apply immediately." --chromatic, Editor of Perl.com ... Read more

Customer Reviews (15)

A trashing of the first edition ..........
This is a blatant misrepresentation of the excellent first edition of this book: Advanced Perl Programming.It's as if they published a 2nd edition of GoF Design Patterns but it was written by the Three Stooges and contained a rambling account of Moe, Larry, and Curly trying to implement an HTML parser.If fact that would have been a better book than this!Most of this book is filled with lists of parsing modules but with no coherent thread of discussion about how to use these modules to do anything besides trivial parsing of simple documents!The only reason this gets 2 stars is due to the very first chapter which is a decent discussion of "advanced techniques" such as introspection and a very brief discussion of perl internals.However after that you can use the rest of this atrocity to wipe your ass with......

Excellent reference for the serious Perl developer
This book truly lives up to it's title - this is a book for advanced developers who have a solid understanding of not only the Perl language but of higher level computer science concepts.

While there are some intermediate topics and short introductions, this is not a book to learn theory -- this is a book to show you how to take the theoretical concepts you've learned elsewhere and apply them to Perl, and to understand more of the internal workings of the language.

more a guide to CPAN than to the Perl language
In his preface to Advanced Perl Programming, 2nd Edition, Simon Cozens says that the focus in Perl programming has shifted, since the first edition, from techniques to resources.Rather than write really good new code, authors rely on the CPAN to find existing code and use that to solve the unoriginal parts of their problems.To cater to the discerning Perl programmer, then, the book has been completely rewritten.Instead of covering the parts of the Perl programming language that are often unexploited by more novice hackers, APP2 focuses on providing an overview of some of the major solved problems in Perl, and the modules that provide some of the solutions.

Only Chapter 1, "Advanced Techniques," bears much resemblance to the previous edition of APP.It covers subject matter closer to the language than to the modules involved: globs, CORE::, objects, B, and compilation.Each subsequent chapters discusses a common programming problem, shows off a few existing solutions (in the form of code on the CPAN), and sometimes demonstrates how to put those existing solutions to use.Among the topics covered are parsing, templating, serialization, unicode, and testing.POE, Inline, and Acme also get a chapter each.

Simon's writing is, as always, lucid and easy to follow.He provides good example problems, and he builds solutions that tend to do a good job of selling the modules on display.I must admit to feeling compelled to go do more with POE and some of the Lingua:: tools, after finishing their respective chapters.

In the end, though, I felt unfulfilled.While APP1 was not one of O'Reilly's best Perl books, it delivered what it promised: advanced techniques for writing Perl code.What APP2 delivers is a guide to avoiding the need for advanced techniques.It will save you from needing to use the strangest bits of Perl, not show you how.(The back cover quotes Andy Wardley as saying, "This book of spells goes a long way to unlocking those secrets [of advanced Perl code.]"I think, rather, that it just teaches the incantations.)

Perhaps my disappointment is predicated entirely on my incorrect expectations.If this book had been called "Leveraging the CPAN," I'd probably consider it a great success.You may, instead, be interested inIntermediate Perl or Mastering Perl.

A very different beast to the first edition
As other reviewers have noted, there's not a whole lot in common with the first edition of this book, either in feel or content. It's rather questionable whether this merits being called a second edition. Something like 'Problem solving with CPAN' would be a more accurate title (then again, perhaps it's just as well I don't work in the publishing industry).

It does still cover some of the material of the first edition, such as globs, closures, AUTOLOAD, the Perl class model, and some Perl internals, but it's all been compressed into one chapter.

The other chapters discuss various subjects using CPAN modules and gives some insight into how the material from the first chapter was used to solve these problems. A wide variety of issues are discussed, including serialization and object relational mapping, natural language parsing, templating and unicode. Some superficially similar material could be found in Perl Cookbook, but the discussion here is deeper (and more up to date), there's very little overlap.

Exactly how much you get out of the book will probably be dependent on how well you know the innards of CPAN and how interesting you find the topics. I liked the parsing and natural language processing chapters a lot, and the chapter on inlining code from other languages was diverting; conversely, I can't bring myself to find Unicode even remotely stimulating, and the POE (some sort of event-based framework) chapter didn't do much for me. The testing chapter is a solid addition to the material in Intermediate Perl, and I picked up some pointers to modules to check out, but it didn't feel all that advanced.

This is a book that fits in quite nicely with Intermediate Perl and Programming Perl -- it cleans up a few niggling details not well discussed in the former book, without having the intimidating heft of the latter, and also provides a wide ranging overview of several topics and the CPAN solutions for them. As such, it will bring an intermediate programmer up a few notches.

Already advanced Perl programmers may be disappointed, and those hoping for an updated version of the first edition will definitely be out of luck, but if you know what you're getting, and evaluate it on those terms, rather than what the title suggests, I think you'll enjoy it.

Very disappointing
This book was slated to come out for a long time before it actually did, and I naturally assumed that Simon was working on something ambitious and that it was taking him longer than he planned. I bought it sight-unseen, but quickly discovered it was more of a tour of CPAN than an in-depth book deserving of the title Advanced Perl Programming. I know from his blog that Simon was wrapping up his life to go be a missionary in Japan, so now I think the book was late because he was working on *that* project after he had agreed to write this book. Just speculation.

It reads more like an article on Perl.com or in the Perl Journal, and could easily have been several articles spread out over a few months. I have to wonder if he started the book with the idea that "advanced" means "knowing about useful modules on CPAN" or if the idea came to him sometime after it was clear the book was running late.

Regardless, consider looking at it if you see it in the store. It's not without its value, but I can't see paying for a book that mostly says, "Here's someone else's work to check out." An advanced book ought to be getting into -- well -- advanced techniques, useful info that's hard to come by, something that isn't ALREADY AVAILABLE ELSEWHERE. ... Read more

Product Description
This comprehensive tutorial assumes no prior experience with PICBASIC. It opens with an introduction to such basic concepts as variables, statements, operators, and structures. This is followed by discussion of the two most commonly used PICBASIC compilers. The author then discusses programming the most common version of the PIC microcontroller, the 15F84. The remainder of the book examines several real-world examples of programming PICs with PICBASIC. In keeping with the integrated nature of embedded technology, both hardware and software are discussed in these examples; circuit details are given so that readers may replicate the designs for themselves or use them as the starting points for their development efforts.

*Offers a complete introduction to programming the world's most commonly used microcontroller, the Microchip PIC, with the powerful but easy to use PICBASIC language
*Gives numerous design examples and projects to illustrate important concepts
*Accompanying CD contains the source files and executables discussed in the book as well as an electronic version of the book ... Read more

Customer Reviews (9)

Good resourse
Taking a class on mechatronics and the core of this class is programing PICs, good price [compared to campus book store] and an easy to read reference

Pic Programming
An excellent book. This is very informative on the subject of learning the Pic language.A great place to start.

VERY READABLE, NOT PERFECT, BUT NONE OF THESE BOOKS ARE
Chuck Hellebuyck is the most interesting of these PIC authors. He writes for the beginner in an easy-to-read style. He gives the best course on PicBasicPro available. In fact as far as I can see he provides the ONLY course on PiBasicPro. The melabs manual is just a list of explanations of the commands and other books assume we are experienced in Basic. I was not, so after buying the melabs LAB-X1 super bundle I had to use this book. I read it from cover to cover and don't regard a single minute as wasted

The book is dated 2003, but according to his web site it was written in 1998. So the little circuit board he uses for experiments is no longer available. That is a nuisance but it is still well worth having this book around.

left wanting
Yes, this is a good book for the most part. I agree with some other readers that it should have been a supplement to the compiler texts but maybe it came out before the better ones? I forgot BASIC and FORTRAN many years ago and this text does not help me recall the old language very well(maybe my IQ has slipped a lot)! My only complaint here is that it is way overpriced for what it delivers: I would have guessed it to be sold at maybe $35 not $55.Since Microchip have a new motor controller series out, perhaps I'll write about it myself if I discover something clever I can do...
Geoffrey Campbell

Great BASIC Compiler Tutorial for PIC Processors
I am very impressed with Chuck's book. He knows his subject and is good at explaining it to the novice while keeping more experienced programmers interested. I would like to see more information on the low end PIC parts like the 12F675 and the 10f222. These parts are great for projects normally relegated to discrete parts or simple logic gates.

Keep up the good work.

Peter Langer ... Read more

Product Description
The bestselling guide to assembly language-now updated and expanded to include coverage of Linux

This new edition of the bestselling guide to assembly programming now covers DOS and Linux! The Second Edition begins with a highly accessible overview of the internal operations of the Intel-based PC and systematically covers all the steps involved in writing, testing, and debugging assembly programs.

Expert author Jeff Duntemann then presents working example programs for both the DOS and Linux operating systems using the popular free assembler NASM. He also includes valuable information on how to use procedures and macros, plus rare explanations of assembly-level coding for Linux, all of which combine to offer a comprehensive look at the complexities of assembly programming for Intel processors.

Providing you with the foundation to create executable assembly language programs, this book:
* Explains how to use NASM-IDE, a simple program editor and assembly-oriented development environment
* Details the most used elements of the 86-family instruction set
* Teaches about DEBUG, the single most useful tool you have as an assembly language programmer
* Examines the operations that machine instructions force the CPU to perform
* Discusses the process of memory addressing
* Covers coding for Linux

The CD-ROM includes:
* Net-Wide Assembler (NASM) for both DOS and Linux
* NASM-IDE, a command shell and code editor for DOS
* ALINK, a free linker for DOS programming
* All program code examples from the book ... Read more

Customer Reviews (49)

Brilliant Book
This is a book I would highly recommend, and already have recommended, to anyone with an interest in what goes on under the hood of computers.It's written very clearly, starts at the very begining and assumes nothing.Having said that, if you have some knowledge you won't mind reading through the bits you already know because the book is very humerous and enjoyable to read.Definitely the best text book I have read in a long time.

Excellent Beginner Assembly Language Book
I found this book to be very good and although I am using FreeDos 1.0 it is accurate all the way. As Free Dos is a clone of MSDOS you get all the
benefits from the book, like being able to access video memory directly, use the BIOS and DOS interrupts, and learn how to program in Assembly Language. Check out FreeDos org if you are a DOS fan.

I recommend this book for beginning Assembly Language programmers.

A Dissapointment
I started a personal campaign to teach myself assembly language, and searched out books that might help.I bought this book because I own a number of "Step-By-Step" books and the blurb sounded good.Unfortunatly, it turned out to be a dissapointment.

The author prides himself on the fact that he uses an "unusual" method to teach a hard subject, and equally proud that he will not do a "complete" job.And then proceeds to work on chapter after chapter of thin analogy without actually getting to real assembly programming.Now I'm all for "unusual" methods of teaching, but only when they actually work.Reading this book left me more confused than ever.

And of course, to top it off, it's about 10 years old.

I really hate to spend more time on this book, but I wanted to express at least a little bit of my opinion.If I would recommend a book, this other one is worth the money.I even found out that ASU uses it as a textbook, and it's cheaper on amazon.

Assembly Language for Intel-Based Computers (5th Edition)

Additionally, I'd do a google search for winasm, radasm and masm32.All three have wonderful forums to help people learn how to create assembly programs.

THIS BOOK SHOULD BE TITLE "PRE-ASSEMBLY LANGUAGE" !!!
This book is a MUST for anyone taking Assembly Language in a computer science class. Most books on assembly language leave out some VERY important information. Most programming languages are basically the same and require the same logic to use. There is a an important difference between assembly language and other languages like C or Java.

Just like a procedural language like C and an object-oriented languages like C++ or Small Talk requires a difference thought process, so does Assembly Language versus C++ or C#. Jeff does a masterful and humorous job of bridging that gap.

This book shouldn'tbe titled "Assembly Language Step by Step" it should be called "Pre-Assembly Language." The book actually teaches very little Assembly Language, instead, it teaches foundational corner stones such as memory models, CPU function, memory access, binary and hexadecimal numbering systems, and registers. These things are generally glossed over in most text books, yet end up being the most important part. Jeff realized this flaw in other books and wrote this classic. The time to get this book is a semester BEFORE you take a class in Assembly Language, THEN that class in Assembly Language will make more sense. Especially if your going to learn Assembly Language on Intel's 80x86 architecture.

If you're going to learn MIPS or RISC processor assembly language, I'd still recommend Jeff's book. But, I'd also get "SPARC Architecture, Assembly Language Programming, & C" by Richard P. Paul. Richard does a great job like Jeff, but orients his text toward RISC computers.

I HAVE A COUPLE OF WARNINGS: Jeff recommends "Mastering Turbo Assembler" by Tom Swan as the next step. This recommendation is seriously out of date. You can't by Borland Turbo-Assembler new anymore, and the book deals with mostly 16-bit code. Instead, you should get "Assembly Language for Intel-Based Computers" by Kip Irving. This text is up to date with 32-bit code.

Jeff also recommends a book by Michael Abrash. Though Mike's "Black Book" was a great text, it's out of date. I'd recommend that instead you buy "Code Optimization: Effective Memory Usage" by Kris Kaspersky since it's more up to date..

IMPORTANT TO PURCHASERS: Jeff's book "Assembly Language Step by Step" comes with a disk with NASM and programs examples. Unfortunately, they're "READ-ONLY" when you copy them from the disk to the hard drive. You have to change the attribute on every single file to get the program to work. Still NASM and the NASM-IDE are a great addition to the book. If you remove the "READ-ONLY" attribute, you should have no problem.

I hope Jeff will come out with a Third edition to this classic. "Assembly Language Step by Step" should be required as a prerequisite to any Assembly Language class.

First 150 pages rambling, without a hint on the real thing.
At page 151, author said "That's why I began at the real beginning, and took 150 pages to get to where the other guys start."

That is really true, 150 pages wasted!!!

The author is trying to be funny, but actually made it look even worse.
If you are interested in assembly language, there are several online tutorials which are actually much better than this book. ... Read more

Product Description
Get the in-depth reference and pragmatic, real-world insights you need to exploit the enhanced language features and core capabilities in Visual C# 2008. Programming expert Donis Marshall deftly helps you build your proficiency with language features such as classes, structs, and other fundamentals, and helps you advance your expertise with more-advanced topics such as debugging, threading, and memory management. Combining an incisive reference with code samples and best practices, this developer reference focuses on details of the C# language you need to build innovative solutions. ... Read more

Customer Reviews (6)

Not a book for those wanting to progress from beginner to intermediate in C#
I have to echo Michael Beane's comments:
"This would be a rough way to try to learn C#. The stylistic hallmark is short declarative sentences which are accurate but not necessarily helpful to the learner."
I am an experienced programmer wanting to move on to C# and I started with the Excellent SAMs C# 24 hr book -
a delight to use.
Now seeking an intermediate level book I bought this book - and as soonas I started to read it - I regretted my purchase!
The opening "hello world" programme with its unnecessarily complex code (defeatsthe purpose of the simple - introductory code example?) and equally obscure and unhelpful comments is an indication of what is to come.

In no way is this a book for those wishing to progress in visual C# - I can't tell whether it is helpful to already experienced C# programmers.

The level indicator on the back cover is misleading and should be revised upwards before any future print-run is published.

All I would say is notwithstanding it may be technically excellent but the writing style is abysmal - I certainly wont be buying any more books from either this author or series!!!

richard willis

Good book for intermediate level C# folks.
If you want an authoritative tome on C# 3.0 then this is the right book. The book goes very deep into C# e.g. IEnumerable is explained in such a detail very precisely. The book also covers MSIL, VS Debugging, Metadata + Reflection, Memory management and Unsafe code. The section on Memory management is a very detailed one on how the GC actually works. Can't wait for a revised edition of the book for C# 4.0.

This book will make sense to you if you already know C#
This would be a rough way to try to learn C#.The stylistic hallmark is short declarative sentences which are accurate but not necessarily helpful to the learner.For example, consider this gem of a definition of generic methods from chapter 7:"Generic methods have type parameters.These parameters can be used in the method header or body.An open method has type parameters, which are nonspecific.A closed method has type arguments, where specific types are substituted for type parameters. For a generic method, the type parameters are listed after the function name.The type parameter list is enclosed in angle brackets.Each parameter is comma-delimited."Accurate?Sure.Will you know how to write a generic method, or why you would want to?Hardly.This is by no means an isolated example.

The alert beginner will know they are in trouble in the first chapter, when the obligatory "Hello, World" program is presented.This one includes a wrinkle I have not seen before and hope not to see again:it uses delegates, a fairly advanced C# feature.The explanation that follows the program source says, "Delegates define a type of function pointer."That's it.Next!

You really get the sense that the author's purpose is more to demonstrate how much he knows about the subject than to help you understand it.I am not looking for hand holding of the "3 comes after 2, am I going too fast?" variety.But this is ridiculous.The organization of the book -- broad and fairly thorough coverage of C#, with extensive coverage of .NET and Visual Studio as well -- might lead you to believe it is an appropriate first book.It isn't.

Another great resource from Donis Marshall
This is an excellent resource for developers who want to learn C#.It includes code samples and advanced topics that can be applied to help even a basic C# programmer build robust applications.I recommend this as the only reference you will need for Visual C#.

A MUST have C# book
Anyone can learn C# in order to complete a given task. Mastering C#, however, is another matter.

While one can combine several resources (magazine articles, web pages, friends, colleagues, etc) along with considerable time to learn C#, what one often needs is a good book. A GREAT book will guide you through the design of the language and help you understand how to use all its features to accomplish more with less effort.

Donis' book is a great example of a really GREAT book that will save novice C# developers weeks of effort and will help experienced developers solidify their knowledge and skills.

And unlike many existing texts, this book is bang up to date covering some of C# 2008's awesome and much misunderstood features such as generics and anonymous methods.

In short, if you want to REALLY get to grips with C# and master this amazingly powerful language, this book is an essential purchase that will pay for itself many times over. ... Read more

Product Description
Do big math on small machines Write fast and accurate library functions Master analytical and numerical calculus Perform numerical integration to any order Implement z-transform formulas Need to learn the ins and outs of the fundamental math functions in

Master analytical and numerical calculus with this solid course in applied math from the renowned columnist of Embedded Systems Programming magazine. You will learn how to do big math on small machines with fast and accurate library functions, numerical integration to any order and z-transform formulas. Features never-before-published methods and a versatile set of algorithms to use in your own projects. ... Read more

Customer Reviews (12)

Math Toolkit for Real-Time Programming
This book showed some good points. However I felt it is a little bit out of date. The author might know the contents earlier, but he released too late.

Math Toolkit for Realtime Programming
Book is good and useful. Rational fraction, Numerical intergration, dynamic simulation and state vector cover in detail. Appreciate your selling.

Contacted customer service for missing CD-ROM attached with book on 2/17/2006, contact person, Durga.A. Yet to receive reply.

Falls short of expectations
I have yet to find a book that explains "complex" math algorithms well and give clear coding examples that follow.This book is no exception.I suppose after reading some of the other reviews, I had high expectations for this book, but it failed to deliver.

My number one complaint about the book is that there are very little or no comments in the code.There are pages of equations and derivations of the equations followed by code of a function.I didn't understand how the code related to the equations.It would have been a tremendous help to put a one line comment next to each section or line of the code referring to an equation number.Many equations deal with variables like x, y, or a.It doesn't help me much when a variable inside of code is called "x".I have no idea of its use or where it came from.It would have been even better if after each section of the math, the author put the line of code it referred to, and after the algortihm was complete, write the whole function down.

Another minor issue I had with the book was that it was written in the first person and the author tried to make humorous remarks throughout.I understand that he was trying to make it fun and while some people may appreciate it, I found it annoying.

The author does not seem to follow his own advice.The book is clearly not written for any one programming language.Most of the code is written in C, but he has references to pascal, c++, and says that fortran is basically a dead language but refers to fortran throughout the book.He makes it a point to state that he has good coding style and has a whole chapter on constants.He #defines One as 1.0 to avoid wasting run time cycles from converting an int to a double.The compiler may do this, but he adds "to take the chance is bad programming practice".I can see his point, but the problem is he never uses defines in his own coding samples when he writes code like double sum = 0;

The book is divided into 3 sections.The first section deals with constants and errors.There was no math and I am an experienced programmer and did not find much use for this.

The second section of the book is about square roots, sin, arctan, and logs.The algorithms seemed ok, and as expected, are probably faster and less precise than the standard library functions of a compiler.I've seen them before and they were not useful to me because many of them required an initial guess to be input.I work with graphics and such a broad range of numbers that I don't have an initial guess and therefore can't use the methods.

The third section deals with numerical calculus and was the major reason I bought the book.I thought the refresher and review of basic calculus was good.It was a bit stale in my mind, so it was nice to read about it again.However, I want to be able to apply the code in the book to real world programming.The key link and understanding of the code as it relates to the equations just wasn't there.Also, I was hoping there would be more code.There are whole chapters that don't have a single line of code written in it.

Embedded Programmers bible!
Math Toolkit for Real-Time Programming is simply the best focused book on the subject of doing maths on microcontrollers, eg PIC 8051, AVR, PSOC etc with limited resources.

If you write software for an 8 bit micro's then this is the book for you. As it is writen if you want a canned answer then this has less value, but if you want to learn how then this is for you.
It has also been helpful to demistify some math concepts that I never really "got" even after doing an electrical engineering degree!

Lack of example to fully demonstrate the knowledge.
The book review how an algorithm is implemented using C/C++. The book often override many of the default routine, with long boring text broken in pieces here and there. This is a good book if you are already very fluence in math, but could be very boring and useless if you are not. Note that the CD only contain less a 500KB of text file!! ... Read more

Product Description

• After a quick primer on database design basics and the SQL query language (for those programmers who may be building their first database application), this book provides an overview of SQL Server itself, which has been dramatically redesigned with the 2005 release
• Once readers have grasped the fundamentals of database design and SQL concepts, they will then learn how to implement those concepts with Microsoft SQL Server 2005
• Addresses creating and changing tables, managing keys, database normalization, writing scripts, working with stored procedures, programming with XML, and using SQL Server reporting and data transformation services
• The companion Web site provides all of the code found in the book

Customer Reviews (25)

Excellent book
This is a very good book for learning TSQL and introduces the Database objects and their related programming in an excellent way. Would recommend this book to anyone trying to learn TSQL.

It's OK
I found this book too slow and not covering enough information. Then again, I realize the spped of relaying the information via a book is a bit of a personal thing. I also would have loved to have a lot more examples. I prefer a much more hands on method.

Beginning SQL Server 2005 Programming (Programmer to Programmer)
This SQL Server book is very detail oriented. He explains clearly and straight to the point. The exercises are short on each subject. This book is meant for a beginner at SQL but some experience in programming. Great job! I will be purchasing from Amazon in the near future.

Frustration For Beginners
this book is very disappointing, It assumes the reader has knowledge of
installing SQL and migrating required Data base to be used in the book.
If you Can not get the required DATA Base in SQL then GOOD LUCK.

If you are looking to learn on your own Look Else Where.

Yes, I do have Some Programing knowledge.

Good Book For Beginners.
An Excellent Beginners book. I bought it for my friend to start on SQL SERVER 2005. I will definitely recommend it to any beginner. 5 Stars. ... Read more

Product Description

Sams Teach Yourself Beginning Programming in 24 Hours, Second Edition explains the basics of programming in the successful 24-Hours format. The book begins with the absolute basics of programming: Why program? What tools to use? How does a program tell the computer what to do? It teaches readers how to program the computer and then moves on by exploring the some most popular programming languages in use. The author starts by introducing the reader to the Basic language and finishes with basic programming techniques for Java, C++, and others.

Customer Reviews (26)

Required Text Book
Needed it for school, it is what it is, not sure i would buy it if i didnt need it.

I'd like to re-review this and improve the rating.
Well, after dedicating a solid month, I can say I finally have figured it out. This is a great book with only some typos. The beginning is far too basic even for a pre-teen, but if you dont know this info, you shouldnt continue in the book.

I'm happy to say I can write simple programs now, and even made one for next April Fools!

teach yourself programming
That's exactly what is written on the cover. It's a good book for the people who know noting about programming and want to enter in this exiting field. The book is well written and gives you good idea about computer programming and teach you to program in Liberty Basic Which not the best choice from my point of view but it's free.

Words from a "wannabee programmer"
As many other people in this world want to do, I want to program video games in the future. The only problem was that I had no idea how to start or where to turn to for advice. I had tried to learn over the summer of this year on how to create video games, but the books that I had borrowed from my local library said that I needed to have an understanding of C/C++. And when I borrowed a C/C++ book, I didn't really read it. So I decided to give programming up... for a while at least.

About a month ago, that itch to create video games came back to me when I was grounded. So I went back to my library and looked for a programming book that fit my needs. During my search, I stumbled upon "Sams Teach Yourself Beginning Porgramming in 24 Hours". And so I decided to read the introduction if I met the books requirements. When I learned that I did, I borrowed the book and began to read the book.

The book mainly covers a language called Liberty BASIC (which is probably is as easy a programming language as it gets). Right out of the gate, the book lets you program your first BASIC program, a rocket launch countdown. I was suprised how easy it was to program in Liberty Basic. To me, it felt like dumbed down English. When you are finished with the Liberty BASIC training (11 hours worth), you should have a good understanding of Liberty BASIC.

The book also gives you a detailed introduction to Java, but the first two chapters are only text and no examples. Those two chapters do help with the basics of Java and C/C++ (C is Java's "mother" language). When you do get to the programming part of the Java in the book (four chapters of Java in the book), you use Forte for Java (it already gives you the main code for your project). Unfortunately, I found Forte a bit intimidating at first, but when I played around with Forte a bit and got an understanding, I went through the chapters with ease.

The book also gives you a taste of other languages out there (Visual Basic, C/C++, HTML, Pascal, Javascript, and .NET) I say taste because it goes over the fundamentals of each of the languages entered there. You will find C/C++ easier to understand because of your work in Java.

There were some problems with the book that I found. First, there were some coding errors that I found. I found the most errors in Chapter 10, "Having Fun with Liberty BASIC". Most of the code I found put down on BASIC and ran could not run. How can you have fun with the program if you cannot run the code? More like "Getting Frustrated with Liberty BASIC". Also in Chapter 11, there is a sample code that seems to be bugged but isn't. When you get to the code that seems bugged (I forget which sample it was in the chapter) just expand the width of the window to get the result you want.

There were also many dry spells in the sample code for you to write down and practice. The ones that have little or no examples in them are Chapters 2-4, 12 & 13, and 16-24.

In my opinion, I would reccommend this book to anyone who is considering to explore the world of programming (either regular programming or video game programming) or anyone who wants to program but doesn't know where to begin. This book will not mold you into a good programmer, but it will lay down the necessary building blocks to becoming a regular or video game programmer.

I reccomend this book for video game programmers because it will give you a basic understanding of C/C++, the typical language of game programming (this information will be useful for other books that you have your sights on and if you get another C/C++ book, you will understand some of the subjects being talked about (arrays, literals, operators, basic C/C++ procedures, etc.)

Now I just need some help on what to do next...

What you would learn.... IF you took a class
Reads like an extended course description. Very few examples. Code examples are often incomplete so they cant be run. No real 'projects' to test any skills.

Comes with Liberty Basic (shareware) (you can download this seperately and learn more from its own help/tutorials). For the most part, you dont even need a computer to read this book. The code examples are only excerpts so you have to study them from the text in the book anyway.

What gets me more than anything is I found about 5 errors in code and text that are important! Things like mislabeled variables that would confuse anyone trying to learn. Although I guess finding the mistakes is a lesson in itself.

OK, that was the bad part, but I didnt give it a score of 1 because it is easy to read (fast). It does mention a wide range of topics, and it comes with a useable version of Basic (but only limited shareware, also there is a later version online). For a real beginner, this is one way to start off slow. It is disappointing because it could have been much better with only a little more effort. A few larger examples, and a few more actual coding projects instead of just saying'if you want to create a text box in your program, type the following line....',

and then moving on to the next lesson.

This review relates to the 2nd edition. ... Read more

Product Description
Professional SQL Server 2005 Programming shows experienced developers how to master the substantially revamped feature set of the latest release of Microsoft SQL Server. The book begins with a concise overview of the new features of SQL Server that is of interest to experienced developers. This is especially important given the substantial changes to SQL Server with this release. From there, the book quickly moves on to the ?meat? of the title. Beginning-level material has been removed to provide more room for covering new features and more extensive code examples. ... Read more

Customer Reviews (9)

Doesn't live up to Title
For a book that is supposed to be geared to programmers pretty proficient in SQL, it doesn't offer anything new. The examples are very basic and it leaves out some of the new features in 2005, such as Common Table Expressions. This would be better as a beginning SQL programming book.

Great book, series
I own several books from this series.They have been fantastic.This one is no exception.

The definitive SQL Server Programming Guide
This is an excellent follow to his book on Professional SQL Server 2000 Programming. If you're going to be doing a lot of true SQL server programming, there is no better guide out there.

Define 'programming'
When working with databases, there's querying, and everything else. A DBA might set up a database; an advanced user might progam stored procedures and triggers, ponder indexing, effectively use cursors, etc. - but if you just want to know how to write a query to accompish a task, this is *not* the right book to help you learn. Check out 'SQL Server 2005 T-SQL Recipes: A Problem-Solution Approach' by Sack.

Cash Grab! Stay away - get the 2000 book.
The second topic I looked up I ran across this problem...

Page 353:

He says there are four different isolation levels you can set - that was in SQL Server 2000 - this book is about SQL Server 2005. Where is SET TRANSACTION ISOLATION LEVEL SNAPSHOT?

Chapter 12, 'Transactions and Locks' is almost a cut and paste from his 'Transactions and Locks' chapter in SQL Server 2000 Programming!

Encryption - Let's see - 2 pages, and 3/4 of a page is a copy of an image from BOL.

His 2000 book is better. ... Read more

Product Description
Your essential comparative approach to learning C++ and Java

Programming with Objects: A Comparative Presentation of Object-Oriented Programming with C++ and Java, a comparative presentation of object-oriented programming with two of the most popular programming languages of today, teaches vital skills and techniques for the Internet age. Based on highly successful courses taught by the author, this book answers the need for a comprehensive educational program on the subject of object-oriented programming. In a clear and accessible format, the author compares and contrasts both languages, from basic language constructs to how both languages are used in application-level programming, such as graphics programming, network programming, and database programming.

Since both C++ and Java were born out of the same language, C, learning these two languages together has several distinct advantages:

• Because they have much in common at the level of basic language structures, learning C++ and Java together saves time and facilitates the mastery of each
• Learning by contrast and comparison can be more efficient and enjoyable, allowing readers access to the strengths and weaknesses of both languages
• Learning to write a program in one language that corresponds to a given program in the other language enables students to tackle more difficult projects in either language
• Comparing similar concepts in the two languages leads to a deeper understanding of the concepts in both

Roughly the first half of the text is devoted to basic language issues. More advanced topics are detailed in the second half, including programming of graphical user interfaces, multithreading, network programming, and database programming.

Designed as a text for educational programs in advanced programming and as a reference for professionals implementing Web- and Internet-based applications, Programming with Objects: A Comparative Presentation of Object-Oriented Programming with C++ and Java is also recommended for programmers familiar with either language who wish to expand their programming skills. ... Read more

Customer Reviews (7)

Good book to learn C++, JAVA or both
Dr. Kak does a great job of teaching both C++ and JAVA at the same time by comparing the two as he goes through the workings of both.

Some level of C programming knowledge is helpful, however the book is very complete and Dr. Kak is very good about not discussing items which have not been introduced yet, so you can catch up quickly even with limited C knowledge.

Pluses:You can learn two languages for the price/time of one!If you don't know either, you can learn both and not pick up a biased for the first you learn.

Negative:You can get the differences a little confused.Is a friend type for C++ or JAVA?But, at least you will know what they mean and what the equivalent is.

I took a Master's level course that used this book, and before the semester was over my binding was coming apart.Disadvantage to paperback.

A good book for learnig C++.
I'm not new to oop, as I'm a java programmer; I took this book because I had to study some c++ for a job interview.
I liked this book from the beginning, I think the explanations are very clear and the examples go right to the point.
The best thing about the book is that it's very detailed and precise, and it doesn't waste your time with ambiguous discourses (as many IT books do).

Very, very good book on C++/c, JAVA
To put it simply, this book is the best book I have read on OOP. It will save you a LOT of time and annoying searching through the net to only read thousands of confusing and badly written explanations of the different aspects of OOP with C++/Java. It is also very good with the choice of topics. Highly recommended. The text is simple, terse, to the point and fun to read.

A good intermediate-level book
I took a C++/Java course based on this book and liked it very much.

Of course, you will be better off if you get yourself two separate books on C++ (for instance, The C++ Programming Language: Special Edition (3rd Edition) )and Java, but this one is as good as it gets in a single cover.

Besides, the main attraction here is for a person who knows C++ (Java) and wants to switch to Java(C++), because the book provides a consistent side-by-side comparative analysis.

An excellent book!
I have used this book as a text for my class. It helped me understand the concepts of Java and C++ better than the other books that I consulted. ... Read more

Product Description
Get the practical, popular reference written by ASP.NET authority Dino Esposito—now updated for ASP.NET 3.5. An in-depth guide to the core features of Web development with ASP.NET, this book goes beyond the fundamentals. It expertly illustrates the intricacies and uses of ASP.NET 3.5—in a single volume. Part of Microsoft Visual Studio® 2008, ASP.NET 3.5 includes AJAX functionality, the Microsoft Silverlight™ cross-platform development tool, new controls, and new integration features. This pragmatic guide covers these new features, and also includes coverage of Windows® Communication Foundation, LINQ, and other key Microsoft .NET Framework 2.0, 3.0, and 3.5 capabilities. Complete with extensive code samples and code snippets in Microsoft Visual C# 2008, this is the ideal reference for developers who want to learn what’s new in ASP.NET 3.5, or for those building professional-level Web development skills. ... Read more

Customer Reviews (10)

Excellent Book
This was my first Dino's book. Though this book was not the top-rated ASP.NET book, I took a chance. I am glad I did it, I love the book, I love his writing style. I recommended it to a colleague and he liked it too. I must admit that I have become a fan of Dino.

I have couple of other ASP.NET books too. This is the only one that I keep going back to refer.

Comprehensive source of information about ASP.NET
This book is an excellent source of information about ASP.NET 2.0 to 3.5, for developers new to ASP.NET and experienced ASP.NET 2.0 developers. I picked the book to prepare for the 70-562 exam. Even though the book does not contain verbatim texts and exercises to prepare you for the exam, it contains all the required material and teaches you how to use ASP.NET 3.5.

I found very useful the chapters about HTTP handlers and HTTP modules as well as the chapter on the ASP.NET page life cycle. The author uses accessible language to describe complex topics.

The AJAX programming part of this book is rather weak. It covers mostly UpdatePanel. This is good enough to get you going from ASP.NET 2.0 and to get you through the certification, but is not sufficient to write good AJAX applications in ASP.NET 3.5. For a deep dive in AJAX I recommend "Developing Service-Oriented AJAX Applications on the Microsoft Platform" by Daniel Larson.

Dino - Best ASP.NET Advanced Topics Books on the Market
I own Dino's last book (Programming ASP.NET 2.0 Applications Advanced Topics) and this book continues his excellence in writing about advanced topics in ASP.NET.There are many things that he covers that you come across on a day-to-day basis and he explains those topics well.

The topics in this book are not simple.That's why sometimes I think people who have reviewed this says it can be a hard read.Well, again that's because the topics are NOT SIMPLE.When you are diving into creating your own custom controls, Virtual Path Providers, Asynchronous Commands & Callbacks, Http Handlers and the rest, of course the language is going to have to be pretty verbose...there's not really a good way around this unless you're going to write a 1000 page Head First type of book that explains it in more simple terms.

You will search the internet for a while trying to find this kind of information.I don't know how many times I have opened Dino's book to find what I'm looking for especially when we need to create custom providers, controls and to just really understand the processing of asp.net and all the low-level details that can really become overwelming.Dino does a nice job by not overly explaining things (since you could to way into depth on many of these advanced topics) but also does not leave you short in most of his sections.

His examples are more real-world also as well as his explaination and solutions while talking about a topic.I have been at 3 .coms and all of us used his book to figure out how to do a lot of advanced tasks quite literally by him explaining (examples Virtual Path Provider, custom Http Handlers, etc.).

He also takes the time to show you diagrams more than any book I've ready on the processes.I appreciate this time he has put in to the books he writes.He doesn't just write, he diagrams a ton in his book and this is important because the concepts here are very dry and you can get lost very quickly in all the things that happen behind the scenes in ASP.NET at a very low level.

Anyway, not sure why people are complaining about the expectation of perfection when this book provides a better review of advanced topics than you'll find in any other book as well as the internet itself in a lot of cases.

It's pretty much the Bible for our team in terms of advanced topics for ASP.NET.When in doubt open Dino's book.

good overview
like the book says, there's no step by step in there but, it's a good over view of the differences however few there are in 3.5

Good overview of technology with some poor design tips
The book is pretty well tooled to ASP.Net 3.5. But it is as much a marketing pamphlet for Microsoft as it is a resource for ASP.Net programming.The author also seems to have some really terrible understandings of OO design.Early in the book he states that you should always favor base classes over interfaces.Sometimes base classes are favorable to interfaces but the founding principal of all common OO design patterns is that you should code to an interface and not an implementation.Frequent use of classes instead of interfaces can create unwanted dependencies on implementations that do nothing more than facilitate unnecessary coupling.Do a little more research before considering any of the design recommendations that the author suggests. ... Read more

Product Description
Welcome to Programming is a tutorial with which the reader teaches himself or herself to write computer programs on a PC. The book discusses all aspects of computer programming, provides downloadable example programs, and uses the QBasic interpreter (which you can download) to demonstrate these principles.
... Read more