Software Development Books

What makes a project successful or doomed - loved or hated? Those are the questions "Adrenaline Junkies and Template Zombies: Understanding Patterns of Project Behavior" hopes to answer, looking critically at the archetypes of people and engineers that people constantly fall into, whether they know they are or not. Not afraid to take a humorous look at it all, it's a comprehensive guide that offers an example of what is a good and bad behavior coming from team members in management of a project. "Adrenaline Junkies and Template Zombies: Understanding Patterns of Project Behavior" is highly recommended to anyone in charge of a group project and for community library business collections.

How can you keep from getting sick by infection? You need to build up immunity. There are two ways to do this. One is by surviving an earlier bout with the disease, and the other is by getting vaccinated.

Reading this book will "vaccinate" you against the negative project behaviors it describes, so that they can be recognized and dealt with before they cause project failures. Learning from the failures of others is a lot faster and cheaper than learning "the hard way" (by taking part in failed projects yourself). Get everyone on your team a copy, so that the cries of alarm cannot fail to be heard.

With "Adrenaline Junkies and Template Zombies: Understanding Patterns of Project Behavior," The Atlantic Systems Guild team of DeMarco, Lister et al has done it again - a book about projects, project work and software development that is both useful and readable. I highly recommend this book.

Many books that relate to technical or managerial subjects are difficult to read - a lot of stuff you don't care about, and the occasional nugget. "Adrenaline Junkies" is a book of nuggets. Each chapter is a nugget or "pattern," including a phrase, a picture, a sentence and a couple of pages of descriptive text. One of my favorites, "News Improvement," refers to the tendency of bad news to be "improved" as it makes its way up the organizational chain. Another, "The Overtime Predictor," talks about how fear can drive people to overtime.

Not everyone will care about every pattern, but the book is organized in such a way that the reader has control over what to miss. Some patterns validated my own experiences. Some provided new insights. A couple I didn't get. My recommendation: read through the book, paying special attention to the patterns you care about. Skip some of the descriptive text if the pattern doesn't resonate with you, but first make sure you understand it. (Hint: the last paragraph of each pattern usually has a brief summary.) Then, when you're done, take a few minutes and go through all the patterns again to refresh your mind. That way, when you encounter these situations in real life, you'll remember the pattern. Even if that's all you can remember, you'll be able to refer back to the book for advice.

The title and cover caught my eye (today!) in the bookstore and after flipping through, I couldn't wait to get home and blow through it.

It's clear why this is getting a 5-star average here @ Amazon. Written by the same folks who authored Peopleware (classic skilled-person management book), it contains ~80 patterns of project behaviour alternating between helpful and harmful.

Almost immediately I had several, "Ohhh yeah! That's what's going on!" moments. The authors do a terrific job of identifying patterns and the reasoning behind them. Being relatively new to a management gig, this sort of resource is invaluable. You might not be able to fix some of the issues, but you'll certainly be able to notice them more quickly - which is really the first step.

Each pattern is about 2-3 pages long, clearly identified in the table of contents and with pattern headings that stand out. This presentation allows me to quickly refer back to find out the suggested cure.

Most patterns are presented with prescriptive, corrective behaviour. Granted it's not a detailed dissertation on how to fix organizational issues, but enough to get an idea of the scope of the fix; work through it, or time to find another employer?

I'm already in the process of recommending this to my peers. It's such a brief, valuable read that anybody with skin in the game (from developers to CEOs) should give it a look.

I have been a fan of Tom DeMarco and Tim Lister for some time, their insights into the right way to manage information technology (IT) projects could be entitled, "The Way It Should Be Done." In this book, they are joined by their colleagues in the Atlantic Systems Guild to describe 86 project patterns, some of which you would enjoy being used to describe how you do things and others that you would avoid if you could. The descriptions are generally short, less than three pages and include a figure for emphasis.

Unless you have been blessed to a level that no one to my knowledge has ever been or you have never worked, then there will be patterns in this book that will cause your head to nod in agreement. Using colorful language on occasion and consistent blunt talk, the authors tell it straight, providing advice that pulls the façade off of some of the common notions of what makes a project work. Some of the titles of the patterns are:

Project slut
Rattle Yer Dags
One Throat to Choke
The Too Quiet Office
Everyone Wears Clothes for a Reason
What Smell?
Sanctity of the Half-Baked Idea
Seelenverwandtschaft
The authors are big advocates of creatively goofing off, arguing forcefully that the most productive teams are those that do things together that are anything but work related. Eating together, attending a movie, playing together in a band and a regular poker night are suggested ways to build cohesion and a sense of respect between the members of the development team. They also insist that some of these things should be done on company time.

The group is also strongly opposed to strict rigidity of any form, believing that a bit of chaos, animated discussion with disagreement and respectful truth telling are all signs of an efficient and productive team. In the "Miss Manners" pattern, they point out that extreme civility is misdirected and results in deep mediocrity. Everyone is subject to generating the occasional error or bad idea and if it is accepted rather than rejected for fear of hurting feelings, everyone suffers.

This past year, I authored a new major and minor program in Management Information Systems (MIS) for the college where I teach. Two of the upper level classes in the program involve the study of the proper ways to manage IT projects. This book will be used as a supplementary text when I teach those courses.

Published in the online Journal of Object Technology reprinted with permission

I picked up this book to help me develop an application knowing absolutely nothing about GTK+ programming and it was beyond helpful. Excellently written, not to mention many code examples showing how to use the GTK+ library properly and efficiently. This book gives you the tools and the understanding for building your own applications and not just re-creating the examples given to you.
I highly recommend this book to anyone programing in C and want to learn how to use the GTK+ library along with the GLib and Pango libraries. This is one book I'm not going to let go of.

FINALLY... a great book on GTK+.
Easy to follow and understand, great example, great explanations...

Usually I dislike the writing styles in Apress publications, but this is a definite winner. For the first time I can say I actually understand and can effectively use GTK+.

A textview widget in python had me stumped, but no longer. Anyone wishing to tackle GTK+ programming should buy this well organized and excellent book. It is well worth it.

I got this book a few weeks ago and found it to be well written and to the point.

I wanted to like this book, but unfortunately I cannot in good conscience give it 5 stars as the other reviewers have.

I will say the book is well organized and is definitely useful as a starting point for studying GTK+ and the author clearly has a great deal of knowledge about the subject. But what should have been the main strength of the book that differentiates it from the mostly inadequate online tutorials is the author conveying to the reader straightforward explanations of important concepts and insider tips and tricks that can only come from extensive experience. He tries to do this, but I found many of his explanations ambiguous and confusing. Important terminology was left undefined or poorly defined which contributed to the confusion.

The author dutifully plods through a presentation of most of the main widgets, providing essentially the same trivial example code each time with minor variations- basically just showing how to put the widget onscreen. But there was a frustrating lack of material devoted to how to use signals and events to perform any useful tasks. The vast majority of the functionality of any GUI application lies in its event handlers and callback functions. After reading this book, you will be able to prototype the GUI for your application, but you may be at a loss to make it actually do something.

By Ch.3 and 4, the same example code has been replicated so many times that there is an increasing frequency of copy-paste errors that gradually becomes very annoying. Also, there are many typos in the text. The lack of editorial oversight and technical review on the part of the publisher combined with the author's lack of attention to detail and failures in exposition has created a book that I can only marginally recommend- mostly because all of the other books that have been published on GTK+ are either out of date or out of print, so this book seems to be the winner by default.

I admit that at first I was thinking this book would focus more on the game engine part of the toolset development in its title. I knew it wasn't REALLY about developing a game engine but even so, make sure you understand what you're getting.

That said, I really liked this book. I'm halfway through it already (it's a very quick read given how discrete each chapter is and the clear and easy to read print and examples).

I've read a number of game development books and you rarely get everything done right. This book gets close. The author describes the particular problem the chapter seeks to solve (e.g. encryption, batch processing, etc.) and goes through the steps of solving it.

The book is similar to those programming gems types of books that aren't organized in some linear fashion but are discrete chapters on specific topics that can be picked and chosen as you see fit.

The author does a very good job of putting the examples together and many of the chapters have been useful to me (I plan on implementing a number of the tools/frameworks he mentions).

If you're working on a game engine, I really suggest trying this book out. This assumes you're not already an expert game programmer who already built a lot of these sorts of tools before.

If you're looking for something that will help you build a full-fledged game engine, look for another book...then come back to this and get it to help you flesh out your toolset.

I just received my copy of Game Engine Toolset Development and I have been unable to put the book down. The author gives a good introduction to .NET 2.0 and relates it to toolset development for games. The chapters are easy to read and follow and he gives good advice on how to build good tools. He could have looked at other toolsets to make the book more complete, but I see this book as a way to introduce students to game programming who have a basic programming background (Java, C++, C, Alice 2.0, etc.).

