Transcend is a compilation phase and process of reasoning about program in order to influence compilation. First, compiler extracts annotations from source code and other facts from number of sources to form a complete logic program. Then, solver processes logic program and outputs decisions that affect and control compilation process in a number of ways.

Xreate's annotations comprise optional supplementary information that is processed by compiler along with a source code proper and able to affect compilation process. Annotations have form of expressions that consist of following elements: Literals Strings, numbers. Example: 5, "success" Predicates Predicates have zero or more arguments. Example: final, status(broken), version("12.0.3", unstable) Negation Example: -i12n, -access(allowed) Various Xreate's entities can be annotated. At the time following entities are supported: Expressions and Identifiers Code blocks and context Functions and Function Guards Modules

SYNTAX: //expression// **::** //type//**;** //annotation-list//. type expression's type annotation-list one or more annotation attached to the expression. Annotations are delimited by semicolon Example: test = function:: int { x = 5:: int; arithmetic(fast). //annotation applied to an identifier y = (x - 8:: int; arithm_optimization(off)) * 2:: float. //annotation applied to a nested expression x+y } For readability sake compound statements(e.g. loops) have different syntax for an annotations. See particular statement's syntax for details

SYNTAX: **context** :: //annotations-list//. annotations-list List of annotation delimited by semicolon Code block annotations called context. Keyword context used to declare annotation within enclosing code block. Example: test = function:: int { context:: arithm_optimization(off). x = 10 :: int. 2 * x - 16 }

There are some annotations in Xreate that have special meaning entry Specifies entry point of a program. See Function Syntax final Specifies fixed point of loop statements. See Loop Statement

Annotations is a mechanism to express an additional pieces of information and can occur in source code or accompanying files. They are of declarative nature in a sense that they express specific properties of and relations between different entities, such as: identifiers, statements, code blocks, functions, modules or even a whole program. Annotations are facts about source code provided by developer in explicit form. Beside annotations there are other sources of information, e.g. implicit facts that are automatically inferred by various analysis phases to express useful insights regarding analysed code. Such pieces aren't exposed directly to a developer but accessed and used internally at reasoning phase along with annotations. All types of input are summed up below: Explicit annotations in source files Annotations provided by developer in order to explicitly affect compilation Code Analysis Different code analyses during compilation provide information implicitly inferred from source code Supervision External facts that reflect requirements, describe hardware and/or environment where compilation takes place or program is supposed to work. There are many supervision layers possible, from custom compiler's mode, to OS- or computer- or even network-wide level. On other words, supervision covers local or client supplied annotations Audit Third party supplied external information that reflect additional software properties, e.g. results of security audit Reasoning rules Reasoning infers additional facts from pool of previously gathered information. It is done by using resoning rules that govern reasoning process

This section goes through differences that annotations have over traditional statements.

Annotations are not a part of language syntax and there is no predefined set of allowed annotations. Developer is free to define and use custom annotations to express desired properties without prior changes to compiler. Yet there are several reserved annotations that have specific meaning in Xreate. See special annotations for details.

Unlike language statements that have well defined compilation output, annotation do not. They are rather of suggestive nature and actual impact depends on many factors. Annotations comprise an input for a reasoning procedure that ultimately determines how exactly influence compilation.

Annotations are gathered from different sources and this enables annotations to complement themselves. Compiler blends in annotations originated from various sources seamlessly and this allows to improve decisions quality.

Annotations able to express not only properties of program itself but also properties of local environment(OS, computer, local network) where program is supposed to run. Thus compiler operates information inaccessible during software development and can't be reflected in the code otherwise. Compilation can be adjusted to a particular environment and functioning mode.

Traditionally software has a rigid strictly defined hierarchical structure and interaction between components. More precisely, let's look at client-service code model. Service is done independently in order to work well with as wide as possible set of different clients. Thus service is unaware of exact characteristics of particular client code it works with. All burden of complying with interaction specification lies on a client. However client may use only small subset of service functionality or use it in specific and predictable order. Generally speaking, service by having additional information on particular client able to serve requests more efficiently in many cases. It can be conceptualized as a feedback from a client. Annotations is good candidate to express feedback to improve interaction quality.

As code grows and goes through multiple reworks and rewrites many initial assumptions about the code and relation between different parts change accordingly. Some implementation details and approaches became outdated and code quality deteriorates. DIfferent picture in case if code uses annotations to express important properties. Any changes in underlying code lead to a restart of reasoning procedure which adjust implementation decisions to be still optimal in changed environment.