This drives keyboard-heavy users (like me) crazy. However, it turns out that there is a way to dismiss this dialog from the key:

Type Shift+Return instead of Return.

There is, in fact, a good reason why this dialog has a multi-line edit box. As explained in this Eclipse bug, some languages (including Java) allow you to enter more than just a simple expression into this box. And since the dialog comes from Eclipse’s code rather than from Flex Builder’s, we can’t just change it to have a single line.

Since this is such a common point of frustration for Flex Builder users, in the above-linked bug I have asked that they find some way to make this easier for people to deal with, e.g. by perhaps having a short message in the dialog mentioning Shift+Return. But in any case, you now know the secret handshake — enjoy!

The code:

package {
    import flash.display.*
    import flash.text.*

    public class AprilFools extends Sprite {
        エイプリルフール var Number = 4..toString()

        use namespace エイプリルフール

        function AprilFools()
        {
            get = set
            set = get

            with (createTextField())
                text = new Date(Number).toDateString()
        }

        function get get() { return Number + <><{Number}
            b={"/"+Number.split(/\//)[0]*502.25}/></>..@b }
        function set get(set) { Number = set+'/'+set/4 }

        function get set() { return Number }
        function set set(get) { Number = get }

        // nothing fun here
        function createTextField():TextField
        {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            var textField:TextField = new TextField();
            textField.width = 1000;
            addChild(textField);
            return textField;
        }
    }
}

namespace エイプリルフール

The program’s weak spot is creativity in terms of what it actually does — just some static text output. Pretty pathetic really. All my effort went into the ActionScript. Click here to see the result. It’s probably not worth the effort to try to figure out what it does before running it; that’s not really the fun part. The fun part is trying to figure out why the heck the thing compiles at all; what the individual lines of code actually mean; and what sick features of the language I am taking advantage of. Tell me what you find.

Even if you aren’t the kind of person who uses the scroll wheel on your mouse or two-finger scroll on your trackpad, please do it.

If you do, you will make some of your users very very happy.

mxmlc and compc have a -dump-config option to dump all settings to a file. Later, the settings in that file can be read back in with -load-config.

So, do this:

• In Flex Builder, do Project Properties
• Click the “Flex Compiler” tab
• In the “Additional compiler arguments” box, add “-dump-config full-path-to-output-file“. For example, on Windows, “-dump-config C:\myconfig.xml”; on Mac, “-dump-config /Users/myname/myconfig.xml”. (If you use a relative path, the file will be put in some odd hard-to-find place.)
• Click OK.  If Build Automatically is on, just clicking OK will cause the file to be built; if it is off, do a build now.
• Now that the settings have been dumped, go back to your project settings and remove the -dump-config option.
• Tweak the settings file as necessary (one thing you will almost certainly want to do is change <debug>true</debug> to <debug>false</debug> if your nightly build is supposed to do a release build), and use it in your nightly build script.

Please be aware that this only captures compiler settings; it doesn’t capture all the other little things that Flex Builder does for you, like compiling Flex library projects that your project depends on, copying non-embedded assets to the output directory, optimizing modules for the application, extracting RSLs, copying the HTML template, and so on.

More info here. Please read that, it has additional info you will probably need.

I typed Donner, as in Donner Pass.  The iPhone “corrected” that to Dinner.

Um, yeah, that’s appropriate.

(I’m also sick of the iPhone changing its to it’s.  Its spell checker doesn’t know what it’s doing!)

Any other funny ones?

A variation of that happened to me just today.  I decided to try Yahoo Chess (and I’m proud to say I won my game).  You enter a room, e.g. the beginner room, and then there is a list of tables; you click to join a particular table.  But every few seconds, the list of tables keeps refreshing, so the button you were about to click could have suddenly disappeared — or worse, turned into a button for a different table you didn’t intend to join.

What’s interesting to me (I don’t know why, maybe because I’m a geek) is that this is a real-life version (if using the computer is considered real life) of the sort of race condition horribleness we all run into when we write multithreaded code. Thread 1 tries to increment a variable, but oops, thread 2 sneaks in there and changes it!  Urgh.

Does this ever come up in real real life (as opposed to real life while using a computer)?  Yes, of course — one good example is the awkward little dance we all do once in a while when trying to walk past someone else who is coming the other way. Both step to the right, oops, both step to the left, oops!

In the case of computer UI, I can think of two ways to alleviate this problem (I am not claiming any incredible insight here, I think these are pretty obvious):

1. Animation can help. E.g. in the example of the Yahoo Chess list of tables, when the list redraws, rather than having it redraw instantly as it does now, maybe the individual rows of the list should slide to their new positions.  That gives a person’s eye the visual feedback, “Wait, don’t click just now.”  Animation is sort of the computer equivalent of what usually helps avoid this problem in real-life scenarios: Most of the time, the fact that you can see the other person moving and adapt to their movement gives your brain enough time to avoid a collision.
2. Maybe disable the mouse (and keyboard if appropriate) for a fraction of a second, e.g. maybe 1/4 second, immediately after a change, e.g. immediately after the list of chess tables was updated, or immediately after a program opens a new window or dialog.

Of course, it would often be appropriate to combine both of those techniques: disable the mouse, do the animation, and then re-enable the mouse.  If done that way, the mouse could be immediately re-enabled when the animation was done — no need to wait for 1/4 second more after the animation is done, because the person has already had sufficient time to process what is happening and avoid an accidental click.

What do you think?  I’m sure none of this is terribly original — I imagine lots of research on this topic has been done.  I just haven’t come across it.  (Sometimes blogging scares me, because the Internet is so huge that no matter how original a particular thought of mine might be, the odds are extremely good that someone else has already had it, and has said it on the Internet, and thus it’s already in the Google index, and so should I really bother.  Reminds me of a joke that A. Whitney Brown made many many years ago in Saturday Night Live: “There are a billion people in China.  Think about that.  That means if you’re a one-in-a-million kind of guy, there are a thousand other people exactly like you.”)

So here it is. This ZIP file contains two projects:

• MyLibrary is the main interesting part. It contains design.xml, a Flex manifest, and a sample component. See the slides (linked above) for an explanation of how all this stuff hooks together.
• MyFlexProject is just a simple Flex Project that has MyLibrary on its library path, so that you can see that when you open the Flex project’s main app in design view, the library’s Calculator component shows up in the “Mike’s stuff” folder of the Components view (as opposed to the default, the “Custom” folder), and that if you click on the calculator that is already in the document, the list of properties in the Properties view has been customized, with the “Layout:” property showing up there.

To reiterate, the sample by itself isn’t quite enough — you really need to see the slides (starting at slide #23) to understand the context. And, I will soon be writing an Adobe Developer Center article with much more detail.

Also, David posted the sample code for tomorrow’s talk. See his post here.

Conditional breakpoints

Suppose you have set a breakpoint, but that line of code is reached hundreds of times, and you only care about the case where a variable 'x' is unexpectedly equal to null.  Just right-click on the breakpoint, go to its properties, and add the condition:

For some extra breakpointy goodness, you can also set a hit count on any breakpoint -- e.g. a hit count of 5 means, don't halt until the fifth time that line of code is reached.

Awesome new expression evaluator: function calls, E4X, regular expressions, etc.

Going along with conditional breakpoints is a vastly improved expression evaluator.  It is used when evaluating conditional breakpoints, in the Expressions view, and in debugger tooltips.

For one thing, you can now make function calls directly from the Expressions view (as well as from conditional breakpoints):

mystr.indexOf("test")

Also, regular expressions and E4X expressions can be quite tricky to debug; with the new expression evaluator, you can just type them into the Expressions view and immediately see the value.  (The one exception is you can't use E4X filter expressions such as "myxmlvar.(@id=='3')".)  For example, suppose "customers" is an XML object -- you can do expressions like these in the Expressions view:

myCustomersXML.customer.@name
myCustomersXML..zipCode
myCustomersXML.customer[0].@name

Here is a regular-expression example that you could put in the Expressions view or a breakpoint condition:

mystr.match( /[0-9]+/ig )

You can use the ternary ( ?: ) operator:

mystr.length>=3 ? mystr.charAt(2) : "too short"

You can use the "is" operator (this is especially useful in conditional breakpoints):

obj is String

The possibilities are limitless. ===, !==, string concatenation, etc. -- almost any other ActionScript expression you can think of, you can put it in the Expressions view or a breakpoint condition.

Watchpoints

Watchpoints tell the debugger to immediately halt when the value of a particular variable changes. Suppose you have a variable whose value keeps changing out from under you, and you can't figure out who is changing it. With a watchpoint, it's trivial -- just set the watchpoint and run your code.

(Flex Builder watchpoints are set on a particular instance of a variable. For example, you set a watchpoint on the _width field of a button "myButton", not on the _width field of all Buttons.)

Exception breakpoints

The debugger always halts immediately whenever there is an uncaught exception. But sometimes, you want the debugger to halt even on an exception that is going to be caught by a try/catch block in your code.

That's what exception breakpoints will let you do. You will be able to say, for example, "Always halt in the debugger whenever a TypeError is thrown, even if it is going to be caught."

Run to line

A minor feature but still quite nice to have: Run to Line (Cmd+R on Mac, Ctrl+R on Windows) is a quick way to set a temporary breakpoint on the current line, then run until you get there, and then automatically clear the temporary breakpoint.

Network monitor

A major addition, this allows you to easily see the network traffic that is going back and forth between your app's front end and its back end.

Click for a closer view:

The topics we'll be covering are:

• The Code Model.  David will give this portion of the talk. The Code Model is an API that lets you programmatically browse and modify the set of ActionScript classes, functions, etc. that are in the user's code.
• The Design Model.  This is another API that lets you programmatically browse and modify the MXML portions of the user's code.
• If you write your own SWC (Flex library project) and want to customize how it shows up in the Components view when you give the SWC to another user, and also how it appears in the Properties view when they have an instance of your component selected in design view, you can add a file called design.xml to your SWC.
• If we have time, we'll also give a very brief introduction to writing Eclipse plug-ins, which is necessary if you are going to be using the Code Model and the Design Model.  Not sure if there will be time for this, because there is so much other stuff we're trying to squeeze in.