# GOBLAN Language Reference Manual

Size: px
Start display at page:

Transcription

1 GOBLAN Language Reference Manual UNI Name Role yk2553 Yunsung Kim Project Manager sl3368 Sameer Lal Verification & Validation jw3046 Jee Hyun Wang Language Guru dl2997 Da Liu System Architect sjg2174 Sean Garvey System Architect

2 Table of Contents 1. Introduction 2. Types and Literals 2.1 Primitive Types 2.2 Lists 2.3 Named Tuple 3. Graphs and Nodes 3.1 Node Types 3.2 Constructing and Using Nodes 3.3 Constructing Graphs 3.4 Using Nodes and Graph 4. Expressions 4.1 Primary expressions 4.2 Unary operators 4.3 Multiplicative operators 4.4 Additive operators 4.5 Relational operators 4.6 Equality operators 4.7 Boolean AND 4.8 Boolean OR 4.9 Assignment 5. Statements 5.1 Conditional 5.2 while 5.3 for each loop 5.4 for loop 5.5 break 5.6 continue 5.7 return 6. Functions 7. Standard Library 7.1 Print 7.2 Type conversions 8. Program Structure 9. Sample Program 1

3 1. Introduction Graphs appear naturally in problems of various domains such as physics, chemistry, sociology, linguistics etc. for the way they intuitively express entities and the complex relationships among them. Especially in the fields of computer science and statistics, graphs are used to model information diffusion or as a statistical formalism for describing the relationship between events. Graphs are used in this context to represent distributions and formulas which generate data that is observed. A method for exact inference in these statistical graphical models is the Junction Tree Algorithm (JTA). JTA is an algorithm that is based on the node connectivity in a graphical model. Each node passes to its neighboring nodes the "messages" that encode the partial information about the posterior distribution, and the neighbors collect these messages, run a function to create its own message, and pass it to their neighbors down the stream. The messages received by the last node in the stream is then used to reconstruct the desired answer. The intuition behind this algorithm falls into the paradigm of message passing among nodes, which is characterized by two major components: the ability to (1) exchange messages between nodes, and to (2) update the data or state of each node using those messages by computing certain functions. In fact, message passing is the intuition behind many graphs algorithms including shortest path search or binary tree search. Yet, implementing these node oriented algorithms can be tedious and time consuming. In this context, GOBLAN is a language that focuses, not on manipulating the graph as a whole (with the use of adjacency matrices), but rather on exchanging data (messages) among individual nodes and using these data to update the data at each node. This domain specific language is expected to enable developers to work with graph based structures and algorithms with more ease by thinking in terms of the operations of each node. 2. Types and Literals GOBLAN has a set of types and literals which are similar to those of most programming languages. Since GOBLAN compiles into C, most of these specifications match those of the compiled language. Types in GOBLAN can be largely classified into primitive types and non primitive (user defined) types. List, named tuples and graph nodes fall into the latter. While primitive data types are passed by value, non primitive data types are always passed by reference. 2.1 Primitive Types A number of primitive data types are defined as follows: 2

4 2.1.1 Integers Integer constants (e.g. 14, 2131, , etc.) are indicated with the keyword int. In GOBLAN, all integers are 4 bytes in size and thus can represent any signed integer in the range [ , ]. int d = 30; Characters Character constants, signified by a single character, surrounded by single quotes: a. Only ASCII characters are permitted. For variable instantiation, the char keyword is used to state the this type. char first = a ; Strings String constants are defined as a list of characters greater than size 1. They are identified as being surrounded by double quotes: hello world. For variable instantiation, the String keyword is used to state type. These may only be defined using GOBLAN defined characters. In order for double quote ( ) or single quote ( ) characters to be a part of the string, they must be preceded with a backslash (e.g. he said \ Hi\ ). String greeting = hello world ; Floating Point Numbers To represent rational numbers and values outside the range provided by the integer constant, the double precision floating point data type is available using the keyword float. This is signified by the double keyword for variables. As mentioned in the C Language manual, these are defined as follows: A floating constant consists of an integer part, a decimal point, a fraction part, an e, and an optionally signed integer exponent. The integer and fraction parts both consist of a sequence of digits. Either the integer part or the fraction part (not both) may be missing; either the decimal point or the e and the exponent (not both) may be missing. Every floating constant is taken to be double precision. float number =

5 2.1.5 Boolean This data type in GOBLAN represents the most basic unit of logic. It takes either the value of true or false. Variables are typed using the keyword bool. bool win = false; 2.2 Lists The list data type is signified using the left and right braces [ ]. List types are like arrays in that they allow for manipulation using indexing, but are also variable in size. They automatically resize to the amount of data in the list. Lists can be mutated to include more or less values using keywords: add and delete. The add keyword appends the value to the end of the list. The delete keyword deletes the object at the index specified: delete 3 from I A list is declared by a type specifier followed by the keyword list and an identifier. If the list stores named tuples, the type specifier is replaced by the keyword tuple. int list l; add 1 to l; // declares a list l of integers and appends 1 to it edge list l; add {int i = 0, int val = 0 to l; 2.3 Named Tuple Named tuples are flexible data structures intended for holding the necessary data for graph computations. These are essentially a list of key,value pairs which can be of different types. Each type of a named tuple should be first declared by using the keyword tuple as in: tuple type_name{type1 member1, type2 member2,...; Named tuples are instantiated by specifying the tuple type and writing out the members separated by commas in brackets ( { ). This statement adds returns the reference(address) to the tuple instance, which can be stored as a separate variable. An example of declaring a tuple type and instantiating it: tuple new_type{int cats, bool hat; // declare tuple type new_type new_type a = new_type{0, true; // a stores the address of the tuple instance Tuples must be accessed by its reference. To access the value for a given key in a tuple, the key is followed by a dot: 4

