After the failure of a wannabe Facebook-killer, Buzz and Orkut platform in apparent hiatus, Google seems to have finally found a simple yet potentially deadly effective way to rule the social network business. Or at least to compete with the current ruler on an even footing.

Mashable, among many other sites, reveals the search engine giant’s plans to unify its popular and widely used applications under the common brand, with Picasa becoming Google Photos and Blogger rebranded as Google Blogs. This looks like a first step to amalgamate these two (along with other Google apps) into the recently-announced social network platform, Google+.

Along with a closed beta period (practically serving as a now-classic strategy of invitation-only registration), which is already creating enough, erm, buzz to kickstart the whole operation after the test phase (or feel-like-a-VIP phase) is complete, there seems to be an apparent intention to basically force current users of Picasa and Blogger into joining Google Plus and use it actively – and we’re probably talking large numbers^*. This corresponds with the recent small steps, such as an option to merge your Picasa Web Albums into Google Profile (which are now expected to be replaced by Google+ profiles).

Looks like the only thing needed from a general social networking site – apart from a functionality that rivals Facebook’s (which, by the way isn’t anything spectacular when it comes to Google+ features) – is to gather a critical mass of registrations and traffic that will cause a steady flow of  users from a dominant platform to a contender. The strategy described above aims mainly, if not solely, at that.

On a side note, someone has obviously missed a good moment to enter the scene while the Facebook hype is in the decline. Diaspora guys, with their app still unable to come out of the alpha, should take notice. Ona a side-side note, I bet institutions such as European Commission WILL take notice of this very… microsoftish move.

*unfortunately, I was unable to find a current information regarding user base

The day before a friend of mine retweeted a post by Martin Pilkington, an iOS/OSX developer:

You say “Android is dominating, Apple is doomed” I hear “I have no idea what profit is, nor how it relates to business” (status)

I recalled a few times I had expressed a mild “Android>iOS” stance and I took it rather personally, but then again I realised that never had I meant anything like “if I were to develop and market a mobile application, I’d go straight for Android and never release it for iPhone because <insert generic antipragmatic reasoning here>“. I can hardly imagine anyone in the sofware development business say (and really mean) that. That said, I think someone is having a hearing problem.

Of course, I can’t speak for anyone but myself, but I strongly believe that most of the serious Apple critics (because, ultimately, this is an Apple vs. the world discussion – forget Android for a while) share, to some extent, a similar point of view:

This isn’t about numbers, current market shares and current possibilites of revenue from design and development for certain platforms, you can’t deny the facts. What I mean when saying “Apple is going down” is a certain feeling of impeding trend reversal, a change in a trendsetting consumer’s consciousness that will eventually shape the market.

This is not based on hard facts, tech specs, sales numbers, etc., just as around and after 2000, as a fresh Amiga-to-PC convert I began to take interest in Apple products because they evoked a certain feeling of independence and geeky sentimentalism that made me stick to Amiga for so long – and a certain hunch that the same thing will appeal to a lot more people. And then came the deadly effective “I’m a Mac, he’s a PC” marketing campaign, cue Jaws theme music. Apple began to shape its core user base which eventually evolved into a twisted version of what I expected it to be, the Apple Store controversies began (to me, de facto being an attempt at establishing a monopoly and a censorship institution), the stance on open source vs. proprietary came to light, etc. – the criticizm is well known and repeated ad nauseam. But its growth can’t go unnoticed with websites and blogs (PL) springing up and Apple products becoming attributes of certain social groups widely considered loathsome.

Back in the day, Apple inspired all the positive ideas mentioned above and seemed like a great alternative to PC/Microsoft combo with its frightening market share. Now, not much of it is left, the bright sides being slowly replaced by an image of technology-illiterate fanboy machine-fed with Apple products. Semiotics change over time – what was once an epitome of edginess and forward-thinking may soon become the new uncool. I firmly believe that this is something that is going to happen to Apple – sooner than some might think. And if I’m right, in a few years we won’t be talking beliefs, personal reception etc. – we’ll be talking business.

Call it a fishful thinking, I call it a wind of change ;)

