Customer Reviews

Flex 4 in Action: Revised Edition of Flex 3 in Action

5 star:		(14)
4 star:		(1)
3 star:		(0)
2 star:		(2)
1 star:		(1)

 

 

One of the main features of Flex 4 is the new Spark component architecture, with its new layouts and skinning features. The book has only cursory discussion about Spark layouts, and almost nothing on skinning.

Skinning is the whole point! The new system is advertised to be the most flexible yet, giving the most power to designers, but I've found more information on it in blog posts and videos on Adobe.com.

I bought this book based on the high reviews, and that it was specifically about Flex 4. But I learned a lot more about Flex from Chafic Kazoun and Joey Lott's "Programming Flex 2" by O'Reilly.

The other material seems rushed as well; if I didn't already know Flex I think I'd be very confused.

Avoid this book if you're looking for an explanation of how Spark works.

I read the custom components chapter in this book to beef up my knowledge, having completed a few tutorials on creating Spark components already (thank goodness I had!) The author, rather than building up a single simple example has decided to show 'component code' for one component, but 'skin code' from some other component (actually he refers back to an earlier code example, as if creating a single cohesive example for this chapter was too much trouble).

Furthermore the skin code example has been unnecessarily imported from Adobe Illustrator (there is no actual end-component example to accompany this chapter, so why do that?)- all it means is that the example code contains additional Illustrator-specific information which in most circumstances is not needed, and it is not even explained here despite this supposedly being an introduction to Flex4 and Spark components.

The example also seems incomplete as there is no specific discussion about declaring the states-node in the skin-part to correspond with the component code. The first part of the chapter ends with the words "You now know how to make a simple custom component. Next up are composite components". Trust me, if all you have read is this chapter you won't know how, and you probably shouldn't proceed.

This book gets STUNNING reviews on Amazon.com but look deeper and almost all reviewers have either only reviewed this book, or have largely only reviewed other Manning publications - apart from someone who only gives it a 2 star review and says that the Spark info in this book is sadly lacking - possibly the only honest review there!

Having said that, a few chapters in this book are good - if you want to learn RobotLegs then Joel Hook's chapter is a great read, but otherwise I would steer clear. I'm sure all the authors are knowledgable but had unrealistic pressure to get something completed in too-short a time. This book certainly doesn't appear to have been peer-reviewed properly and is far too verbose in places .... and shame on any publisher who reviews their own books rather than striving to produce something of better quality (if indeed that is what's happened here - but I'll leave you to check out the reviewers' profiles and decide for yourself).

Overview
Flex 4 in Action is a rewrite and update of the original Flex 3 in Action published in February of 2009. The book retains its overall topic flow so it will feel like an old warm blanket for those that learned Flex 3 from the previous edition or used it as a reference. New readers will feel just as welcome as it is an easy-to-read, thorough tutorial of what you need to know to come up to speed with the new Flex 4. There are also a couple of additions to the book that take it a step above the others.
The authors are acknowledged experts in their respective fields and have converted organizations to utilizing Flex for enterprise class applications.

Summary of Contents
Part One: Application Basics
Chapter One: Making the case
The book starts by talking about challenges that a web developer faces and how to solve them using Flex by Adobe. It also dives into the mechanics of a Flex application and discusses the Flex ecosystem as a whole.

Chapter Two: Getting Started
The authors show you how to take advantage of open source tools. They spend a good part of this chapter discussing Flash Builder and how to begin producing Flex applications.

Chapter Three: Working with ActionScript
Chapter 2 introduced ActionScript and this chapter is dedicated to it. The authors admit that entire books could be and are written about it. This chapter focuses on ActionScript?s core concepts of variable types, operators, loops, conditions, arrays and functions.

Chapter Four: Layout and Containers
In this chapter Flex?s visual building blocks and types of containers are discussed. These components can be anything from buttons, tables and graphics to other containers.

Chapter Five: Displaying forms and capturing user input
Creating forms in Flex is the topic here using input components (controls) and capturing user input.

