#actionsctipt3

[codeorchestra-blog-blog]

Understanding Metacode - Closures and Generics - Part B

This is a second episode of a preface to using language extensions in Realaxy ActionScript Editor (RASE). In this video we'll examine some basic syntactic elements that are valid almost for all the language extensions of RASE.

[codeorchestra-blog-blog]

Public Beta Realaxy Editor 1.1 "Flashout" Is Launched

We proudly announce the first public Beta of Realaxy 1.1 "Flashout" Key features:

Flash debugger

JavaScript debugger (in progress)

Export ActionScript3 to JavaScript (in progress)

jQuery support in astojs projects

Tons of small bug-fixes

Linux version: http://s3.amazonaws.com/rase/RASE-9139-linux.tar.gz (upd. 14 mar 2012) Mac version: http://s3.amazonaws.com/rase/RASE-9139-macos.zip (upd. 14 mar 2012) Windows version: http://s3.amazonaws.com/rase/RASE-9139-win.exe  (upd. 14 mar 2012)

Find out more on YouTube.

[codeorchestra-blog-blog]

Querying And Conquering Big Collections in ActionScript3 with Realaxy Editor

A new tutorial about work with Collections in ActionScript 3 with Realaxy Editor was recently published on ActiveTuts+.

Requirements Program: Realaxy ActionScript Editor Beta 10 (build 8179+) Difficulty: Intermediate Estimated completion time: 20 min.

Intro

Good news everyone. Everybody who works with arrays and vectors - it pretty seems, all developers do it - will enjoy the new opportunities: since the late August 2011 (build 8179+), Realaxy ActionScript Editor (RASE) supports the new Collections AS3 language extension. In this post we'll tell you about its potentials.

A collection is a general term that means something like “a bunch of similarly typed objects that are grouped together”. Building a collection in ActionScript 3.0 can be done by using either arrays or vectors. They both have some makings of a perfect concept. However, if you have even a basic acquaintance with any modern and trendy language like Scala, Groovy or Ruby, you'll definitely feel the lack of a functional approach in the pure AS3-way of processing Collections.

The Collections Language

Well, let's introduce the Collections AS3 language extension that is available in RASE Beta 10, build 8177+.

A complete vocabulary of methods supplemented with samples is available here: one for lists and another one for maps (scroll them down, they are really HUGE).

In order to not get lost in this jungle, let's take a survey on some simple use case. The first true-life sample demonstrates the conciseness of a code.

We create a list, which can contain only int values.

Then peek only those that fulfil a condition (“where”).

Do something with every picked element (“select”).

Convert them to Strings (“select”).

Finally, to cycle through the list and to trace the result.

Where, select, selectMany — these operations are easy to use when you're building a query.

Operations like all, any, containsAll, contains work perfectly in conditional phrases (“if” statement, etc).

To modify a list, go ahead to use a wide range of weapons — remove, removeAll, removeWhere, removeHead, removeTail, etc.

For those persons who definitely have an eye for perversion :D we have prepared a bunch of operations like foldLeft/foldRight, reduceLeft/reduceRight, intersect, etc.

Simply said, there are a plenty of various operations suited to every fancy and almost every task. In some operations you just transmit one or more values to it, in some other ones you add a closure.

Read and discuss the full article on ActiveTuts+.

[codeorchestra-blog-blog]

Logging Language in Realaxy Editor

Aims and objectives of language

Logging of applications is widely used as alternative or succession for using debugger. The most common of using debugger is to dip into a code execution, meanwhile sometimes it is really useful to get some signals from the code.

This article tells about the Logging language, a built-in debugging tool of Realaxy ActionScript Editor (RASE). The basic operator of this language extension is trace, just like trace in the pure AS3. Nevertheless, the capabilities of this tool were dramatically redesigned and improved.

Basically, the Logging language has 7 main features that are uncovered in this post:

1. It is built-in and closely integrated with RASE

2. It provides a number of simple and powerful tricks to automate your routine actions, such as:

Message numbering

Different verbosity levels

Tabs for different groups of messages

Indents to stress some lines

1. Integration with IDE

The Logging language automatically appears in every newly created project of Realaxy Editor as a substitution of basic functionality of ActionScript 3 (it refers to the trace operator only).

For instance, if we’ll create a new Main() class and try to type a new trace expression, the autocomplete menu will show you that it is not really pure AS3.

Note for the curious people: if you remove com.realaxy.actionScript.logging from Module Properties, the same autocomplete menu will look like that:

A trivial logging in AS3 works as follows:

import flash.display.Sprite;  public class Main extends Sprite {   // fields ------------------------------------ /   private var a : int = 42 ;   private var b : String = "All work and no play makes Jack a dull boy" ;   // constructor ------------------------------- /   public function Main( ){       trace("a = ", a, ", b = ", b);      }  }

Looks pretty familiar, isn't it? Let's look upon what’s new in the Logging language extension.

2. Routine procedures automation

Well, let’s describe the sample from the paragraph above with the Logging language:

You can see, there are two alternatives, one with a simple syntax and the other one a little more advanced.

Just for understanding: at the time of the trace completion, your Flash-application and the editor use sockets to communicate with each other. Since Realaxy Editor is an open source software, you can also examine a LoggingUtil class to understand how it works “under the hood”.

The result appears in the Messages window in the lower left corner of the IDE.

As we could see above, the trace values (...) statement allows developers not wasting time on formatting the output. Meanwhile, it's the thin end of the wedge. Besides the values keyword, the trace syntax allows utilize also many other parameters. For instance, the statement trace package, class, method, args, values(a, myField) will not output only values of a and myField but will also supply a lot of useful debugging information.

3. Messages Numbering

The trace statement syntax also provides an easy numbering for the messages (by the way, you can use variables instead of numbers, like on screenshot below):  

The output will be the next:

4. Verbosity level

The Logging language offers the 6 different verbosity levels. All of them you can find in autocompletion menu (or on a screenshot below):

Frankly speaking, only three positions from six ones are of a general interest for an end-user: trace, error and warn.

Message with different verbosity appear in different ways on the Messages screen.

It bears mentioning one small but very useful editor’s feature: when you click on any line in the Messages window, you will jump to the trace statement that has thrown that message. For a wonder it’s really hard to find a modern IDE with such a behavior.

5. Tabs for different groups of messages

Sometimes it is useful to sort messages, specifically if trace is used many times. It is done as follows: Select the whole trace statement and call the Surround with... menu (Ctrl-Alt-T). Select the log-scope item:

  A new log-scope expression will appear. Then enter our new tab’s name:

Well, it’s done. Since now all the messages from the indicated scope will appear automatically in the new tab.

Of course, each scope may contain unlimited number of trace statements.

6. Indenting log messages

In other circumstances you may need to emphasize some messages unassumingly. It can be done with a log-indent functionality, which is quite similar to the log-scope mentioned in the previous paragraph. Select any number of trace statements and pick the log-indent item from the same Surround with... menu:

It is easy to imagine the resulting output: the two lines in the middle will be printed with one-symbol indent.

[codeorchestra-blog-blog]

A New Functional Way Of Working With Collections In ActionScript3 using Realaxy Editor

Intro

Nearly every application you ever write uses collections. Work with collections can be called a basic routine activity that takes up to 60-80% of your time as long as you deal with algorithms. A collection is a general term that means something like “a bunch of similarly typed objects that are grouped together”. AS3, which is a modern language like any other, also provides a lot of convenient tools (like loops, sophisticated collections API, sorting, etc) to process collections. The only trouble is the lack of a functional approach that is so common for modern and trendy languages, such as Scala, Groovy or Ruby.

Requirements

Program: Realaxy ActionScript Editor (RASE) Beta 10 (build 8177+) Difficulty: Intermediate Estimated time: 7-12 minutes

The old-school classics: Arrays and Vectors

Generally, building a collection in ActionScript 3.0 can be done by using either arrays or vectors. They both have some makings of a perfect collection concept except none of them are ideal.

The principal trouble with arrays is that ActionScript does not currently support typed arrays - a single array may contain both primitives and objects, for example.

That means, every time you use an array in AS3, you need always take care of it introducing rules for each situation:

If you forget to set these rules, an item from AS3 array can do nothing on its own. Just compare the autocomplete capabilities between an Array item and a String:

Another opportunity to organize your data collections with ActionScript is the using of Vectors. This class was introduced since AS3 and Flash Player 10. Vector is an array whose elements all have the same data type. The base type can be any class, including built in classes and custom classes. The base type is specified when declaring a Vector variable as well as when creating an instance by calling the class constructor.

Another advanage of Vectors: array element access and iteration are much faster when using a Vector instance than when using an Array.

Nevertheless, if you have even a small experience with modern functional languages, you will find AS3 potential of working with collections very limited.

Collections Language

Well, let's introduce the Collections AS3 language extension that is available in RASE Beta 10, build 8177+.

The complete vocabulary of methods with samples is available here: one for lists and another one for maps (scroll them down, they are really HUGE).

In order to not get lost in this jungle, let's take a survey on some simple use case. The first true-life sample demonstrates the conciseness of a code.

We create a list, which can contain only int values.

Then peek only those that fulfil a condition ("where").

Do something with every picked element ("select").

Convert them to Strings ("select").

Finally, to cycle through the list and to trace the result.

Where, select, selectMany — these operations are easy to use when you're building a query.

Operations like all, any, containsAll, contains work perfectly in conditional phrases (“if” statement, etc).

To modify a list, go ahead to use a wide range of weapons — remove, removeAll, removeWhere, removeHead, removeTail, etc.

For those who definitely have an eye for perversion :D we have prepared a bunch of operations like foldLeft/foldRight, reduceLeft/reduceRight, intersect, etc.

Simply said, there are a plenty of various operations suited to every fancy and almost every task. In some operations you just transmit one or more values to it, in some other ones you add a closure.

Closures

A closure is, in fact, the same anonymous function, but with a number of small differences.

First, a Closure has a very concise syntax. Parameters don't have a type declaration (to be more exact, they have it, but such declarations are hidden). A Closure has a special behavior "the last statement is a return value". In actual fact, use "1;" (in the last line) instead of "return 1;"

Second, it has a special view for single-line closures (they outnumber) — in such a closure a semi-colon on the end is hidden (for two reasons, readability and brevity).

In distinction from an anonymous function (and also as a counter to the mentioned Arrays and Vectors), the closure is type safe. That means, either autocomplete or type-check are working in closures.

To conclude, a Closure is a kind of function on steroids. It has a lot of tasty features and helps us to write everything quick and concise.

Lists and Maps

Collection language is intentionally simplified. It supports two types, a List and a Map. Map is quite similar to a trivial Dictionary that holds some useful methods — keys, values, containsKey, containsValue (useful for checks and conditions), pushMap (to merge values), removeKey, removeValue, etc.

Maps are smart and fail-safe. You can't add a wrong key or value:

Maps work well with any lists and queries.

There are also conversion operations that can be utilized to facilitate embedding the new Collections extensions to your actual pure-ActionScript project. Just take a trivial array (or vector) and apply .toList operation. After processing a list (or a map) you can always convert it back to the old-school AS3 style using .toArray or .toVector operations.

Instead of Conclusion

The new Collections language extension allows you:

to improve your AS3 code making it more concise

to make your code more human-readable

to facilitate turning your sequential code into parallel.