Falcon 0.8.8 (Blue Jay)

The download section hosts the Falcon 0.8.8 release (Blue Jay).

Join now the community by joining the forum, or come visiting us at irc://irc.freenode.net/#falconpl (NOTICE: You need an IRC client or an adequate IRC plugin for your browser to open this link).

What is Falcon?

The Falcon Programming Language is an Open Source general purpose untyped language, based on a Virtual Machine executing portable pseudo codes (a class of languages nowadays known as Scripting Languages, and counting Python, PERL, PHP, Ruby and LUA among them), completely written in C++.

A fast introduction to the language can be found in the Showdown document. A more technical document, covering the main features of the language, the engine, the development and the embedding model is the "What's different" guide.

Falcon differentiates from all other scripting languages because it has been developed with a series of goals in its design since the first program line had been placed:

• Simple but elegant grammar
• Extremely fast Virtual Machine
• Easily embeddable in any kind of application
• Easily extensible and maintainable
• Fully multiplatform
• Completely internationalized

All those goals have been been reached through constant commitment into carving those aspects out of the code.

Simple but elegant grammar

For a programming language to be useful, its first requirement is that the grammar through which it can be expressed comes natural for the users, easy to learn and to read. But it is also necessary that, despise this, the grammar is capable to express a wide range of concepts and to perform meaningful operations with a minimal set of instructions.

Falcon reduces the distance between useful, meaningful constructs and written symbols to the minimum, avoiding the use of any unnecessary token to express the concepts. The care for the user/programmer has been a primary concern of the developers; in example, exceptional effort has been put into avoiding any kind of variable declaration (which are automatically declared at their definition), the elimination of the "statement terminator" (usually a semicolon in many languages), and the banishment of the brackets.

Although many aspects of this design may seem trivial and unimportant, some choices that have been adopted in Falcon greatly reduce the effort and strain of users/programmers in many contexts. In example even if every programmer without direct access to the brackets has her own favorite keystore to evoke them in her own favorite development platform, Falcon is thought to be embeddable in any application, for how simple it may be; that application may provide an internal editor to configure its own scripts, and the editing support it provides may not be the best programmer-wise text editor available. Actually, this idiosyncrasy has really happened in several applications: Blender internal Python editing and UnrealEd for internal Unreal Script editing being just two examples; palmtop configuration and maintenance scripts being another.

But Falcon takes care of the users/programmers past and beyond its simple layout. Singleton objects, simple class definition, lambda functions and other advanced object oriented and functional language features provide the developers with an unmatched simplicity in working with complex constructs; other advanced features of the language are the ability to dynamically transform functions into object methods, the recording of methods into variables for later summoning and the tracking of the "sender" object, that allow access to the object that summoned a method in another object.

Falcon integrates also coroutines (short for cooperative parallel routines) support in its Virtual Machine, allowing extremely simple parallel programming paradigms to be embedded into simple scripts. This light parallelism is exceptionally useful when writing system utilities as process monitors, or when providing the user with some interface while some processing is taking place.

All this is presented to the user/programmer with a extremely simple and coherent grammar; once a Falcon construct is learned it is never forgotten, and all the other constructs come natural and easy for the student. This has three immediate advantages over languages with various special grammar constructs:

• When an embedding application instructs power users about the internal scripting language, i.e. from an on-line guide or from within the embedding application manual, there will be less misunderstanding and less needs for voluminous amount of documentation; both this aspects leads to less user support requirements, and ultimately to cost and perceived quality advantages.
• When adopting Falcon in a production environment, in example as the default scripting system for system mantenance, the learning curve of the personnel is steep; this both while learning Falcon to build the scripts and learning how the scripts are organized and how to maintain/extend them when the personnel is physiologically turned over. Again, this impacts on the TCO of the Informative System.
• When teaching the language to students, they will concentrate on learning how to program instead of how to tell the language what to do. This makes Falcon an ideal language to be used as a support to teach programming logics and concepts to whose students that are exposed to programming for the first time.

Extremely fast Virtual Machine

A primary requirement for Falcon has been to be a valid alternative for:

• other forms of evolved dynamic configurability for complex embedding applications;
• other forms of stand-alone scripting for system maintenance and generic programming.

For this reason, the Falcon Virtual Machine has been designed the fastest and most efficient possible, considering the untyped nature of the scripting language.

A primary concern for the developers has been that of making Falcon scripting a viable alternative to writing C programs for system management, mantenance, text analysis and file manipulation and in general for the class of applications called "dirty work" in the IT jargon. At the same time, Falcon scripting had to be a consistent alternative to writing extremely configurable highly variable embedding application engines; games AI support being one example, heterogeneous database management being another.