Chapter Six: Validating user input
In this chapter how Flex handles validation and the different types of validators such as those which verify the proper formatting of phone numbers and the structure of email addresses is covered. They are put to use, employing several different approaches.

Chapter Seven: Formatting Data
Formatting raw data with Flex?s built-in formatters is the subject of this chapter. This includes types of formatters, real-time formatting, scripted formatting and finally dealing with formatting errors.

Chapter Eight: MX DataGrids, lists, and trees
The authors cover everything you ever wanted to know about using list-based components from the MX library. Topics include list-based components displaying flat data, displaying hierarchical data, handling user interactions and retrieving selected items from List-based components.

Chapter Nine: Using the Spark List controls
In this chapter, you learn about the list-based features and functionality that ship with the Spark library, which is new to Flex 4. The discussion starts with the Spark list-based component architecture, and continues with how to leverage the new list-based Spark functionality in your Flex 4 applications.

Chapter Ten: List customization
This builds on chapter 9 by demonstrating how to customize the list-based components. Topics covered include the labelField property, label functions, overriding itemToLabel, item renderers and editors, advanced item renderers and filter functions.

Part Two: Application flow and structure
Chapter Eleven: Events
The event system is introduced along with its all-important role in a Flex application. Integrating native and custom events in an application while gaining an understanding of event nuances is also covered.

Chapter Twelve: Application Navigation
This chapter looks at the following components that you?ll use to add standard navigational features to your application: Menu, MenuBar, ViewStack, ButtonBar, TabNavigator and Accordion.

Chapter Thirteen: Introduction to pop-ups
The different ways of creating and managing pop-ups as well as simple ways to style them are here along with how to utilize the pop-up manager to help you create, delete, position, close, and destroy windows.

Chapter Fourteen: Implementing View States
This chapter starts by introducing the concept of view states in general. It then continues by covering everything you need to know about them.

Chapter Fifteen: Working with data services
This comprehensive chapter is all about data-centric development with Flash Builder. Starting with connecting to web services it continues with using the HTTPService and WebService components and understanding the Action Message Format (AMF). Communication with JavaEE using BlazeDS, ColdFusion Communication and communicating with PHP via Zend_AMF rounds out the discussion.

Chapter Sixteen: Objects and classes
Exploration of a fundamental feature of Flex, objects and classes, is the core of this chapter along with some OO theory. Covered topics include OO concepts, implementing OO concepts, using ActionScript classes, how to create, invoke and destroy them, and extend those that already exist.

Chapter Seventeen: Custom components
This chapter covers the basics of creating and utilizing custom components and tackles ways of getting your components to communicate with each other. Starting off by taking a look at how components are handled in Flex 4 and the Spark architecture, the discussion continues on with types of components and the difference between simple and composite objects.

Chapter Eighteen: Creating Reusable Components
Code reuse is the topic of this chapter. The example used in this chapter takes a look at a scenario where a component that reveals content must be created, but in many different ways, yet without having to write a separate component for each implementation.

Chapter Nineteen: Architectural Design Patterns
A deep look into Flex-driven design patterns and the thought process behind the core Flex architecture is taken. Then, rolling your own Flex application architecture is discussed without getting over-complicated. This chapter covers the Model-View-Controller pattern, how to roll your own architecture and mentions the frameworks Mate, Cairngorm, Parsley, and Swiz along with a deeper discourse into the Robotlegs framework.

Part Three: The Finishing Touches
Chapter Twenty: Customizing the Experience
This chapter focuses on the user experience and how you can leverage user experience design techniques in Flex to enhance your applications. The VIBE Model, themes and skins, CSS in Flex 4 and best practices are discussed.

Chapter Twenty-One: Working with Effects
This chapter first explains what effects are and how to use them and then the types of out-of-the-box effects are discussed.

Chapter Twenty-Two: Drag-and-Drop
D&D is considered from a usability point of view rather than just because you can use it or because of the coolness factor. The authors discuss how a mindset change is needed to accomplish this.

Chapter Twenty-Three: Exploring Flex-Charting Chapter
In this chapter, exploration of what makes up a chart, the charts that come with Flex, and how to customize them is covered.

