/** @page qore_intro Introduction

    @section qore_introduction Introduction to Qore

    The %Qore programming language is a powerful, thread-capable, embeddable weakly-typed language with optional strong typing and procedural and object-oriented features designed for anything from quick scripting to complex multithreaded, network-aware application development to embedded application scripting. %Qore was initially designed to facilitate the rapid implementation of sophisticated interfaces in embedded code in an enterprise environment, and has since grown into a general-purpose language as well.

    %Qore exports a C++ API to allow programs or libraries to embed %Qore code; this manual documents %Qore's user-level features, for more information about %Qore's C++ API, see the <a href="http://www.qore.org">%Qore home page</a>.

    Flexible @ref character_encoding "character encoding support" is also built-in to %Qore strings, and automatic character encoding conversions are supported, enabling correct behavior when working in an environment with mixed character encoding requirements (see @ref character_encoding).

    %Qore includes the following design points:

    <b>Support for Embedded Logic</b>\n
    %Qore was designed to support embedding logic in applications; this also applies to applications written in %Qore as well as applications using the %Qore library's public C++ API. By using the @ref Qore::Program "Program" class, discrete objects can be created and destroyed at will containing embedded code to extend or modify the behavior of your application in user-defined ways. The @ref Qore::Program "Program" class allows the capabilities of embedded code to be arbitrarily restricted as well.

    <b>Thread Safety and SMP Scalability</b>\n
    All elements of %Qore are thread-safe, and the language in general has been designed with SMP scalability in mind. The internal design and implementation of %Qore favors multithreaded performance over single-threaded performance, so multithreaded %Qore programs can count on an efficient and stable execution platform, and do not have to limit themselves to a subset of %Qore's functionality (see @ref threading). Additionally, %Qore includes optimizations designed to reduce the number of SMP cache invalidations that provide a substantial performance boost on SMP machines.

    %Qore supports deadlock detection in complex locking scenarios and will throw an exception rather than allow an operation to be performed that would cause a deadlock. Furthermore, %Qore's threading primitives detect threading errors and throw exceptions in these cases as well.

    <b>Database Integration and DBI Layer</b>\n
    Retrieving, comparing, and manipulating data in a consistent manner from heterogenous database types is made possible by %Qore's built-in database integration. %Qore was designed with a database independent interfacing (DBI) layer, providing a standard interface for %Qore programs to access any database supported by a %Qore DBI driver (see the @ref Qore::SQL::Datasource "Datasource" class).  %Qore now supports a very high level API in <a href="../../modules/SqlUtil/html/index.html">SqlUtil</a>, which provides facilities for automatic schema management and programmatic SQL generation as well as data synchronization between heterogenous database types and more.

    <b>Function and Class Library</b>\n
    %Qore's basic functionality covers areas such as: POSIX-compliant command-line parsing (ex: @ref Qore::GetOpt "GetOpt" class), strong encryption and digest calculation, thread synchronization (ex: @ref Qore::Thread::Queue "Queue" class, @ref Qore::Thread::Mutex "Mutex" class, @ref Qore::Thread::Condition "Condition" class, etc), working with files (@ref Qore::File "File" class), socket, HTTP, and higher-level protocol communication (@ref Qore::Socket "Socket", @ref Qore::HTTPClient "HTTPClient", @ref Qore::FtpClient "FtpClient" classes, optionally with TLS/SSL encryption), support for dynamic embedded application logic (@ref Qore::Program "Program" class). Additionally, %Qore's functionality is extended with @ref qore_modules "modules" delivered separately from the %Qore library (see @ref qore_modules or <a href="http://www.qore.org">Qore's home page</a> for more information.

    <b>Familiar Syntax</b>\n
    %Qore syntax is similar to other programming languages, allowing new programmers to rapidly come up to speed in %Qore. %Qore borrows features from languages such as: C++ (ex: @ref inheritance "multiple inheritance", @ref exception_handling "exception handling", @ref static_methods "static methods"), Java (ex: the synchronized keyword, the @ref instanceof "instanceof operator", @ref object "object" and @ref qore_classes "class" implementation), <a href="http://www.perl.org">Perl</a> (ex: the @ref foreach "foreach statement", @ref splice "splice", @ref push "push", @ref pop "pop", @ref chomp "chomp", @ref trim "trim" operators, perl5-compatible @ref qore_regex "regular expressions", and more), the D Programming Language (the @ref on_exit "on_exit", @ref on_success "on_success", and @ref on_error "on_error" statements provide exception-aware functionality similar to D's <tt>scope(exit)</tt>, <tt>scope(failure)</tt>, allowing exception-aware cleanup code to be placed next to the code requiring cleanup), Python (@ref Qore::range() "range()", @ref Qore::xrange() "xrange()", and the @ref Qore::RangeIterator "RangeIterator" class), and others, also with many features unique to %Qore. Furthermore, %Qore supports @ref closure "closures" (including binding local variables in the closure in a way that is safe to use even in multithreaded contexts) and features for advanced list processing (@ref map "map", @ref foldl "foldl", @ref foldr "foldr", and @ref select "select").

    %Qore's @ref operators "operators" are designed to produce the expected results for the programmer even when data types are mixed, a feature meant to further flatten the learning curve for new programmers.

    <b>Simple Resource Management</b>\n
    %Qore's @ref garbage_collection "garbage collection" approach is unique and allows %Qore to support the
<a href="http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization">RAII idiom</a> for resource management with deterministic collection and
destruction of objects even when objects participate in recursive directed graphs; see @ref garbage_collection for more information.

    Additionally, every effort is made to find and fix bugs in %Qore before every release; for example <a href="http://www.valgrind.org">valgrind</a> is used on Linux and OSX and dbx on Solaris to check for memory leaks and memory errors.  Particular attention is paid to thread-safety of all %Qore components as well; %Qore aims to be a stable platform for enterprise development supporting both quick script-based solutions and as an encapsulating language for embedding (and protecting) code in a server application.

    @note %Qore is moving toward establishing @ref new-style "%new-style" as the default syntax; all examples given in the %Qore documentation are given assuming @ref new-style "%new-style".
*/