6 a.cats == 0 // true 3. Graphs and Nodes GOBLAN is a language for graph based programming, suitable for implementing algorithms within the message passing framework. In the framework of message passing, a graph is a group of nodes that possess data attributes and object functions that manipulate these data or communicate them to other nodes in the form of messages. There are two types of object functions. First are the synchronous object functions, which are functions invoked by a node upon receiving a message to process the message. These functions are used to update the data of the node based on the message communicated from other nodes. The second type of object functions are asynchronous object functions, which are functions that manipulate the data of a node or initiate message passing at any point in the program. Many major graph algorithms can be constructed within this framework. In a shortest path search algorithm (Dijkstra s algorithm), for instance, each node maintains current estimates of the shortest distance from the source (data). Going in the increasing order of distance from the source, each node sends to its neighbors its current estimate of the distance from source (asynchronous function). Upon receiving the distance estimates from each node, the receiving node updates its own distance estimate and saves the neighbor that connects the source and itself in shortest distance (synchronous function). When the root node is reached, the algorithm terminates. Binary tree search also falls into the paradigm of message passing. Each node in the tree holds data, and the algorithm starts from the root by recursively running binary search on its subtrees. Each descendent of the root collects the search results of its subtrees, searches its own data, and passes the search result to its parent (synchronous functions). The root initiates this search and collects the final search results (asynchronous functions). The data attributes, a synchronous function sequence, and an asynchronous function sequence thus collectively define a node type. Graphs in GOBLAN are homogeneous directed graphs, which are directed graphs whose nodes are of identical types. A graph in GOBLAN is conceptually a group of multiple nodes, and GOBLAN internally represents a graph as a list of nodes. 5