Twenty-Four: Debugging and Testing
Debugging applications using the Flex debugger, using the Flash Builder Profiler and Unit and Functional testing of your applications is discussed.

Chapter Twenty-Five: Wrapping up a project
Tying up loose ends and getting the project out the door by customizing the HTML wrapper and deploying it to a production server is this chapter's topic.

Chapter Twenty-Six: Working with XML
In this final chapter, Flex's robust XML support, from its ability to use XML as a source of data, to how you can use Flex to directly manipulate XML code is presented.

Opinion
This new edition contains a thorough coverage of the new Spark components of Flex 4. It contains all you need to know to write applications with the new API.

The authors know from experience what you, as a developer, need to succeed and they make an admirable attempt at conveying it. This is nowhere more prevalent than their discussion in chapter 22 where they attempt to make you understand that just because something is 'cool' is not the reason to implement it in an application. When a feature will get the job done is the time to put it to use. You just need to change the way you look at things.

The book features two new chapters one of which was sorely missing from the previous edition. Chapter 19, Architectural Design Patterns, is a long overdue and very welcome addition. This chapter is a critically needed discussion of software architecture and assistive frameworks for Flex. Most books get atrociously overcomplicated, stay solely with theory and fail to bring those concepts to reality. They need to actually go through the process of designing architectures for actual enterprise applications. This chapter gives you the basics of how to go about it. This reviewer believes that a little two much time is spent with RobotLegs in this chapter at the expense of the others mentioned (one of the authors, Joel Hooks, plays a large part in the development and support of RobotLegs so that explains that). There aren't even simple examples of the other second-generation frameworks Mate (pronounced ma-tay) and, this reviewer's personal favorite, Swiz.

Chapter 9, Using the Spark List Controls, is the other new addition. This includes a thorough discussion of the Spark List Controls' class hierarchy and customization.

In chapter 24, Debugging, the authors could have spent a little more time on the Network Monitor and Profiler that comes with Flash Builder. There is a little more discussion of the Profiler but both of these topics are cursory at best. Also, this chapter provides sample code for unit testing Flex with the FlexUnit library. This is an absolutely essential addition.

Taken as a whole this new edition gives you good thorough coverage of the new Flex 4 and provides some sweet additions at the same time.

Those of you reading this who decided to pass on buying one of the other Flex 4 books before Flex 4 in Action made its appearance on shelves will be well served. It was worth the wait.

Hello,

I expect more out of my computer books then errors in the simple examples! We should all have higher standards.

Here are some examples, and note there is no Errata published to date. Thus, you will want this list if you are reading the book.