If you’re just as frustrated with the lack of a good OS-X IDE for both Flash/Flex and general web development (or tired of Eclipse) as I am, chances are, that in your attempts to find one you may have come across NetBeans. Despite being written in Java, it’s much less bloated and much snappier than Eclipse – still, it provides a rich feature set, a flexible plugin architecture with huge database and active community.

Unfortunately, there is still no serious support for ActionScript development. Sourceforge hosts a plugin project called FlexBean (seemingly abandoned), but all it delivers is basic MXML templating and project make support (through Ant). You can read about its installation and setup here.

If you intend to use it for AS projects, the biggest culprit is the lack of syntax highlighting and code formatting (not to mention code completion) which makes editing sources in NetBeans a real pain in the ass. But given the fact that ActionScript and JavaScript share the same ECMAScript-262 specs, you can open an .as file as a JS script – this way you can get basic code highlighting and formatting. To do that, right/command click an .as file in the project pane and select ‘Open As..’, then select text/javascript MIME type from the list. This will create a file association which you can later edit or delete under Preferences/Miscellaneous/Files.

One thing I haven’t really sorted out yet is the massive amount of syntax validation errors. As far as I know, you can’t turn them off or selectively disable. I suppose these result from the fact that AS3 extensively uses keywords and language contructs from newer version of ECMAScript specs, not included in the JS binding or those specific to AS3.

The above cited warning message kept showing up while I was trying to set up a data binding between a customized component (extending Canvas component class) and a simple text field. 99% of application’s code was placed out of the main (and only) MXML file – let’s call it a front controller. Its role was to provide a few general GUI controls and act as a simple auxiliary mediator between the model (centered around a loaded XML document) and a complex UI component.

Here’s a test case (overtly simplified for the sake of argument):

Main MXML document:

<?xml version="1.0" encoding="utf-8"?>
<glearn:GLearnApplication>
	<graph:Graph id="graph" width="100%" height="100%"  />
	<graph:NodeInspector id="nodeinspector">
		<mx:TextInput id="nodeName" text="{ graph.selectedEntity.resource.toString() }"/>
	</graph:NodeInspector>
</glearn:GLearnApplication>

(Notice the application’s class.)

Graph class:

package pl.greymatter.glearn.graph
{
    import mx.containers.Canvas;
    import mx.core.UIComponent;
    import mx.events.PropertyChangeEvent;
    // ... more imports

    public class Graph extends Canvas {

        private var _selectedEntity:GraphEntity;
        public function Graph():void {
            // contructor
            // property change is triggered by this event - checked, works
            addEventListener(GraphEntityEvent.SELECT, objectSelectedHandler);
        }

        public function objectSelectedHandler(e:GraphEntityEvent):void
        {
            selectedEntity = e.entity;
        }

       [Bindable(event="propertyChange")]
           public function get selectedEntity():GraphEntity {
           return this._selectedEntity;
       }

       public function set selectedEntity(val:GraphEntity):void {
           if (_selectedEntity !== val)
           {
               var oldSelection:GraphEntity = _selectedEntity;
               _selectedEntity = val;
               dispatchEvent(PropertyChangeEvent.createUpdateEvent(this, "selectedEntity", oldSelection, val));
           }
       }
    }
}

All things were set up according to Adobe’s guidelines, including [Binding] metatag and whatnot, but the following warning still popped up:

[exec] /Users/optik/Work/swlearn/pl/greymatter/glearn/glearn.mxml(56): Warning: Data binding will not be able to detect assignments to "graph".

…and the property change wasn’t reflected in the component bound to it.

Cause of the problem & the solution

Some testing and backtracking led me to believe that the source of this problem was in a way the Graph instance reference was being stored. Checking GLearnApplication class, I recalled that I explicitly declared “graph” property (a reference to Graph component) – a reflection of the tag in the MXML file.

Adding [Bindable] before the declaration solved the problem.

The code:

package pl.greymatter.glearn
{
    import mx.core.Application;
    public class GLearnApplication extends Application
    {
        [Bindable]  // this was initially missing
        public var graph:Graph; // this reflects <graph:Graph id="graph" /> and is required to reference "graph" inside GLearnApplication class methods
 // ....

The point of this story: it seems that using MXML component tags does all the data binding job, as long as you keep things simple. If you mess around with components’ declarations, be prepared for problems with data binding and make sure all the required variables/properties are meta-tagged as “Bindable”.