Customer Reviews

Programming Flex 2: The Comprehensive Guide to Creating Rich Internet Applications with Adobe Flex

5 star:		(7)
4 star:		(7)
3 star:		(4)
2 star:		(6)
1 star:		(1)

 

 

§
The authors do a good job introducing the concepts and techniques of Flash-based Flex programming. Much of the content is directed at developers completely new to creating Flash content although familiarity with an object-oriented programming language and the latest trends in JavaScript (see my other reviews for examples) is recommended.

I won't recapitulate the chapters, which are given above in the editorial review. I just want to point out that the chapter order is not random but based on the authors' step-by-step approach though basic concepts.

To follow the examples you will need either:
- the free Flex SDK and your favorite code editor
or
- a trial version of Flex Builder

I give the authors credit for doing the extra work to show both alternatives in the samples. Believe me, the Flex Builder way takes far fewer steps!

I was disappointed with two things:
1) The URL for the book Web site was wrong. When I did find the book page on the O'Reilly site, there was no code download link. Since many code snippets were quite extensive, this lack is more than an inconvenience.

2) Each chapter stood more or less on its own. There was no integrated example to build upon from chapter to chapter.

This book fills in the gaps of the official Flex documentation and helps get you comfortable quickly with Flex.
§

I've been using this book for about a week or so now and while I think it's well written and provides a good foundation for Flex development concepts, I find it lacking as a reference book. In particular, the index is nearly worthless. It seems like every time I want to look up a property or component, even some common ones, they are not listed. I've had better luck with Google searches and Adobe Live Docs. It's also very light on ActionScript because the author has another separate book dedicated to that subject.

If you want to read a technical book cover to cover, this may be for you. If you need to dive right in and are looking for a good reference book, this is not it.

I picked this book up and felt like I was sliding right into Flex. The concepts are familiar, the book lays the concepts out logically, I installed Flex Builder and did an initial HelloWorld and thought "This will be fun!"

After reading a couple hundred pages, I wanted to start a project. This is where the problems with the book hit me. The topics are covered at a very superficial level, and without any hands-on exercises. You don't proceed through simplistic but pedagogically useful example scenarios. I'm now reviewing the book, and its too-scant index (which makes it an unacceptable reference later), and realizing that I gleaned little about how to construct an application. How do I hook the MXML model to my ActionScript classes that provide the controllers? There's a VERY brief chapter on the life cycle of Flex apps and I'm sure I'll be able to figure this out because I've done similar things, but this is more a theoretical discussion of the concepts behind Flex than a how-to on programming Flex. Tastes great, (but) less filling. My guess is that a better hands-on Flex book plus a good ActionScript 3.0 book would be a much better choice, both for learning and for later reference.

This book is well-written, and (in its Rough Cuts format) was very helpful while I was getting up to speed in Flex basics. Unfortunately it's virtually useless when it comes to helping out in real world projects. For instance, there are no examples of such basic use cases as importing an external xml file using the HTTPService tag, or how to populate a DataGrid using external data.

I give the book 2 stars instead of 1 because it does serve as a good introduction. But as soon as you start to try to get some work done, it's fairly useless. A major disappointment for a long-anticipated book. The Adobe Flex 2: Training From the Source, while far from perfect, is far superior in providing working code examples.

I own a lot of O'Reilly books and I like all of them . . except this one is not what I expected from O'Reilly books.

This books does explain the basics and provide beginners the needed information. But the book is a 'READ MY FEATURES' books, no practical examples, just short snippet codes that are unrelated each chapter. When u start reading everything looks cool. You understand everything, but if u start implementing something, u will get stuck. For example, using xml for datalist providers, i cant really find the information where they tell you where to put the code . .and more importantly, which packages you need to import. Although i figure it out myself, its confusing.

I stopped reading this book, I just browse it to see what features Flex 2 offers, then i better learn on the net, the quick start tutorials provided at the devloper site provides the EXACT information of the book . . even the structure of the discussed information are 80% the same, except they are more practical . .

I hope Flex 3 book will be a better one . . . but this time its a waste of time and money.

The book is structured to gradually exposure the reader to Flex programming. Since I was pretty new to using Flex, I found it rewarding to just read straight through chapter-by-chapter. The book is written such that it doesn't assume that the reader has had any exposure to Flash-based programming. If you have had any experience with other object-oriented programming languages then you should feel right at home programming with Flex 2. I did find it useful to have some familiarity with web technologies like HTML, XML, and Javascript.

The authors don't waste a lot of time getting right to the interesting parts of Flex: there are the obligatory pages about the history of Flex, and a section of how to go about downloading and setting up the development environment, but by these are short and concise. I also find it refreshing that the book doesn't assume that you will be using FlexBuilder (Adobe's for-pay Eclipse-based development environment), and they give equal treatment to those who are developing Flex applications using the free Flex 2 SDK.

The book had a basic introduction to ActionScript, which is the scripting language that Flex uses, but by the time I had read about half-way through the book, the Actionscript code samples were starting to get pretty involved. Fortunately the descriptions of what the code was doing were clear and the program flow was pretty easy to follow. Learning Actionscript is a topic that could fill its own book, so the authors had a deliberately narrow focus on exposing enough Actionscript to make it possible to learn Flex. Once you are done with this book, you will probably want to pick up a good book on ActionScript to expand your understanding.

The book also has a very well-written chapter on accessing remote data services using HTTP and Web Services. This is where having some experience with setting up Web Servers and doing some server-side programming really came in handy. Compared to the other chapters of the book which felt more or less like a tutorial, this chapter seemed to come the closest to presenting the true power behind using Flex as a Rich Internet Application framework. Sadly, the chapter was rather short and I found myself wishing that there was more on this topic.

One small complaint I have about the book was that it didn't appear that any of the example code was available on-line. The book lists a URL that claims to have example code, but that only gives an error when you type it in the browser. When you do manage to find the page by searching on the O`Reilly website, there doesn't appear to be any download links for the book. Not that this was a huge problem: even though XML tends to be very verbose, I was happy to see that for the most part the authors were able to keep their example code snippets relatively small and it was pretty trivial to type them in myself. It might just be that Flex is so expressive or that there is really good library support, but I didn't feel too inconvenienced by not having access to the source code.

Overall I was pleased with this book. It is difficult to cover a topic like Flex, MXML and Actionscript in a scant 450 or so pages, but the author's definitely seem to have covered the basics. After reading the book I found myself wanting to do more with Flex 2 and wanting to learn more about Actionscript.

If you are newcomer to the world of Flash programming and want to see what the future of the Flash platform is, then I heartily recommend this book. If you are already savvy with Actionscript (the version that Flex 2 supports is 3.0) then you may still find some value in this book due to its' coverage of MXML and theFlexBuilder toolset.

I've finished working my way through Programming Flex 2. Overall, I found the book a good introduction to Flex 2. The chapters are well written and the various concepts are explained clearly.

However, the code download from O'Reilly for this book is extremely poor. You get approx. 272 code snippet files that are incomplete and badly named. It is very frustrating if you want to actually load one of the chapter examples into Flex Builder to run it yourself. I could not find some of the chapter examples (for example try finding the code for the using HTTPService with ActionScript example given in chapter 16).

If you're an absolute beginner with Flex 2, then this book is a good introduction. But do not expect this book to be a complete reference or to provide examples you can try (unless you are going to type all the code yourself).

The Flex 2 framework is built on Flash Player technology, and it leverages a very fast virtual machine built into Flash Player 9. Thus Flex 2 applications can utilize all the functionality of a Flash Player while vastly simplifying the creation of Flash Platform applications. This is a very good book that supplements the official Flex documentation quite clearly. Although aimed at anyone interested in learning Flex 2, the reader should already understand object-oriented programming concepts along with certain other computer science concepts such as run-time environments and compilers. You'll also get more mileage from this book if you already know ActionScript. This book is not intended to teach you that language. The following is a detailed table of contents and brief description of each chapter:

1.Introducing Flex - Introduces Flex and its technologies. Flex is compared with other methods for creating Internet applications.
Understanding Flex Application Technologies; Using Flex Elements; Working with Data Services; Understanding the Differences between Traditional (HTML) and Flex Web Applications; Understanding How Flex Applications Work; Understanding Flex and Flash Authoring; Understanding Flex 2 and Flex 1.5; Summary;

2. Building Applications with the Flex Framework - Discusses the tools necessary for creating Flex applications and projects. Shows what makes up a Flex project and how to compile and deploy Flex applications.
Using Flex Tool Sets; Creating Projects; Building Applications; Deploying Applications; Flash Player Security; Understanding HTML Wrappers; Using SWFObject; Using Runtime Shared Libraries; Summary;

3. MXML - Discusses the markup language that creates the UIs of Flex applications. If you are familiar with any other markup language, this chapter should be pretty easy.
Understanding MXML Syntax & Structure; Making MXML Interactive; Summary;

4. ActionScript - A quick refresher on ActionScript. If you are a novice you'll need outside sources.
Using ActionScript; MXML and ActionScript Correlations; Understanding ActionScript Syntax; Variables and Properties; Inheritance; Interfaces; Handling Events; Error Handling; Using XML; Reflection; Summary;

5. Framework Fundamentals - All about what goes on behind the scenes in Flex. You'll need to know this as you work your way up to more complex applications.
Understanding the Flex Application Life Cycle; Differentiating Between Flash Player and Framework; Bootstrapping Flex Applications; Understanding Application Domains; Understanding the Preloader; Summary;

6. Managing Layout
Flex Layout Overview; Making Fluid Interfaces; Putting It All Together; Summary;

7. Working with UI Components - Discusses all of the categories of UI components in the Flex framework at a high level.
Understanding UI Components; Buttons; Value Selectors; Text Components; List-Based Controls; Pop-Up Controls; Navigators; Control Bars; Summary;

8. Framework Utilities and Advanced Component Concepts - Discusses the libraries that allow you to add features to the components discussed in the previous chapter.
Tool Tips; Pop Ups; Cursor Management; Drag and Drop; Customizing List-Based Controls; Focus Management and Keyboard Control; Summary;

9. Working with Media - Talks about how Flex handles all of the different media types.
Overview; Adding Media; Working with the Different Media Types; Summary;

10. Managing State - Discusses how Flex uses the state to describe a collection of changes to a view.
Creating States; Applying States; Defining States Based on Existing States; Adding and Removing Components; Setting Properties; Setting Styles; Setting Event Handlers; Using ActionScript to Define States; Managing Object Creation Policies (Preloading Objects); Handling State Events; When to Use States; Summary;

11. Using Effects and Transitions - How to apply special effects via Flex.
Using Effects; Creating Custom Effects; Using Transitions; Creating Custom Transitions; Summary;

12. Working with Data - How to work with data on the client side focusing mainly on data modeling and data binding.
Using Data Models; Data Binding; Enabling Data Binding for Custom Classes; Data Binding Examples; Building Data Binding Proxies; Summary;

13. Validating and Formatting Data - How to insure that input or display data follows certain rules.
Validating User Input; Formatting Data; Summary;

14. Customizing Application Appearance - How to customize the appearance of the Flex components.
Using Styles; Skinning Components; Customizing the Preloader; Themes; Runtime CSS; Summary;

15. Client Data Communication - Discusses types of data communication in Flex applications that occur entirely on the client side.
Local Connections; Persistent Data; Communicating with the Host Application; Summary;

16. Remote Data Communication - Discusses types of data communication that require network connections for transmission.
Understanding Strategies for Data Communication;Working with Request/Response Data Communication; Web Services; Real-Time/Socket Connection; File Upload/Download; Summary;

17. Application Debugging - All about the debugging tools that come with Flex.
The Flash Debug Player; Using FDB; Debugging with Flex Builder 2 Remote Debugging; Logging Using trace() Within an Application; The Logging Framework; Debugging Remote Data; Summary;

18. Application Components - All about the logically modular elements within an application defined via MXML and how they fit into the component-based development principle.
The Importance of Application Components; MXML Component Basics; Component Styles; Summary;

19. Building Custom Components - Discusses details you need to build your own truly unique components.
Component Framework Overview; Component Life Cycle; Component Implementation; Adding Custom Properties and Events; Adding Styling Support; Summary;

Just for quick background, I'm an application developer/analyst, and have been for 10+ years. I've taught myself all the languages I know using books, many of them from Oreilly - and I've never yet been disappointed with one of their books until now...

I worked though a great deal of this book, but found I was learning very little. Finally, with deadlines looming, I just started working with Flex Builder, and searching for answers online. At this point I came across Adobe's documentation for Flex - which is extensive - and absolutely beats this book hands-down. Don't waste your money - use the docs on Adobe's site, and you'll be ahead of the game. On a couple of occasions I've reached for this book to get an 'instant answer' - as it was sitting on my desk, and what I need is so simple, it must be both in there - and in the book's index... but I've found each time that the book was of no help at all.

'Programming Flex 2: The comprehensive guide to creating rich media applications with Adobe Flex' is a nice resource for delivering smart, rich web content with a lot less effort thanks to the Flex 2 SDK. Packed with 450+ pages of content, this book covers everything such as topics like ActionScript, validation, transitions, state... all the goodies that you would expect to learn about when going down the Flex road. Written in a nice, typical O'Reilly fashion, my only gripe would be the lack of pictures to demonstrate the content within in the last 3/4 of the book. With a visual topic like Flex I wouldn't want to have to rely on my imagination to 'see' what the end result would be, but alas that is the case with this book.

Nice book for beginners to Flex who are looking to get started with this great package for delivering dynamic content in a slick and efficient manner.

**** RECOMMENDED