7 3.1 Node Types Users can declare different types of a node by specifying their data members, asynchronous functions, and synchronous functions. The declaration of a node type must contain 3 blocks: the data block for defining node members, the do block for defining the asynchronous function, and the catch block for defining the synchronous function. node NodeType { data { /* data specification */ type_1 member_1;... type do (type arg1, type arg2,...) { /* asynchronous function definition */ catch { /* synchronous function definition */ Declaring the members in the data{ block requires declaring the types and names of each member (as in declaring tuple types). Asynchronous functions are defined in the do(){ block in the way typical functions are defined. Asynchronous functions can take arguments or return a value. Synchronous functions are defined in the catch{ block, and they do not take arguments nor return values; conceptually, their arguments are passed via messages, and they do not require return values. Following is the declaration of the DijkstraNode. (It is explained in greater detail in the last section.) node DijkstraNode{ data{ int dist = infinity; DijkstraNode prev; void do (list l){ msg = {DijkstraNode sender = self, int dist = self.dist; pass msg to all; delete self from l; catch{ if (pack.dist + self[pack.sender].dist < self.dist){ self.dist = pack.dist + self[pack.sender].dist; self.prev = pack.senderl In addition to the members specified in the data block, each node has two default members called chld and prnt. Both of these members are lists of neighbor tuples. A neighbor tuple 6

8 contains the address of the neighbor node instance (ID), the address to the edge tuple for the edge that connects the neighbor and the node, and the address to the message tuple that is shared between the two ends of the edge. Note that the neighbor tuple is not a node instance but instead a metadata of the relationship between the two connected nodes. The following figure visualizes the complete data structure of graphs and nodes. In the graph in this figure, there exists an edge that goes from node G[1] to G[0]. Arrows indicate addresses and the structures to which the addresses refer to. Note that two nodes on each side of an edge share the same edge and message tuples. When a message is passed and the synchronous function is invoked, the shared message tuple is populated by the sender and its contents are retrieved by the receiver. Following are the keywords that are used in graph declaration The self Keyword Used within the context of the graph definition, the self keyword is the reference to the node itself. For example, the following statement construct a named tuple containing the reference of the sender node and the distance value. node SomeGraph{... int do{... tuple msg = tuple{somegraph sender = self, int dist = 0;

9 3.1.2 The message Keyword The message keyword is valid only within the catch block to refer to the message that was received by the node. Messages are treated like regular named tuples. In the context of the sample code in the previous subsection, the following statement declares a synchronous function which prints the sender of the message and the dist field in the message. node SomeGraph{... catch{... print( %s, dist: %d % (to_string(message.sender), message.dist) ); The pass to... Keyword The pass to... statement is used to initiate the exchange of a packet. The statement pass msg to {node [node1, node2,...] parents children all, where msg has to be a tuple type, transfers the msg tuple from the owner node to a particular node or a list of nodes. The user can also use the keywords parents, children, or all to refer to a specific group of nodes. The pass keyword can be used both inside and outside of a node definition. node SomeGraph{... int do{ tuple msg = tuple{somegraph sender = self, int dist = 0; pass msg to children; Constructing and Using Nodes Once a node type is declared, users can create instances of each node type by calling constructors. Constructors are used just like regular functions, except that they use the names of the node types. The arguments to a constructor have to follow the order in which members are declared in the node type declaration. A constructor returns a reference to the instance of the created node. The following statement declares a reference to a DijkstraNode called n, creates a DijkstraNode instance, and store the reference to that instance in n. All node instances must be accessed through its reference. DijkstraNode n = DijkstraNode(0, null); // n is the address to a new Dijkstra node 8

10 3.3 Constructing Graphs A graph is declared by the node type followed by the keyword graph and an identifier. Graph instances are initialized by the graph constructor, which is also denoted by the keyword graph, but instead called like a function with two arguments: a list of nodes and a list of edge tuples. An edge tuple must contain a source node, a destination node, and optionally some data attributes, in order. The graph constructor automatically populates the chld and prnt list of each node in the graph. Consider, for example, the following directed graph. The following code creates the graph displayed in the previous figure. The numbers on the edges indicate weights. list DijkstraNode nodes; for (int i = 0; i < 4; i = i + 1){ add DijkstraNode(inf, null) to nodes; // add 4 default DijskstraNode s to the list node list tuple edges = [ {DijkstraNode src = nodes[0], DijkstraNode dst = n[1], int weight = 4, {DijkstraNode src = nodes[0], DijkstraNode dst = n[3], int weight = 2, {DijkstraNode src = nodes[1], DijkstraNode dst = n[0], int weight = 6, {DijkstraNode src = nodes[1], DijkstraNode dst = n[2], int weight = 10, {DijkstraNode src = nodes[3], DijkstraNode dst = n[2], int weight = 5]; // creating a list of edges DijkstraNode graph g = DijkstraNode graph(nodes, edges); // creating graph 3.4 Using Nodes and Graph Once a node type or a graph is declared, its members and functions can be accessed. Following keywords and operators are used to manipulate graphs and nodes. 9

11 3.4.1 The. operator The members of a node can be accessed by. operator as in node_name.member. Continuing on the graph constructor example in section 3.3, the statement for (nb in nodes[0].chld){ print("%s, %s" % (to_string(nb.id), to_string(nb.edge.dist))); prints the ID of and distance to the children of nodes[0] The [, ] operator This operator can be used with both nodes and graphs in different contexts. When used as node_name_1[node_name_2], evaluating this statement returns the neighbor tuple of the edge going from node_1 to node_2. Continuing on the graph constructor example in section 3.3, the following statement is valid: node_1 = nodes[0]; node_2 = nodes[1]; print( %d % (to_string(node_1[node_2].edge[weight]))) // this prints 4 When used as graph_name[integer_expression], this statement returns a node in the graph indexed by the value of integer_expression. (Recall that graphs are internally represented as lists of node addresses. The [] operator is used in the same context.) The run keyword The statement run node_name(arg1, arg2,...) invokes the asynchronous function of node_name and passes arg1, arg2,... as the arguments to it. Usually asynchronous functions are the functions that initiate recursion of the algorithm. For example, the following code creates a graph of two nodes whose values are initialized to 1 and 2, connects node_0 to node_1, and invokes the asynchronous function that adds a value k to the values of the node and its children node SimpleNode{ data{ int num; void do(int k){ num = num + k; pass {int add = k to children; 10

12 catch{ print("adding %d to %d" % (msg.add, self.num)); self.num = self.num + msg.add; SimpleNode list nodes; add (SimpleNode(1)) to nodes; add (SimpleNode(2)) to nodes; edges = [{SimpleNode src = nodes[0], SimpleNode dst = nodes[1]]; SimpleNode graph g = SimpleNode graph(nodes, edges) run g[0](1); // now node[0].num is 1, node[1].num is 2; output: adding 1 to 1 run g[0](2); // now node[0].num is 3, node[1].num is 4; output: adding 2 to 2 4. Expressions In this section, the order of the subsections denotes the precedence; expressions in section 3.1 are of the highest precedence and expressions in section 3.9 are of the lowest. Within a subsection, the precedence of the expressions are equivalent. Each subsection outlines the associativity of the expressions in its respective subsection. 4.1 Primary expressions The operators in this section have left to right associativity identifier The identifier refers to a previously declared and initialized identifier constant, null, inf A constant refers to a data type literal. The integer, floating point, and boolean constants have a range of possible values defined in the previous section. The keyword null represents a non existing reference. The keyword inf represents the mathematical concept of infinity ( expression ) The set of opening and closing parenthesis can be used to group an expression into a higher precedence. The type and value of this primary expression are that of the contained expression identifier [ expression ] An identifier followed by expression surrounded by opening and closing brackets, denotes element index access. If the identifier is a list, the expression must be a non negative integer, and the type and value of the primary expression are that of the element at index. If the identifier is a node, the expression must be a node, and the primary expression is a tuple which contains 11

13 edge information between the nodes (from the identifier node, to the expression node). If the identifier is a graph, the expression must be a non negative integer, and the primary expression is a node. Type others than the list, node, and graph are not supported identifier. member An identifier followed by a period and a member name denotes member access. The identifier must be either a node or a named tuple. Must member be one the attributed of the identifier. The type and value of the primary expression are that of the member. 4.2 Unary operators The operators in this section have right to left associativity expression The operator denotes arithmetic negation for integer and floating point types ! expression The! operator denotes boolean negation for boolean types. 4.3 Multiplicative operators The operators in this section have left to right associativity. Multiplicative operands must be of the same type; type conversions, promotions, or demotions are not supported expression * expression, expression *. expression The * and *. operators denote integer and floating point multiplication expression / expression, expression /. expression The / and /. operators denote integer and floating point division. In integer division, if the number produced by the evaluation of the operator is not an integer, the fractional portion of the number will be truncated expression % expression The % operator denotes the integer modulo operator. The number produced by the evaluation of the operator will have the same sign as the dividend (left) operand. 12

14 4.4 Additive operators The operators in this section have left to right associativity. Additive operands must be of the same type; type conversions, promotions, or demotions are not supported expression + expression, expression +. expression The + and +. operators denote integer and floating point addition expression expression, expression. expression The and. operators denote integer and floating point subtraction. 4.5 Relational operators The operators in this section have left to right associativity. The result of relational operator evaluation is a boolean type, the value of which corresponds to the truth value of the expression. Relational operators support integer or floating point operands, but not a combination of both expression < expression, expression > expression The < and > operators denote the less than and greater than comparison expression <= expression, expression >= expression The <= and >= operators denote the less than or equal to and greater than or equal to comparison. 4.6 Equality operators The operators in this section have left to right associativity. The result of equality operator evaluation is a boolean type, the value of which corresponds to the truth value of the expression expression == expression, expression!= expression The == and!= operators denote the equal to and not equal to comparison, which support integer and floating point operands. If an integer is compared to a floating point, the integer is automatically promoted to a floating point. 13

15 4.6.2 identifier === identifier, identifier <> identifier The === and <> operators denote the reference equal to and the not equal to comparison, which support reference operands. These are defined as Nodes, Graphs, and Strings. 4.7 Boolean AND expression && expression The && operator denotes the boolean AND operation. It has left to right associativity and only supports boolean operators; type conversions or demotions are not supported. 4.8 Boolean OR expression expression The operator denotes the boolean OR operation. It has left to right associativity and only supports boolean operators; type conversions or demotions are not supported. 4.9 Assignment identifier = expression The = operator denotes assignment. It has right to left associativity. The identifier must have the same type as the expression; type conversions, promotions, or demotions, are not supported. 5. Statements Except otherwise noted, statements are executed in sequence providing instructions to the computer at the language level. 5.1 Conditional Conditionals are generally boolean value expressions, which take the forms as the following: single conditional statement if (condition expression) { 14

16 5.1.2 multiple conditional statement if (condition expression) { elif (condition) { else { where our conditional statement is either a true or false boolean value for determining whether or not to execute the statement inside the curly brace block. The keyword elif is used after the first condition unless it reaches to the last statement. (Curly braces are not optional in case of single line of conditional expression.) 5.2 while while loop while(condition expression) { if the conditional is true, the expression or statements inside the curly braces are executed, otherwise, it is not do while loop do { while (condition expression) in this do while loop, the expression in the block is executed once no matter the conditional being true or false, if it is true, then the expression(s) will be executed again, until it becomes false. will be executed again, until it is false. 15

17 5.3 for each loop In for each loop, it takes the following form: for (variable in list){ This is a python style for loop where variable is any primitive data type of graph object, and list is a list higher order data structure. The expression is being executed while the variable traversing the entire list elements. 5.4 for loop for(expression 1; conditional expression; expression 2) { This is a c style for loop, where the init expression defines the initialization of the loop, conditional expression takes value of boolean, true of false and will be evaluated before any execution of the statement. Post expression can be any value expression. The statement inside the block will be executed if the conditional expression is true; it will stop the execution once the conditional becomes false. 5.5 break for(expression 1; conditional expression; expression 2) { if (condition expression) { break; // exit the current loop after break break is a keyword that can be used in a for loop or while loop or any procedural control manipulation. If the conditional inside the block is true, the runtime will exit the current loop without executing the expression after break statement and runtime will continue with the following code after the loop block, if there is any. 16

18 5.6 continue for(expression 1; conditional expression; expression 2) { if (condition expression) { continue; // skip the following statement in this loop block after continue continue is a keyword that can be used in a for loop or while loop, or any code procedural control. If the conditional inside the block is true, the runtime will skip executing the expression after conditional statement and continue starting from the loop block again if the loop conditional expression is still being true. 5.7 return Return keyword returns a value to the caller of the function or expression with the corresponding predefined type of the function, being the type of the expected value if non void type. If it a void type, nothing is returned. 6. Functions Functions are defined with the fun keyword. fun Function name ( arg1 type arg1, arg2 type arg2,... ) { expression They should be defined before being used. Arguments are passed by reference for graphs, and are passed by value for other data types, and passing arguments requires the specification of their types. Types include primitives, graph, node, list, and named tuples. There can be multiple arguments given to a function. Each argument s type should be defined prior to its name when defining a function. The type of the argument should not be specified when calling a function. The program checks the types of arguments as the function is being called. The return keyword returns value. The function will terminate when it sees the return keyword, and the program will return to where the function was called. Return type can be any types that are supported in GOBLAN, but it needs to match the predefined type of the function. If the return value is type void, the function returns nothing. 17

19 fun some_function(int a, String b){ String newstring= to_string(a); newstring = a + b; return newstring; main { String returned = some_function(1, example ); 7. Standard Library 7.1 Print Prints a statement. Formatted in c convention. 7.2 Type conversions float_of_int( identifier ) Takes an identifier of type integer as an argument and returns the floating point representation int_of_float( identifier ) If the floating point number has a fractional portion, this will be truncated. If the floating point number is too large to represent as an integer to_string( identifier ) Takes an identifier of any type, including nodes, graphs, tuples, and lists, and converts it to a string representation. 8. Program Structure Every statement in GOBLAN must belong to one of the three blocks: function declaration, node type declaration, and the main block. Each program may contain multiple function and node declarations, but should have one and only one main block. The main block is the designated start of the program. It has several unique features. First, the main block cannot be called or used anywhere in the program. Second, it cannot be overloaded. The name main in the global name space is reserved. Third, it does not need to have the return statement. Also, it can call any objects or functions that are defined in global scope. Functions and nodes should be defined before being used. 18

20 In the sample code, the main block first initializes the list of nodes, which are predefined as DijkstraNode. After adding constructed node objects to the list, it then builds edges. With edges and nodes, graph G of DijkstraNode is created. The remaining lines in the main block uses predefined functions in the script to do computations for Dijkstra s algorithm then prints the results out. The min_dist_node and len are functions. len takes type list as an argument and returns an int. This function is specifically used in the while loop statement for computing the Dijkstra s algorithm. min_dist_node takes a list of DijkstraNode s and returns a DijkstraNode. The block DijkstraNode is a node constructor. Each constructed will have data dist of type int and prev of type DijkstraNode. They represent current estimates of the shortest distance from the source and the previous node. The asynchronous function sends to its neighbors its current estimate of the distance from source. The synchronous function for this object gets triggered when receiving the distance estimates from each node. The node updates its own distance estimate and saves the neighbor that connects the source and itself in shortest distance. The outermost scoping is the whole program. Functions, graphs, and main create their own scope, and they are enclosed in curly brackets. For loops, conditional statement, and while loop have their own local scope. When an inner scope update its outer scope's declared variable, that variable is overridden. However, vise versa in not true. 9. Sample Program node DijkstraNode{ data{ // distance froms source, initially inf and updated at each iteration int dist = infinity; DijkstraNode prev; // the coparent that connects to source in shortest path void do (list l){ msg = {DijkstraNode sender = self, int dist = self.dist; // msg has sender address and distance pass msg to all; // pass message to all neighbors I'm connected to delete self from l; // Remove myself from l catch{ // When receiving distance estimate from one of its neighbors, // Update my current distance estimate // if the sender can connect me to the source in shorter distance // than my current view of the shortest path if (pack.dist + self[pack.sender].dist < self.dist){ // Save and that distance and neighbor self.dist = pack.dist + self[pack.sender].dist; self.prev = pack.senderl // Finds the length of a DijkstraNode list 19

21 fun len(dijkstranode list l){ int i = 0; for (x in l) {i = i + 1; return i; // Finds the node in a DijkstraNode list that has smallest distance fun min_dist_node(dijkstra list n){ DijkstraNode min = l[0]; for (n in G) { if (n.dist < min.dist){ min = n; return min; main{ // Initializing nodes list DijkstraNode nodes; for (int i = 0; i < 10; i++){ add DijkstraNode(inf,null) to nodes; // initialize dist to infinity // Initializing edges edges = [ {DijkstraNode src = n[0], DijkstraNode dst = n[1], data = 10,... // list is truncated for brevity. "..." is not reserved ]; // Constructing a graph from nodes and edges graph DijkstraNode G = Graph(nodes,edges); // Add all but the first(source) node to a separate list DijkstraNode list l; for (n in G){ if (n!= G[0]){ add n to l ; // Setting the destination to the last nodes of G DijkstraNode dest = G[len(G) 1]; // Running the Dijkstra's algorithm until the destination is reached DijkstraNode next; while (len(l) > 0){ next = min_dist_node(l); run next(l); // Printing the shortest path(in reverse) from destination to source while (dest!= G[0]){ print dest; dest = dest.prev; 20

22 10. Complete Table of Keywords Keywords int char String double bool {data1: val1, data2: val2,... Null inf fun fun_name (type arg1, type arg2, ) graph graph_name main(argv,argc) remove x from l add x to l [ fun(n) for x in l ] run node ( arg ) return val data do ( type arg1, type arg2, ) pass packet to {node all catch self Description signed integer value ASCII character array of characters double precision floating point number boolean value named tuple null pointer infinity defines an external function declares a graph definition the main script for execution (with command line arguments) removes the element in the array adds element to the end of array iterative definition of an array executes the asynchronous object function returns value begins the definition of graph attributes begins the definition of a node operation and the arguments used for the function triggers the node to forward the specified packet to a neighbor / all neighbors. definition of an asynchronous function self referring keyword for a node 21

23 message prnt chld neighbors for( type name ; conditional ; post loop ) { for variable in list { while( conditional ) { if(condition){elif(condition){els e{ tuple keyword in the catch statement that refers to the packet being passed The parents of a node in a directed graph The set of nodes which are children of the current node in a directed graph All connecting nodes in an undirected graph c style for loop python style for loop while loop conditional statement Tuple type declaration References: The C LRM, The Music Language LRM 22

### egrapher Language Reference Manual

egrapher Language Reference Manual Long Long: ll3078@columbia.edu Xinli Jia: xj2191@columbia.edu Jiefu Ying: jy2799@columbia.edu Linnan Wang: lw2645@columbia.edu Darren Chen: dsc2155@columbia.edu 1. Introduction

### GraphQuil Language Reference Manual COMS W4115

GraphQuil Language Reference Manual COMS W4115 Steven Weiner (Systems Architect), Jon Paul (Manager), John Heizelman (Language Guru), Gemma Ragozzine (Tester) Chapter 1 - Introduction Chapter 2 - Types

### GOBLAN. A Graph OBject LANguage. by John Kim (yk2553) Jee Hyun Wang (jw3046) Sean Garvey (sjg2174) Sameer Lal (sl3368)

GOBLAN A Graph OBject LANguage by John Kim (yk2553) Jee Hyun Wang (jw3046) Sean Garvey (sjg2174) Sameer Lal (sl3368) 1. Introduction GOBLAN (Graph OBject LANguage) is a domain specific, simple language

### CSc 10200! Introduction to Computing. Lecture 2-3 Edgardo Molina Fall 2013 City College of New York

CSc 10200! Introduction to Computing Lecture 2-3 Edgardo Molina Fall 2013 City College of New York 1 C++ for Engineers and Scientists Third Edition Chapter 2 Problem Solving Using C++ 2 Objectives In this

### GOLD Language Reference Manual

GOLD Language Reference Manual Language Guru: Timothy E. Chung (tec2123) System Architect: Aidan Rivera (ar3441) Manager: Zeke Reyna (eer2138) Tester: Dennis Guzman (drg2156) October 16th, 2017 1 Introduction

### ARG! Language Reference Manual

ARG! Language Reference Manual Ryan Eagan, Mike Goldin, River Keefer, Shivangi Saxena 1. Introduction ARG is a language to be used to make programming a less frustrating experience. It is similar to C

### The Warhol Language Reference Manual

The Warhol Language Reference Manual Martina Atabong maa2247 Charvinia Neblett cdn2118 Samuel Nnodim son2105 Catherine Wes ciw2109 Sarina Xie sx2166 Introduction Warhol is a functional and imperative programming

### \n is used in a string to indicate the newline character. An expression produces data. The simplest expression

Chapter 1 Summary Comments are indicated by a hash sign # (also known as the pound or number sign). Text to the right of the hash sign is ignored. (But, hash loses its special meaning if it is part of

### Introduction to Programming Using Java (98-388)

Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;

### Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2005 Handout 6 Decaf Language Wednesday, September 7 The project for the course is to write a

### 1 Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler

### Lexical Considerations

Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler

### Language Reference Manual

ALACS Language Reference Manual Manager: Gabriel Lopez (gal2129) Language Guru: Gabriel Kramer-Garcia (glk2110) System Architect: Candace Johnson (crj2121) Tester: Terence Jacobs (tj2316) Table of Contents

### 3. Java - Language Constructs I

Educational Objectives 3. Java - Language Constructs I Names and Identifiers, Variables, Assignments, Constants, Datatypes, Operations, Evaluation of Expressions, Type Conversions You know the basic blocks

### Language Reference Manual simplicity

Language Reference Manual simplicity Course: COMS S4115 Professor: Dr. Stephen Edwards TA: Graham Gobieski Date: July 20, 2016 Group members Rui Gu rg2970 Adam Hadar anh2130 Zachary Moffitt znm2104 Suzanna

### Sprite an animation manipulation language Language Reference Manual

Sprite an animation manipulation language Language Reference Manual Team Leader Dave Smith Team Members Dan Benamy John Morales Monica Ranadive Table of Contents A. Introduction...3 B. Lexical Conventions...3

### Chapter 1 Summary. Chapter 2 Summary. end of a string, in which case the string can span multiple lines.

Chapter 1 Summary Comments are indicated by a hash sign # (also known as the pound or number sign). Text to the right of the hash sign is ignored. (But, hash loses its special meaning if it is part of

### Sketchpad Graphics Language Reference Manual. Zhongyu Wang, zw2259 Yichen Liu, yl2904 Yan Peng, yp2321

Sketchpad Graphics Language Reference Manual Zhongyu Wang, zw2259 Yichen Liu, yl2904 Yan Peng, yp2321 October 20, 2013 1. Introduction This manual provides reference information for using the SKL (Sketchpad

### Review: Exam 1. Your First C++ Program. Declaration Statements. Tells the compiler. Examples of declaration statements

Review: Exam 1 9/20/06 CS150 Introduction to Computer Science 1 1 Your First C++ Program 1 //*********************************************************** 2 // File name: hello.cpp 3 // Author: Shereen Khoja

### DaMPL. Language Reference Manual. Henrique Grando

DaMPL Language Reference Manual Bernardo Abreu Felipe Rocha Henrique Grando Hugo Sousa bd2440 flt2107 hp2409 ha2398 Contents 1. Getting Started... 4 2. Syntax Notations... 4 3. Lexical Conventions... 4

### Object oriented programming. Instructor: Masoud Asghari Web page: Ch: 3

Object oriented programming Instructor: Masoud Asghari Web page: http://www.masses.ir/lectures/oops2017sut Ch: 3 1 In this slide We follow: https://docs.oracle.com/javase/tutorial/index.html Trail: Learning

### C Language Part 1 Digital Computer Concept and Practice Copyright 2012 by Jaejin Lee

C Language Part 1 (Minor modifications by the instructor) References C for Python Programmers, by Carl Burch, 2011. http://www.toves.org/books/cpy/ The C Programming Language. 2nd ed., Kernighan, Brian,

### The SPL Programming Language Reference Manual

The SPL Programming Language Reference Manual Leonidas Fegaras University of Texas at Arlington Arlington, TX 76019 fegaras@cse.uta.edu February 27, 2018 1 Introduction The SPL language is a Small Programming

### Mirage. Language Reference Manual. Image drawn using Mirage 1.1. Columbia University COMS W4115 Programming Languages and Translators Fall 2006

Mirage Language Reference Manual Image drawn using Mirage 1.1 Columbia University COMS W4115 Programming Languages and Translators Fall 2006 Prof. Stephen Edwards Team Members: Abhilash I ai2160@columbia.edu

### XQ: An XML Query Language Language Reference Manual

XQ: An XML Query Language Language Reference Manual Kin Ng kn2006@columbia.edu 1. Introduction XQ is a query language for XML documents. This language enables programmers to express queries in a few simple

### Decaf Language Reference Manual

Decaf Language Reference Manual C. R. Ramakrishnan Department of Computer Science SUNY at Stony Brook Stony Brook, NY 11794-4400 cram@cs.stonybrook.edu February 12, 2012 Decaf is a small object oriented

### The pixelman Language Reference Manual. Anthony Chan, Teresa Choe, Gabriel Kramer-Garcia, Brian Tsau

The pixelman Language Reference Manual Anthony Chan, Teresa Choe, Gabriel Kramer-Garcia, Brian Tsau October 2017 Contents 1 Introduction 2 2 Lexical Conventions 2 2.1 Comments..........................................

### The PCAT Programming Language Reference Manual

The PCAT Programming Language Reference Manual Andrew Tolmach and Jingke Li Dept. of Computer Science Portland State University September 27, 1995 (revised October 15, 2002) 1 Introduction The PCAT language

### Language Reference Manual

Programming Languages and Translators Language Reference Manual ART: Animation Rendering Tool Brett Jervey - baj2125 Gedion Metaferia - gym2103 Natan Kibret - nfk2105 Soul Joshi - srj2120 October 26, 2016

### IPCoreL. Phillip Duane Douglas, Jr. 11/3/2010

IPCoreL Programming Language Reference Manual Phillip Duane Douglas, Jr. 11/3/2010 The IPCoreL Programming Language Reference Manual provides concise information about the grammar, syntax, semantics, and

### FRAC: Language Reference Manual

FRAC: Language Reference Manual Justin Chiang jc4127 Kunal Kamath kak2211 Calvin Li ctl2124 Anne Zhang az2350 1. Introduction FRAC is a domain-specific programming language that enables the programmer

### UNIT- 3 Introduction to C++

UNIT- 3 Introduction to C++ C++ Character Sets: Letters A-Z, a-z Digits 0-9 Special Symbols Space + - * / ^ \ ( ) [ ] =!= . \$, ; : %! &? _ # = @ White Spaces Blank spaces, horizontal tab, carriage

### Chapter 3: Operators, Expressions and Type Conversion

101 Chapter 3 Operators, Expressions and Type Conversion Chapter 3: Operators, Expressions and Type Conversion Objectives To use basic arithmetic operators. To use increment and decrement operators. To

### Full file at

Java Programming: From Problem Analysis to Program Design, 3 rd Edition 2-1 Chapter 2 Basic Elements of Java At a Glance Instructor s Manual Table of Contents Overview Objectives s Quick Quizzes Class

### RTL Reference 1. JVM. 2. Lexical Conventions

RTL Reference 1. JVM Record Transformation Language (RTL) runs on the JVM. Runtime support for operations on data types are all implemented in Java. This constrains the data types to be compatible to Java's

### Expressions and Data Types CSC 121 Spring 2015 Howard Rosenthal

Expressions and Data Types CSC 121 Spring 2015 Howard Rosenthal Lesson Goals Understand the basic constructs of a Java Program Understand how to use basic identifiers Understand simple Java data types

### Short Notes of CS201

#includes: Short Notes of CS201 The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with < and > if the file is a system

### A Short Summary of Javali

A Short Summary of Javali October 15, 2015 1 Introduction Javali is a simple language based on ideas found in languages like C++ or Java. Its purpose is to serve as the source language for a simple compiler

### Features of C. Portable Procedural / Modular Structured Language Statically typed Middle level language

1 History C is a general-purpose, high-level language that was originally developed by Dennis M. Ritchie to develop the UNIX operating system at Bell Labs. C was originally first implemented on the DEC

### CS201 - Introduction to Programming Glossary By

CS201 - Introduction to Programming Glossary By #include : The #include directive instructs the preprocessor to read and include a file into a source code file. The file name is typically enclosed with

### BASIC COMPUTATION. public static void main(string [] args) Fundamentals of Computer Science I

BASIC COMPUTATION x public static void main(string [] args) Fundamentals of Computer Science I Outline Using Eclipse Data Types Variables Primitive and Class Data Types Expressions Declaration Assignment

### PieNum Language Reference Manual

PieNum Language Reference Manual October 2017 Hadiah Venner (hkv2001) Hana Fusman (hbf2113) Ogochukwu Nwodoh( ocn2000) Index Introduction 1. Lexical Convention 1.1. Comments 1.2. Identifiers 1.3. Keywords

### AP COMPUTER SCIENCE JAVA CONCEPTS IV: RESERVED WORDS

AP COMPUTER SCIENCE JAVA CONCEPTS IV: RESERVED WORDS PAUL L. BAILEY Abstract. This documents amalgamates various descriptions found on the internet, mostly from Oracle or Wikipedia. Very little of this

### Welcome Back. CSCI 262 Data Structures. Hello, Let s Review. Hello, Let s Review. How to Review 8/19/ Review. Here s a simple C++ program:

Welcome Back CSCI 262 Data Structures 2 - Review What you learned in CSCI 261 (or equivalent): Variables Types Arrays Expressions Conditionals Branches & Loops Functions Recursion Classes & Objects Streams

### Objectives. Chapter 2: Basic Elements of C++ Introduction. Objectives (cont d.) A C++ Program (cont d.) A C++ Program

Objectives Chapter 2: Basic Elements of C++ In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

### Lecture 2 Tao Wang 1

Lecture 2 Tao Wang 1 Objectives In this chapter, you will learn about: Modular programs Programming style Data types Arithmetic operations Variables and declaration statements Common programming errors

### Chapter 2: Basic Elements of C++

Chapter 2: Basic Elements of C++ Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates

### Chapter 2: Basic Elements of C++ Objectives. Objectives (cont d.) A C++ Program. Introduction

Chapter 2: Basic Elements of C++ C++ Programming: From Problem Analysis to Program Design, Fifth Edition 1 Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers

### Weiss Chapter 1 terminology (parenthesized numbers are page numbers)

Weiss Chapter 1 terminology (parenthesized numbers are page numbers) assignment operators In Java, used to alter the value of a variable. These operators include =, +=, -=, *=, and /=. (9) autoincrement

### BASIC ELEMENTS OF A COMPUTER PROGRAM

BASIC ELEMENTS OF A COMPUTER PROGRAM CSC128 FUNDAMENTALS OF COMPUTER PROBLEM SOLVING LOGO Contents 1 Identifier 2 3 Rules for naming and declaring data variables Basic data types 4 Arithmetic operators

### Expressions and Data Types CSC 121 Fall 2015 Howard Rosenthal

Expressions and Data Types CSC 121 Fall 2015 Howard Rosenthal Lesson Goals Understand the basic constructs of a Java Program Understand how to use basic identifiers Understand simple Java data types and

### CSI33 Data Structures

Outline Department of Mathematics and Computer Science Bronx Community College October 24, 2018 Outline Outline 1 Chapter 8: A C++ Introduction For Python Programmers Expressions and Operator Precedence

### TML Language Reference Manual

TML Language Reference Manual Jiabin Hu (jh3240) Akash Sharma (as4122) Shuai Sun (ss4088) Yan Zou (yz2437) Columbia University October 31, 2011 1 Contents 1 Introduction 4 2 Lexical Conventions 4 2.1 Character

### CMPT 125: Lecture 3 Data and Expressions

CMPT 125: Lecture 3 Data and Expressions Tamara Smyth, tamaras@cs.sfu.ca School of Computing Science, Simon Fraser University January 3, 2009 1 Character Strings A character string is an object in Java,

### Learning Language. Reference Manual. George Liao (gkl2104) Joseanibal Colon Ramos (jc2373) Stephen Robinson (sar2120) Huabiao Xu(hx2104)

Learning Language Reference Manual 1 George Liao (gkl2104) Joseanibal Colon Ramos (jc2373) Stephen Robinson (sar2120) Huabiao Xu(hx2104) A. Introduction Learning Language is a programming language designed

### COMS W4115 Programming Languages & Translators GIRAPHE. Language Reference Manual

COMS W4115 Programming Languages & Translators GIRAPHE Language Reference Manual Name UNI Dianya Jiang dj2459 Vince Pallone vgp2105 Minh Truong mt3077 Tongyun Wu tw2568 Yoki Yuan yy2738 1 Lexical Elements

### Zheng-Liang Lu Java Programming 45 / 79

1 class Lecture2 { 2 3 "Elementray Programming" 4 5 } 6 7 / References 8 [1] Ch. 2 in YDL 9 [2] Ch. 2 and 3 in Sharan 10 [3] Ch. 2 in HS 11 / Zheng-Liang Lu Java Programming 45 / 79 Example Given a radius

### Contents. Jairo Pava COMS W4115 June 28, 2013 LEARN: Language Reference Manual

Jairo Pava COMS W4115 June 28, 2013 LEARN: Language Reference Manual Contents 1 Introduction...2 2 Lexical Conventions...2 3 Types...3 4 Syntax...3 5 Expressions...4 6 Declarations...8 7 Statements...9

### GridLang: Grid Based Game Development Language Language Reference Manual. Programming Language and Translators - Spring 2017 Prof.

GridLang: Grid Based Game Development Language Language Reference Manual Programming Language and Translators - Spring 2017 Prof. Stephen Edwards Akshay Nagpal Dhruv Shekhawat Parth Panchmatia Sagar Damani

### Lecture 3 Tao Wang 1

Lecture 3 Tao Wang 1 Objectives In this chapter, you will learn about: Arithmetic operations Variables and declaration statements Program input using the cin object Common programming errors C++ for Engineers

### GBL Language Reference Manual

COMS W4115 PROGRAMMING LANGUAGES AND TRANSLATORS GBL Language Reference Manual Yiqing Cui(yc3121) Sihao Zhang(sz2558) Ye Cao(yc3113) Shengtong Zhang(sz2539) March 7, 2016 CONTENTS 1 Introduction 3 2 Syntax

### BoredGames Language Reference Manual A Language for Board Games. Brandon Kessler (bpk2107) and Kristen Wise (kew2132)

BoredGames Language Reference Manual A Language for Board Games Brandon Kessler (bpk2107) and Kristen Wise (kew2132) 1 Table of Contents 1. Introduction... 4 2. Lexical Conventions... 4 2.A Comments...

### Java+- Language Reference Manual

Fall 2016 COMS4115 Programming Languages & Translators Java+- Language Reference Manual Authors Ashley Daguanno (ad3079) - Manager Anna Wen (aw2802) - Tester Tin Nilar Hlaing (th2520) - Systems Architect

### VLC : Language Reference Manual

VLC : Language Reference Manual Table Of Contents 1. Introduction 2. Types and Declarations 2a. Primitives 2b. Non-primitives - Strings - Arrays 3. Lexical conventions 3a. Whitespace 3b. Comments 3c. Identifiers

### There are four numeric types: 1. Integers, represented as a 32 bit (or longer) quantity. Digits sequences (possibly) signed are integer literals:

Numeric Types There are four numeric types: 1. Integers, represented as a 32 bit (or longer) quantity. Digits sequences (possibly) signed are integer literals: 1-123 +456 2. Long integers, of unlimited

### GBIL: Generic Binary Instrumentation Language. Language Reference Manual. By: Andrew Calvano. COMS W4115 Fall 2015 CVN

GBIL: Generic Binary Instrumentation Language Language Reference Manual By: Andrew Calvano COMS W4115 Fall 2015 CVN Table of Contents 1) Introduction 2) Lexical Conventions 1. Tokens 2. Whitespace 3. Comments

### Basic data types. Building blocks of computation

Basic data types Building blocks of computation Goals By the end of this lesson you will be able to: Understand the commonly used basic data types of C++ including Characters Integers Floating-point values

### Flow Control. CSC215 Lecture

Flow Control CSC215 Lecture Outline Blocks and compound statements Conditional statements if - statement if-else - statement switch - statement? : opertator Nested conditional statements Repetitive statements

### 1 Shyam sir JAVA Notes

1 Shyam sir JAVA Notes 1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write

### Chapter 2: Data and Expressions

Chapter 2: Data and Expressions CS 121 Department of Computer Science College of Engineering Boise State University January 15, 2015 Chapter 2: Data and Expressions CS 121 1 / 1 Chapter 2 Part 1: Data

### Objects and Types. COMS W1007 Introduction to Computer Science. Christopher Conway 29 May 2003

Objects and Types COMS W1007 Introduction to Computer Science Christopher Conway 29 May 2003 Java Programs A Java program contains at least one class definition. public class Hello { public static void

### A Java program contains at least one class definition.

Java Programs Identifiers Objects and Types COMS W1007 Introduction to Computer Science Christopher Conway 29 May 2003 A Java program contains at least one class definition. public class Hello { public

### 2 nd Week Lecture Notes

2 nd Week Lecture Notes Scope of variables All the variables that we intend to use in a program must have been declared with its type specifier in an earlier point in the code, like we did in the previous

### SMURF Language Reference Manual Serial MUsic Represented as Functions

SMURF Language Reference Manual Serial MUsic Represented as Functions Richard Townsend, Lianne Lairmore, Lindsay Neubauer, Van Bui, Kuangya Zhai {rt2515, lel2143, lan2135, vb2363, kz2219}@columbia.edu

### Program Fundamentals

Program Fundamentals /* HelloWorld.java * The classic Hello, world! program */ class HelloWorld { public static void main (String[ ] args) { System.out.println( Hello, world! ); } } /* HelloWorld.java

### Programming Lecture 3

Programming Lecture 3 Expressions (Chapter 3) Primitive types Aside: Context Free Grammars Constants, variables Identifiers Variable declarations Arithmetic expressions Operator precedence Assignment statements

### Declaration and Memory

Declaration and Memory With the declaration int width; the compiler will set aside a 4-byte (32-bit) block of memory (see right) The compiler has a symbol table, which will have an entry such as Identifier

### LOON. Language Reference Manual THE LANGUAGE OF OBJECT NOTATION. Kyle Hughes, Jack Ricci, Chelci Houston-Borroughs, Niles Christensen, Habin Lee

LOON THE LANGUAGE OF OBJECT NOTATION Language Reference Manual Kyle Hughes, Jack Ricci, Chelci Houston-Borroughs, Niles Christensen, Habin Lee October 2017 1 Contents 1 Introduction 3 2 Types 4 2.1 JSON............................................

### Language Proposal: tail

Language Proposal: tail A tail recursion optimization language Some Wise Gal Team Roles Team Members UNIs Roles Sandra Shaefer Jennifer Lam Serena Shah Simpson Fiona Rowan sns2153 jl3953 ss4354 fmr2112

### Java Bytecode (binary file)

Java is Compiled Unlike Python, which is an interpreted langauge, Java code is compiled. In Java, a compiler reads in a Java source file (the code that we write), and it translates that code into bytecode.

### Objectives. In this chapter, you will:

Objectives In this chapter, you will: Become familiar with functions, special symbols, and identifiers in C++ Explore simple data types Discover how a program evaluates arithmetic expressions Learn about

### Chapter 2: Using Data

Chapter 2: Using Data TRUE/FALSE 1. A variable can hold more than one value at a time. F PTS: 1 REF: 52 2. The legal integer values are -2 31 through 2 31-1. These are the highest and lowest values that

### MODULE 02: BASIC COMPUTATION IN JAVA

MODULE 02: BASIC COMPUTATION IN JAVA Outline Variables Naming Conventions Data Types Primitive Data Types Review: int, double New: boolean, char The String Class Type Conversion Expressions Assignment

### Twister: Language Reference Manual

Twister: Language Reference Manual Manager: Anand Sundaram (as5209) Language Guru: Arushi Gupta (ag3309) System Architect: Annalise Mariottini (aim2120) Tester: Chuan Tian (ct2698) February 23, 2017 Contents

### (Not Quite) Minijava

(Not Quite) Minijava CMCS22620, Spring 2004 April 5, 2004 1 Syntax program mainclass classdecl mainclass class identifier { public static void main ( String [] identifier ) block } classdecl class identifier

### PLT Fall Shoo. Language Reference Manual

PLT Fall 2018 Shoo Language Reference Manual Claire Adams (cba2126) Samurdha Jayasinghe (sj2564) Rebekah Kim (rmk2160) Cindy Le (xl2738) Crystal Ren (cr2833) October 14, 2018 Contents 1 Comments 2 1.1

### Review of the C Programming Language for Principles of Operating Systems

Review of the C Programming Language for Principles of Operating Systems Prof. James L. Frankel Harvard University Version of 7:26 PM 4-Sep-2018 Copyright 2018, 2016, 2015 James L. Frankel. All rights

Index COPYRIGHTED MATERIAL Note to the Reader: Throughout this index boldfaced page numbers indicate primary discussions of a topic. Italicized page numbers indicate illustrations. A abstract classes

### SSOL Language Reference Manual

SSOL Language Reference Manual Madeleine Tipp Jeevan Farias Daniel Mesko mrt2148 jtf2126 dpm2153 Manager Language Guru System Architect October 15, 2018 Contents 1 Lexical Conventions 2 1.1 Identifiers...............................................

### Graphiti A Simple Graph Language. Language Reference Manual

Graphiti A Simple Graph Language Language Reference Manual Alice Thum, System Architect, at3160@barnard.edu Sydney Lee, System Architect, stl2121@barnard.edu Michal Porubcin, Language Guru, mp3242@columbia.edu

### CS201 Some Important Definitions

CS201 Some Important Definitions For Viva Preparation 1. What is a program? A program is a precise sequence of steps to solve a particular problem. 2. What is a class? We write a C++ program using data

### MR Language Reference Manual. Siyang Dai (sd2694) Jinxiong Tan (jt2649) Zhi Zhang (zz2219) Zeyang Yu (zy2156) Shuai Yuan (sy2420)

MR Language Reference Manual Siyang Dai (sd2694) Jinxiong Tan (jt2649) Zhi Zhang (zz2219) Zeyang Yu (zy2156) Shuai Yuan (sy2420) 1 MR Language Reference Manual 1. Introduction 1.1 Concept of MapReduce

### Chapter 6 Primitive types

Chapter 6 Primitive types Lesson page 6-1. Primitive types Question 1. There are an infinite number of integers, so it would be too ineffient to have a type integer that would contain all of them. Question

### Unit-II Programming and Problem Solving (BE1/4 CSE-2)

Unit-II Programming and Problem Solving (BE1/4 CSE-2) Problem Solving: Algorithm: It is a part of the plan for the computer program. An algorithm is an effective procedure for solving a problem in a finite

### C++ Programming: From Problem Analysis to Program Design, Third Edition

C++ Programming: From Problem Analysis to Program Design, Third Edition Chapter 2: Basic Elements of C++ Objectives (continued) Become familiar with the use of increment and decrement operators Examine

### CHIL CSS HTML Integrated Language

CHIL CSS HTML Integrated Language Programming Languages and Translators Fall 2013 Authors: Gil Chen Zion gc2466 Ami Kumar ak3284 Annania Melaku amm2324 Isaac White iaw2105 Professor: Prof. Stephen A. Edwards

### PROGRAMMING FUNDAMENTALS

PROGRAMMING FUNDAMENTALS Q1. Name any two Object Oriented Programming languages? Q2. Why is java called a platform independent language? Q3. Elaborate the java Compilation process. Q4. Why do we write

### Review Chapters 1 to 4. Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013

Review Chapters 1 to 4 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013 Introduction to Java Chapters 1 and 2 The Java Language Section 1.1 Data & Expressions Sections 2.1 2.5 Instructor: