Funky

Funky is High-Quality Software

Funky has an excellent track record for quality: it is being used around the world in high-speed applications, in which it takes accept-or-reject decisions more than a quarter of a million times a day.

Funky is thoroughly tested before it is released "into the field" using automated unit tests to check that all the scripts work as expected.

Supported platforms include Windows XP, Windows Vista, Linux, *BSD and other UNIX flavours. The C++ code is platform-independent and help is available to port it to other platforms, if necessary.

History

So far, no bugs have been found in the field, and that is not for lack of use! That is because we test our software thoroughly and it uses, as external libraries, only Boost, "one of the most highly regarded and expertly designed C++ library projects in the world" (Herb Sutter and Andrei Alexandrescu, C++ Coding Standards). As a coding standard, we use the High-Integrity C++ Coding Manual and Herb Sutter and Andrei Alexandrescu's C++ Coding Standards.

Indicators of Quality

The indicators of quality we are most interested in at Vlinder Software are those pertaining Functionality, Reliability, Usability, Efficiency, Maintainability and Portability.

Functionality

In order to be functional, Funky must be suitable for its purposes - which is rendering applications scriptable and allowing for persistent predicates to be configured for such applications. It must accurately interpret scripts provided to it, which implies that it must be relatively easy to write scripts. It must be interoperable in that two different instances or versions of Funky should interpret the same script in the same way. it must be compliant to applicable standards and it must be secure.

suitability	Funky's grammar is small and unambiguous, which makes it easy to learn; integrating Funky is very easy (create an instance of a single class); you can install your own functions in the interpreter;
accuracy	because of Funky's unambiguous grammar, errors are quickly diagnosed by the interpreter and accurately reported; because you can define your own functions, you decide what the interpreter does: the "dictionary" grows as you develop; Funky only provides a few primitive operations that are very well-defined - the semantics of most functions are defined by you;
interoperability	since its inception, a few rules have been added to the grammar, but none have been removed; any script that was valid with the first versions of Funky is still valid today; the floating-point dialect can interpret any script the integer dialect can interpret and produces the same results; the scalar dialect can interpret any script the integer or floating-point dialects can interpret, and produces the same results;
compliance	Funky is a purely functional programming language
security	Funky scripts do not maintain their own state nor do they handle user input, perform I/O operations, etc.: all that is handled by functions you will have to install yourself; Neither does Funky use any runtime variables other than the parameters to the script.

Reliability

In order to achieve highly reliable software, we test it extensively. Funky has over 140 unit tests and that number keeps growing. We measure its reliability by its maturirty, its capacity to recover from errors and its tolerance to fault conditions.

maturity	Funky has been in use since 2007; Funky has a proven track-record, unblemished by bugs; Funky's interpreter has a simple but elegant design;
recoverability	parse errors in Funky scripts cause an exception to be raised, but leave the interpreter in a usable state; run-time errors in functions called by Funky scripts cause an exception to be raised, but do not alter the interpreter's state;
fault tolerance	every instance of the interpreter is independant of every other instance; script execution (evaluation) is a read-only operation on the interpreter;

Usability

In order to be useful, software has to be usable, meaning it should be easy to learn, easy to understand and easy to operate.

learnability	the language has a simple grammar: only eight productions describe the whole language; the language has a simple syntax: it is basically a parenthesized, comma-separated list of "words"; the language's dialects are represented as a single class with a very small API: only five methods in the class; it takes only minutes to learn how to integrate Funky in your C++ applications.iIt takes only minutes to learn how to write a script in Funky;
understandability	the interpreter's way of woring is well documented and easy to understand; the simple syntax and grammar of the language make scripts very easy to understand;
operability	to use the interpreter, you create a single instance of a class and call the eval method; ... that's all there is to it!

Efficiency

You need a small and fast interpreter that won't hog your resources:

time behaviour	it takes microseconds to execute a script;
resource behaviour	the interpreter takes less than 40K of memory;

Maintainability

One of the most important aspects of the long-term quality of software is the ability to maintain it: though no bugs have been found in Funky so far, and its stability is a well-proven fact, it is not impossible that bugs will be found in the future. In that case it should be easy to analyse the code of both the script and the interpreter, it should be easy to change in order to extend or repair and it should be easy to test.

stability	Funky has a proven track record: it is used in high-performance applications that run 24/7; Funky has evolved in since its inception in 2007: new dialects have been added and new elements have been added to the shared grammar, but backward-compatibility has been, and will be, maintained and the design of the interpreter has not been changed;
analyzability	the source code is well-documented; the interpreter's design is very easy to follow; the interpreter's code is now very complex;
changeability	due to the interpreter's design, it is very clear where changes should go; built-in functions are very easy to add, as they're added in the same way as installed C++ functions;
testability	each dialect has its own set of unit tests; the API of each class is very conscise

Portability

High-quality software needs to be portable: it should be easy to install, previous versions should be easy to replace, it should be easy to adapt to new needs and it needs to meet its requirements:

installability	the Funky interpreter is presented as a single DLL or static library so you only need to copy the DLL into your path, or link with the static library;
replaceability	if you use the DLL version, you only need to replace the DLL to replace a previous version of Funky: Funky has a very stable API and ABI;
adaptability	you can install your own functions into the interpreter; you have a choice of four different dialects (two in the open-source version), according to your needs; as Funky is an interpreter, you have full control over what it does;
conformance	Funky will meet your requirements for persistent predicates; Funky will render your applications scriptable;