Although the development of Falcon has not yet reached its most advanced phase, where the most important optimizations will be performed, the internal engine and the Virtual Machine have been benchmarked against other scripting languages resulting always winning by a large margin, often by orders of magnitude.

The small footprint of the memory instance of Falcon Virtual Machine and items and the performance of the internal engine are a solid base to consider Falcon scripting as an option to drive complex and demanding applications, as the ones found in the gaming industries or business intelligence industries, especially if compared against the costs and times needed to develop a solution with a similar flexibility level internally.

Easily embeddable in any kind of application

The fact that Falcon were thought to be an application driver scripting language as well as a stand-alone language leaded to the development of a very simple and natural API for embedding application, where they can control every aspect of the Falcon program execution with simple implementation choices.

The most important problems of embedding a scripting language in an application is not bound to the complexity of its API, although this may have a relevant impact on the implementation times and costs; the most problematic issues are:

• to shape the power of the scripts, and of the application users, on the specific needs of the application;
• to provide a simple but safe interface between the application and the scripting language;
• to avoid application redesign or heavy projects requirements/limits when deciding to use the scripting engine.

About the first point, shaping down the power of the script users it's often an undeniable necessity, when i.e. the application can receive and interpret foreign scripts. This has been a primary concern in the design of important scripting languages as JavaScript. Those languages that integrates powerful features in their basic constructs, as the open/pipe redirection used by PERL to open files and processes with the same construct, or the Virtual Machine special treatment of file objects in Python, makes them unsuitable to drive applications that may require to impose hard limits on the script capabilities, unless some kind of hacking in the language code is performed in this direction.

There may also be complex cases where some part of the processing would require the scripting engine to access system level services, while other parts require security and isolation. In such case it wouldn't be quite enough to mangle the scripting language features, tearing them off or on; a deeper redesign of some crucial aspects may be needed.

Falcon provides the embedding application with the ability to control every aspect of the script execution by putting all the basic features that are not directly tied with the Virtual Machine execution into separate modules. The rules by which those modules are loaded can be provided by the application on a per-VM basis, allowing some privileged VM to access all the needed functionalities and other to just run the modules that are provided by the application. It is even possible to intercept the request of any module loading and providing the requesting scripts with an application-specialized version of one or more of the module functionalities.

Falcon allows also to control explicitly the limits of resources that any script can require: stack size, dynamic memory, coroutines, variable number and executed instructions can all be limited to prevent less privileged scripts to take away significant portions of the application computational power.

About providing a simple interface between the application and the scripting language, Falcon puts at the embedder disposal a very simple API that allows to create new Falcon functions, classes and objects which can be accessed directly by the scripts. There is also the possibility to create "opaque" objects that can be manipulated by the scripts only by using the application provided functions, preventing in this way the possibility that the scripts can misuse the application data.

Finally, Falcon is able to run the scripts using just one instance of the Virtual Machine, which is a closed and self-contained object. In this way, it is possible to frame script execution in any existing application, regardless of its architecture. Multithreading and multiprocess applications do not need any special processing or requirements to be able to integrate the Falcon Virtual Machine. Even applications providing their own specialized memory model can instruct Falcon to use the memory they provide.

Easily extensible and maintainable

Falcon scripts can integrate functions and classes coming from external loadable modules written in C++ using the Falcon Module API. A falcon script can also become itself a self-contained module, which can be loaded by other scripts. So, it is possible to mix seamlessly C++ extensions and Falcon extensions. This open model allows to change existing modules with different ones providing the same interface. In example, it is possible to create a first version of a module directly in Falcon, and when the interface becomes crystallized it may be rewritten in C++ to improve its performances. The applications and scripts that have been written in the meanwhile don't even need recompilation; they will just use the new module version.

Fully multiplatform

Falcon is multiplatform by design. Its constructs and the structure of the standard system API is made so that scripts can use generic concepts that are then "rendered" on the specific platform they are operating on. This does not prevents the existence of system-specific modules that may exploit some system peculiarities, but creates a solid common base that may be used by scripts needing to run the same way on different platforms.

Completely internationalized

Falcon compiler and internal string management are fully Unicode aware. They support a wide series of encodings, including iso8859-x tables, as well as UTF-8 and UTF16 both as encoding for source files and as transcoding capabilities for text management.

The support of Unicode characters extends into symbol recognition, that can now be written using any Unicode character. Object properties and methods, funciton names and variables can be named in the native user language, be it English, some Neo-latin accented language, Arabian, Ebraic, Chinese, Japanese, Hindi or any other known language.

Of course, this means that any Unicode character can be employed directly in strings, and that the language itself provides support for international characters in system interfaces (i.e. file and directory access) and in modules (i.e. regular expressions).