Page 204 mx:Script is incorrect, use fx:Script
Page 91: spark.skins.default.DefaultItemRenderer, use spark.skins.spark.DefaultItemRender
(there are two instances both in listing 4.18 and 4.19
Page 176: dg.selectedItem.email, use contactDataGrid.selectedItem.email
Page 200: Listing 10.6 first note that you need to save this as HListIRExample, having first
done a "file/new/Item Render" and filling in the listing for 10.6 (and yes rename to Canvas). Then you can try out Listing 10.7.
Page 201: Notice that Listing 10.7 is missing </s:layout>
Page 188 and 189: almost hopeless in the number of errors but here goes
- change mx.events.IndexChangedEvent to spark.events.IndexChangeEvent
- change s:SimpleText to s:Label
- change selectionChanging to changing
- change s:BitmapImage to mx:Image
images are not provided (naturally). Just create an "images" directory under your src directory. Then copy over some of your own jpgs and rename as needed.
Page 174: rename evt to Event
Page 175 rename evt.currentTarget to event.currentTarget
Page 53: the "don't wrap case blocks in curly braces - incorrect. You may wish to do this based on the scope of the variables you are using.

Many of these errors indicate that someone did not test the examples in the book. One should NEVER just retype code. Thus the design of this book is poor! What should have occurred is the code that must run somewhere (I hope) was linked directly into the text and thus the code at least in syntax correct.

Only half way through and am wondering if I am wasting my time and should just try a new book now that Flex 4.5 is out.

Over all this book is worth your time. You'll get a lot out of it when developing Flex applications. It provides in depth information on the topics it covers and it covers a lot of them. There are however some shortcomings when it comes to developing big entrprise applications.
In short:
Good book providing a strong foundation of knowledge. Missing topics addressing enterprise scale applications.
Target audience: beginners to intermediate.
Target applications: Small to medium (< 2 man year effort, < 40 screens) sized.

I'm very glad with the quality product and the good service. I found the book was brand new even I purchased the used one. Thanks a lot.

There are a bunch of Flex 4 books out there, and I spent some time evaluating them. They all garnered quite a bit of respect, so I focused on what is going to be best suited for me? I'm a freelance web server (mostly PHP) looking to add more technology choices to my customers, and in particular richer front end experiences (dashboards, analytical tools, etc...).



Flex 4 In Action makes no assumptions and starts you off with the core basics and progressively builds up your understanding of Flex as you go along, logically building up a foundation of knowledge. Near the end you're learning about the advanced stuff like MVC frameworks and test automation.



The book is easy to read, has a natural flow to it, and all of the examples are very small and easy to digest. They go into quite a bit of detail on each subject so you feel you have a strong grasp on the subject matter.



Definitely a must have if you're getting into Flex.

I've been researching Flex for awhile now, and my team was looking to introduce a more fluid experience for our web based product - and at the time of research Flex 4 was in beta. So deciding to hold off for awhile, we spent our time scoping out the Flex landscape and read up on the many Flex 3 books that were out there, but didn't want to pursue Flex 3 if Flex 4 was just around the corner.

The Flex 3 In Action version of this book look pretty promising based on the free chapters that were made available, so I pre-ordered the Flex 4 version and tinkered around with Flex to get a bit of a feel for it.

Having the book has made a huge difference. It gave me and my team a good foundation for getting started. This is a pretty heavy weight book at around 650 pages, it goes really into depth on a lot of topics. It seemed overwhelming at first, but it's actually structured in a way that makes it easy to progressively learn. For example it starts off with a very high level overview of what Flex is, what it's strengths and weaknesses are, and as each chapter progresses it builds upon the last.

As you get near the end you're learning stuff like Flex architecture, using the RobotLegs MVC framework, and how to add in unit testing.

Overall, a really great resource if you're looking to get into Flex - and a good tool if you're upgrading from Flex 3 to Flex 4 and want to learn all the stuff that's new.

This is a very practical book for learning Flex and ActionScript together based on useful examples. It covers all the key topics needed by someone interested in learning Flex 4. I consider it an essential handbook for any developer interested in understanding and applying Flex 4 in their projects.

This book enables developers to become proficient with Flex 4, overcoming typical challenges experienced after learning the basics; it helps them understand how to design their Flex applications effectively, using appropriate design patterns, frameworks, and tools. The authors really clarified throughout the book how to put various techniques together for practical solutions that are not obvious by typical reference-oriented documentation that only describes features without the context offered here.

I really liked the comprehensive coverage of all the key Flex 4 features, which effectively demonstrated these capabilities with great examples. The code examples were extremely useful, and can be easily applied to most projects. Even more importantly, the examples all worked well, with just minor errors (easily corrected).

The examples make it very easy to learn Flex technologies and understand how to utilize its broad features. They also provide a great foundation for experimenting beyond those offered in the book since they cover the wide range of capabilities offered in Flex. I liked the thorough and focusing explanations that accompanied the examples, as well as the appropriate discussions about relevant properties, methods, and events related to each tag/class.

I strongly recommend this as a book to anyone interested in learning Flex 4. It's also a key foundation for the other complementary Flex books from Manning, such as Hello Flex 4!, Flex on Java, Flexible Rails, and AIR in Action.

Having skipped Flex 3 altogether, I worried that the jump from 2 to 4 might be overwhelming. But "Flex 4 in action" starts from the basics and covers pretty much everything that was introduced in Flex 3 and Flex 4; what a relief!