I bought this book thinking it would help me write a new tool for, say, building 3d models, or some other general tool. When it arrived I got excited just by the shear size of it, it's huge!

However, I started flipping through it browsing each and every chapter (didn't read them all in detail of course, but quite a few) and it doesn't teach you how to make a NEW tool for your game, it teaches you how to make an EXISTING tool better. While that knowledge is extremely valuable (and the reason I gave it 4 stars instead of 3), it's not what the description of the book stated: "Readers are not required to have any experience developing game engine tools." If you have no experience developing a tool, you're going to have a little trouble getting started. If you know enough math and have good enough coding skills to get a game engine going, you'll be able to write a tool for your game, but you don't need this book to do it.

Now, with that said, this book IS quite good and worth your money so long as you don't expect to read this book and then write a tool, you're going to need more info. Get the book anyway and use it as a guide, it's usefull in that aspect.

This book is so good at making a tool better, most of it's "gems" can and should be applied to ANY application, game tool or not. Also, it covers some good highlevel (or lowlevel, depending on how you view it) .Net functionality such as interfacing with COM and code documentation, as well as few other excellent techniques. These "gems" are quite valuable on their own.

So, in conclusion, if you know nothing about writing a tool, or you don't know C#, hold off on buying this book (make sure to put it in your wish list however). If you have a tool but find it's difficult to work with, or you want to broaden it's appeal, or just simply make it better, get this book, you won't regret it.

This is an excellent book, which covers a lot of important aspects of game/engine tool development, but it is more like a recipe book, as each chapter subject is almost stands on its own - just like game programming gems series. My favorite is how to integrate native code into a managed application. The book is well written (one of the best I've read recently), and the only thing i missed is a few chapters on how-to integrate into an existing pipeline - like importer/exporter for a common 3d package at least. A better title for this book would be "(game)tool programming gems"

Then, as a hobbyist, I'll just let you know that this book not only teaches, but flat you gives you some great modular code that you can work into many different types of tools.

There's also some great design principles covered that have improved my workflow, even though i'm currently working solo.

This order was handled above and beyond the call of duty. They handled everything, including the problem of USPS losing the package. No questions were asked and the book was reshipped immediately. Thank You for the great service.

This book opened my eyes. I'd finished a Ph.D. in computer science, and had a decent exposure to quite a few programming languages and paradigms, before coming across this book. I was surprised to start working through this introductory book, and find myself learning new things! The book transformed my approach to programming.

From page one, HtDP starts talking about good program design, and gives a methodical approach. Until this, I'd always thought programming books were "here are ten small example programs; go write ten more." That's hardly teaching. But HtDP builds up a straightforward design recipe, to guide programs along. If I get stuck or have a mistake in my program, 90% of the time I realize it's because I strayed from the book's recipe. The approach is language-independent, although some programming environments make it much easier to implement the design recipe; the book provides links to a good (free) Scheme environment, which it uses for its code examples too. (I've come to use that environment day-to-day). My code--in any language--has become much more robust, and when I do have a bug I usually locate it early, thanks to this book.

In addition, HtDP made me think about things I'd taken for granted: How is assignment to a variable fundamentally different than assignment to a structure's field? Even, *why* do I use assignment statements in certain situations, instead of choosing a functional approach? How often do my programs actually need the efficiency of imprecise floating-point arithmetic, vs using bignums which totally liberate me from numerical inaccuracy?

Although the text is available on line, I cherish my hardcopy. This is a book to first learn programming from, and one to revisit every five years.

As a programming do-it-yourselfer I've had many conflicting responses to this text -- it's didactic style, its attention to detail, its sometimes patronizing tone, its rigor and broad scope and at the same time its immersion in minutia and quiddities I have never encountered in 'computer books' I had ever perused. Perhaps it's my liberal arts background, or love 'em/hate 'em sensitivity to all those broad stiff-spined textbooks I had carried in back-packs since childhood, combined with a disdain for the authoritative stilted style these educators exude -- despite their patent love of their subject. I felt at once both patronized and condescended to.
From the very start of their journey into a detailed six step-by-step process that show the reader how to analyze problem statements, how to formulate goals, make up examples, outline a solution, and test a solution the authors proclaim their pedagogical ends: "We [...] believe that the study of program design deserves the same central role in general education as mathematics and English. Or, put more succinctly, everyone should learn how to design programs..." This is not a textbook, this is a revolutionary pamphlet calling for educational reform. I had read nothing like this in the tens of 'Dummies' and 'In 24 Hours' books I had exposed myself to. One part priggish, two parts pedagogic. I often found myself asking for whom was it written? First-year college student?, ambitious would-be high-school programmer wanna-be? Math mavens? Surely not a middle-aged bookish clerk who tastes run more to Turgenev and Dostoevsky than Turing and Dijkstra. But then I demanded more than mere anonymous web-lurking from my lowly pc. I remember myself many years ago trying to learn BASIC on a massive time-share computer and telling myself surely there was had to be more magic to computing than this. Well, after reading more texts and having had to unlearn the 'Dummies' and the 'In 24 hours' style of disinformation I had finally found the marrow of a discipline that is as demanding as any I had ever come across and as vexing as any artistic rigor I had ever been inspired by. Come be confused, come be amused, amazed and intellectually abused. Sorely, if I find I have little talent for this excruciatingly logical endevour, I have also found a full-blown appreciation of such daunting computational cheekiness. Much to learn here, and this is only the "core subject of a liberal arts education." What had I been wasting my time on all those years as a professional student?

I have been professionally developing software for about 5 years. I found this book to be one of the most useful and helpful books to help my coding skills. Even though I have been programming professionally for a few years and have a computer science degree, I learned a lot of new neat concepts from this book. It also helped to me to remind me of all the basic good practices that I have forgotten.

It is also an excellent book for beginners. The books doesn't use a popular programming language like Java to accomplish its goals. Instead, it uses Scheme so the student can focus on the concepts rather than syntax. It also teaches great concepts and breaks the problem down on how to solve various problems. Also it isn't "hardcore" like SICP-- it is very friendly to non-MIT level people.

Great book! I liked the way the author approaches how to begin designing programs. I am half-way through the book and I am finding it very entertaining. Yeap! I recommend this book.

Mr. Ulrich has delivered a framework with which IT areas can effectively leverage their existing applications and data to meet the ever-changing business environment. Bill's chapter on Case Studies provides real life examples of how to use his methodology. We face rapidly changing business drivers, including the need to make our businesses internet-ready. This book provides the materials to allow companies a fighting chance to succeed.

I read Bill Ulrich's book and was delighted to see that he was clearing laying out strategies that we were dealing with as we worked with our clients. We now make Mr. Ulrich's book part of our mandatory reading for our consultants and have purchased copies for distribution to some of our key clients. This has helped both our consulting teams and our clients in planning and project executiion.

Mr. Ulrich understands how businesses have a tremendous reliance on legacy systems. Pressure is always on the IT staff to meet the demands of the business cusomter. The IT community is asked to bring products and services to the consumer through the internet while managing the internal demands to keep expenses under control. Bill's book lays out a framework in which the business community can build company-specific plans to leverage their prior investments while striving to meet today's business drivers in a manner that is cost effective.

Bill has filled this book with tremendous value for any one working with existing systems of any kind. He builds in the flexibility of approach by mapping many common and not-so-common methods and strategies through his exploration of specific case studies. Chapter 3 is a valuable item on its own - rarely have I seen such a thorough and clear examination of all the different 'movements' in IT in the last 10 years. Nice job, Bill.

Corporations have been trying to retire legacy systems for the past couple of decades. Each new technology (be it client/server, ERP packaged apps, etc) were supposed to put the nail in the coffin for legacy systems. Yet, legacy systems continue to thrive despite attempts to retire them. One reason why they continue to exist is that in many instances, they support business processes in the most efficient and cost-effective manner possible. Bill's book views this area more as a transformation effort (evolution) rather than wholesale legacy replacement (revolution). This book is a must read for IT departments as they struggle to remain relavent in an era of outsourcing.

The strategies outlined in this book will help the IT department become a partner with functional business units in delivering solutions that address burning business problems. The focus shifts to providinig measurable value to the business as opposed to implementing unified and elegant technologies.

I am an ancient programmer switching from C to .NET. I have read a lotta books in my time and this is the best presentation and layout of a book I have ever seen. Its easy to read. Content is great. I wish I had found it first in my conversion to .NET. I am so impressed that I am checking out the other Murach titles for something to buy.

I needed to learn ADO.NET for my job and this book was the best on the topic I read the entire book in about 3 weeks. Everything is explained wonderfully. I love how the examples are laid out on the right with explanations on the left. I also really found the program files extremely helpful. I opened each chapters program and followed right along with the book. All the examples are already created so that you can see how they work and even modify them.

I liked this book so much that I also bought the ASP.NET, SQL, and Visual Basic 2005...all topics I need to brush up on. As far as I can tell these other books follow the same great format.

From someone who thousands of dollars worth of technical and programming books...these are great even for beginners. However if you are not familiar with vb2005 get murach's visual basic 2005 to read first.

As with the other Murach Press books I have reviewed, this book is extremely readable. It shows step-by-step how to develop database applications with VB. NET 2005 and ADO.NET. This book is best suited to someone new to database development with Visual Studio 2005 but that has a passing familiarity with VB syntax. If you are unfamiliar with flow control statements and VB syntax, you might want to look at Murach's "Visual Basic 2005" book first. I highly recommend this book for entry to mid level developers.

ADO.NET is a huge and sometimes daunting topic to attempt to cover, but in traditional Murach fashion, this book has the capacity to make its reader an expert if read cover to cover. All of the important topics are coverered, including use of the base objects, data binding, typed vs. untyped data sets, and most importantly (in my opinion): use of object data sources.

The best part of Murach books (including this one), aside from the paired page layout, is that they make no assumption about the reader's skill level, and cover enough background on each topic to ensure that you will come away with a thorough understanding of not just what and how, but also why.

Both beginner and expert programmers alike will find this book extremely useful, and it's a great addition to the Murach family of programming reference and tutorial books.

I am a C# developer but when I started browsing this book I couldn't help it but to continue reading it. It is not only about the VB language itself, but instead, how to use it so solve software problems. It teaches how to better write software, best practices and approaches.
This book doesn't cover all the theory in the world about a topic. Also, not all topics. But it tells you how to use them and what to watch for.
I am glad to have read it.

I am an intermediate programmer, who in the past, has done some Visual Basic 6 and Win32 API integration programming. After learning VB.NET and C#, I found that the .NET Framework was missing some functionality of the Win32 API, which surprised me a little since Microsoft is really pushing .NET as the "API" of choice for developers.

I agree with the book that the .NET Framework is mostly targeted at business developers and the Internet for B2B and B2C applications, as well as internal Enterprise applications. Having said that, I have found the .NET framework lacking, and as the author points out, most likely due to how young it is in comparison to the Win32 API.

This book will get you up and running with making those Win32 API calls when you can't find that same functionality duplicated in the .NET Framework. There isn't much documentation on this subject matter on MSDN or the web (searching on Google), so this is pretty much it. The author did a great job, however, at times, the examples were a little light or topics weren't explained as thoroughly as they should have been. For example, the author will tell you what data type he used in place of a native Win32 data type, but doesn't clearly explain his reasoning for the choice. But other than that small complaint, this book is a must have for any .NET developer.

Let's face it, .NEt is really cool, but it isn't a finished product. For everything else, there's this book. He has some Great examples and explains everything amazingly well. I'm a book junkie and this is definitely one of the best books I've come across recently. I think this book would be a tremendous asset to anyone who wants to learn how to get around .NET's current limitations.

.Net Framework Solutions is a very useful resource for those .Net developers (using C# or VB.Net) who want to access the Win32 api from their .Net programs.A no of working examples (with source code available on accompanying CD) and lucid writing style makes this book a pleasure to read and can be very useful to avoid the traps in calling Win32 API. This book assures that you are not stuck with some problem because the .Net Framework does not provide support(which still lacks support for a no of Win32 APIs.)

If you are doing .NET -> Native interop., this book should pretty have almost all that you need. Note that it does not cover COM (RCW) interop in that much detail and does not talk about CCW (COM -> .NET). However, the coverage of MarshalAs() and the clever examples that show how to deal with the complex DirectX structures are alone worth the price of admission.

What I liked best was the author didn't take the cop out solution (managed C++) unless it was absolutely necessary. Most of the code examples in the book are in C# and this might be of some concern to the VB.NET programmers. The chapters are well organized and there's an appendix with 50+ good tips on PInvoke. If you are still struggling with your PInvoke interop problem after reading this book, it's time to bring out the heavy weight (Adam Nathan's bible) -- good luck!!!

Atul

This is a great book for developers seeking to understand how to translate C++ datatypes in the Win32 API functions into C# and VB.NET. It's not in-depth like Dan Appleman's VB's Guide to the Win32 API in past years, but it's the first of its' kind for .NET. My only wish is that the author not have spent so much time on DirectX and instead provided more general examples of other API calls. DirectX coverage should have been left for another book aimed specifically at that technology.

I have been fascinated by the simplicity and usefulness of the
Object-Process Methodology paradigm and approach expressed in the book. As a
researcher in Science Education I have been grappling with how to represent
complex, technology-enhanced educational systems that involve humans,
processes and educational artifacts. OPM and the OPCAT software enclosed
were very instrumental in enabling me to model and represent the "big
picture" of educational systems I developed. With OPM I was then able to
gradually refine portions of the system to any desired level of detail.
The applicability of OPM to IT-intensive educational systems is a testimony
to the generic nature of the methodology and to the fact that it is useful
in so many domains. The combination of a single simple graphical model that
generates natural language on the fly is really unique and valuable. I
wholeheartedly recommend the book to anyone interested in modeling complex
systems, be they of technological, economical, or social nature. The method
is straightforward, easy to learn even for non IT-professionals, and most
rewarding in terms of the quality and clarity of the resulting graphical and
textual model.

This book describes how Object-Process Methodology (OPM) CASE can be used as a tool for generating complete system intent specifications by graphical object diagrams, precise semantic and syntactic language, and intuitive symbols, definitions and structures. As systems have become more complex, a prevalent problem in systems development has been the number of accruing errors. These errors can cause catastrophic failure in the worst-case in addition to intolerable schedule delays and cost overruns. Introducing errors as well as difficulty finding and successfully correcting them occurs because of the lack of proper analysis and design tools for complex system specifications. OPM has the attributes to mitigate against the possibility of system failure, providing comprehensive visibility for better schedule and cost control in product development. It enhances reuse of system modules, processes and software routines in different contexts, while reducing the chance of errors. OPM automatically generates intent specifications that are readily understood by both customers and product team members and are translatable to machine control subsystems. OPM is a holistic systems paradigm that extends the Object-Oriented (OO) paradigm and overcomes its major shortcomings by integrating system structure and behavior in a single integrated graphic and natural language model. OPM successfully tackles the task of development and lifecycle management of systems, products and projects. OPM is a significant extension of and a major departure from the OO approach. It incorporates the system static-structural and dynamic-procedural aspects into a single, unified model. Presented as a concise visual formalism by a set of Object-Process Diagrams (OPD set), it is automatically translated into a set of Object-Process Language (OPL) script, a subset of natural English. At the basis of the OPM philosophy is the observation that to faithfully and naturally analyze and design systems in any domain, processes, like objects, should be considered as stand-alone "things" (entities) that are not necessarily encapsulated within objects. This detachment and de-coupling of processes from objects emphasizes the duality and complementarity of objects and processes, and opens the door for structure-behavior unification. At any point in time, objects exist with some structure and state. This is the static aspect of the system. Processes affect objects by changing their states. This is the dynamic aspect of the system. System complexity is managed through a number of graphical scaling options: zooming into and out of processes, unfolding and folding objects, and expressing or suppressing object states. These mechanisms provide for selectively detailing a subset of things while still maintaining the high-level context of the details.

OPM provides a new framework for specifying design intents and capturing the complexity of hardware and software interaction. Through OPL, it is possible to translate the process into a machine executable code. In addition, OPM can capture the dynamic behavior of the hardware attributes and software states in a single integrated graphical and textual language that is understandable by domain experts who have no programming experience. These traits of OPM ease the development effort for evaluating the system reliability during the design stages. Simulation and testing protocols can be automatically generated though future extensions of OPM to reduce lengthy system verification efforts.
The main benefit of OPM is its ability to identify system objects, processes, and the relationships among them in a structured way. The resulting OPD set becomes an excellent framework for identifying how to implement structural and procedural improvements. The resulting OPL script provides a well-defined set of existing and future specifications for the system. The ability to freely switch from text to graphics and back is of great value to understanding the system as a whole with a single graphic and textual model, without the need to consult various models and carry out mental transformation among these various models.
Based on my personal experience, the following points highlight the benefits OPM can bring to the particular projects described in this paper.
1. OPM is an excellent way to represent daily activities, products, processes and other complex things
2. OPM has allowed representing the complete system with its various aspects in a single model. The model specifies the systems function, structure and behavior aspects without sacrificing clarity.
3. OPM can be used as a common language to exchange design among members of a team.
4. Since OPM design is visual and textual at the same time, it is easy to explain the design.
5. OPL is very easy to generate from OPD
6. OPM will be a good tool for documenting the existing processes and as ISO documentation.

I have used many methodologies over my career. Most of them are based around the object-oriented and structured design paradigms. I found out about OPM quite by accident about a year ago. I've been using it ever since. I have used it to model both hardware and software systems, as well as for business process modeling. It is an excellent methodology and I recommend it for anyone developing any kind of system.

One of the nice things about OPM is that it is easy: I was able to get a team "up-and-running" with the methodology in less than an hour of teaching them some basic concepts (try doing that with UML). Another feature is that you can use this for any type of project; you are not locked into a structured or object-oriented mindset like structured analysis or UML. OPM can handle both types of concepts with ease.

Finally, this methodology is fast. It is just easier and more intuitive to model in an OPM fashion. I've also found that others can comprehend the OPM models better than other methodologies too.

I used to be a UML advocate until I found OPM. I have found concepts that are difficult to model in UML are quite easy to model in OPM. It is just more flexible.

The book is really good by the way. It is very complete and gives plenty of good exammples. I congratulate Dov Dori and his team for providing something that all engineering disciplines can use to design their systems.

OPM is a methodology for modeling systems, technical as well as any other system. In the techical world it compares with UML. OPM is designed with consistant and simple notations, uses simple rules that when combined can be used to model any system (real or informational) to any level of complexity that is desired by the system architect. Also, it integrates object modeling and process modeling in one diagram (although you can still keep them separate if you wanted).

UML uses complex rules to model complex systems, something that is very difficult to make happen, therefore it is very difficult to learn and use. OPM uses simple rules and consistant notations to model complex systems. After simple introductions to the methology, we have been able to start using it in our organization. More powerful and far simpler then UML. The way UML should have been done long time ago.

There is an eternal debate between system designers
and architects of software, products and large systems:
Is it ever possible to show structure (the arrangement
of objects) and system behavior (over time) in the same
representation? Dov Dori's book shows convincingly that it can
be done. Particularly powerful is the duality between
graphical system representation and natural language.
Also, the CD-ROM with OPCAT software allows one to follow
the examples in the book and apply OPM directly to a project.
The book is clearly written and will appeal to engineers,
computer scientists and software developers. A refreshing
contrast to the traditional way of looking a object-centered
systems architecting. This begs for more ... in terms of
connecting OPM to other tools such as Design Structure Matrices,
but also for representing highly complex systems over >2 levels
of decomposition.

I have purchased several markets development books and this one beats them all. It has a fantastic overview of the markets, the language is awesome & the detailed instructions on how you can build your system ground up is fabulous. I'd recommend it to everyone from Beginner to a Pro - "A must buy !!"

For me, just beginning in this field, this book is a gem.
It has great explanations of the lingo/structure of the financial markets as well as useful code examples.

'Practical .NET for Financial Markets' by Samir Jayaswal is a very specialized book for all financial developers. Laid out over 9 chapters with 500+ pages of detail this is a wonderfully written reference for this niche market.

If you are a .NET developer in the financial industry you owe it to yourself to pick up this great resource!

***** RECOMMENDED

This text is excellent in what it sets out to do and five other reviewers have said so with 5 star ratings. I agree very much with the reviews of Ted Hrudz and Gulli Ellee, in particular - they are well said and spot on. I think I must make a few comments of my own, however. I have managed financial software projects in the last seven years and have experience in developing and implementing capital and money market securities software, and prior experience in implementing equity software, so I have some background and interest in this area.

First the positives: This books succeeds enormously at providing a very good introduction to equity markets and front and back office software development from a .NET development lead, architect or developer perspective. In less than 500 pages the authors manage to provide a very good and reasonably comprehensive/broad tutorial in several aspects of financials as well as .NET and the book makes reasonably easy reading for such technical subjects. Most of the relevant and interesting topics are covered or touched on. The reviewers I mention above itemize most of the .NET and financials topics covered so I will spare you the repetition.

The authors are obviously very knowledgeable in both the securities domain and the .NET architecture and development technologies and issues and convey their knowledge expertly. This book makes an excellent introduction (but ironically advanced/intermediate in several respects) to the domain concepts and requisite architectural/developmental .NET features. Having said that let me add that you will need more than this book if you seriously plan to undertake financial software development with .NET. You may need to supplement your knowledge in both areas with some of these books, depending what you already know or have been involved in:

Securities/Electronic Payments Domain: 1. Securities Operations: A Guide to Trade and Position Management by Michael Simmons; 2. Corporate Actions by Michael Simmons; 3. After the trade is made by David M. Weiss, Revised 2006 Edition; 4. How the US Securities Market Works by Hal McIntyre (2nd Edition); 5. Gobal Securities Operations by Jeremiah O'Connor; 6. Trading and Exchanges: Market Microstructure for Practitioners by Larry Harris; 7. An Introduction to Financial Technology by Roy S. Freedman. 8. You may also need to understand Secure Electronic Payment Systems (see texts by Weidong Kou, Mostafa Hashem Sherif)

Technology (.NET Framework, Visual Studio & SQL mainly) : Books by some of the best authors such as 1. Juval Lowy and Alex Ferrara (.NET 3.5, SOA/WCF, Web Services, Remoting, Messaging, Application Logging, Threading, Component-based/Distributed Architectures, Application Security Design, etc.); 2. Chris Sells (Windows Forms in VS 2005); 3. David Sceppa, Brian Noyes, Fabrice Marguerie or David Ratz(ADO.NET 2.0/3.5/Data Binding or LINQ); 4. Stephen Walther, Alessandro Gallo, Cristian Darie, Marco Bellinaso (ASP.NET 2.0/3.5 and AJAX); 4. Nick Rozanski (Software Systems Architecture); 6. Itzik Ben Gan (MS SQL 2005-8); 7. Secure Coding against hacker attacks using books by Gary McGraw/Billy Hoffman/Michael Howard such as 'The 19 Deadly Sins Of Software Security'; to explore such topics in greater detail.

I think the author could have added the equivalent VB.NET code for VB developers and architects. That is the main beef I have (and the book is a bit too expensive, buy it online for a rebate. It should have been paper back to reduce the price for readers) but I still thinks it deserves a 5-star ranking . Bravo to Samir Jayaswal and Yogesh Shetty, the authors!

The authors' experience building a .NET application for a trading house shows. As a result I learned a little about the domain & saw several well written "how to" .NET examples based on it.

Two negatives might be worth considering before spending a fair amount of money. First, not much (anything?) about building high performance applications. Lots of talk about needing performance in the securities market, little in the way of delivery. Second, the book is based on .NET 1.X "best practices". The chapter on 2.0 reads like a last minute techno-tour.

Many books around Oracle's advanced topics simply parrot the manuals. Julian avoids that. Instead, he describes Real Application Cluster technology from the ground concepts up to full implementation, with practical notes and tips. He gets into topics that the manuals never touch, and much of what he writes can be useful in any RAC environment, not just Linux.

I whole-heartedly recommend this book and own both the paper and eBook version which I often reference.

This book delivers what it promises. It contains a great balance of technical detail,examples and theory. It encompasses all aspects of implementing/maintaing 10g RAC on Linux.

Very well written. No mater you are a Pro or a newbie, it will be helpful. A very well written book.


Highly recommended.

This is a very hands on command line oriented book. Good understanding of RAC concepts. I found it extremly useful in my day-to-day work.

Highly recommended.

Thanks!

This book can easily be used as a college textbook on Oracle RAC. I am studying for the Oracle Certified Master exam and this is possibly the most high level book on Oracle I have read.

It has 3 major strengths which I found to be superior to any Oracle RAC books I have read (including the manual from Oracle).

1)Technical Depth
2)Comprehensive Overview and instructions
3)Quality of writing


1)Technical Depth
The authors write about Linux and Oracle and are high level experts in the subjects. For example, the authors have a very detailed description of how Oracle Cache Fusion handles locking across all the nodes in a RAC environment (probably the crown jewel of RAC technology). They also discuss, in detail, different types of CPU, memory, and storage and contains detailed description of each architecture. Lastly, it contains vast number of "how to" install, configure, change, analyze, backup/restore, and utilize Oracle RAC and Linux.

2)Comprehensive Coverage and Instructions
No small amount of detail has been skipped. The book contains every utility (there are many) provided by Oracle to implement RAC. It provides a good step-by-step coverage of Linux and Oracle RAC installation as well what each step is adding to the RAC environment. To top it off, it adds how to performance tune, administer, troubleshoot, backup/restore, and use Dataguard in a RAC environment. I can't think of a subject on RAC which the authors did not cover.

3)Quality of Writing
I was pleasantly surprised how well written this book is. Although far from a Pulitzer Prize material, it certainly belongs in that category amongst the Oracle books. Every praragraph has been well organized and written. The proofreader of this book deserves major praise for their work.