In computer science, a pointer is an object in many programming languages that stores a memory address. This can be that of another value located in computer memory, or in some cases, that of memory-mapped computer hardware. A pointer references a location in memory, and obtaining the value stored at that location is known as dereferencing the pointer. As an analogy, a page number in a book's index could be considered a pointer to the corresponding page; dereferencing such a pointer would be done by flipping to the page with the given page number and reading the text found on that page. The actual format and content of a pointer variable is dependent on the underlying computer architecture.

Using pointers significantly improves performance for repetitive operations, like traversing iterable data structures (e.g. strings, lookup tables, control tables and tree structures). In particular, it is often much cheaper in time and space to copy and dereference pointers than it is to copy and access the data to which the pointers point.

Pointers are also used to hold the addresses of entry points for called subroutines in procedural programming and for run-time linking to dynamic link libraries (DLLs). In object-oriented programming, pointers to functions are used for binding methods, often using virtual method tables.

A pointer is a simple, more concrete implementation of the more abstract reference data type. Several languages, especially low-level languages, support some type of pointer, although some have more restrictions on their use than others. While "pointer" has been used to refer to references in general, it more properly applies to data structures whose interface explicitly allows the pointer to be manipulated (arithmetically via ) as a memory address, as opposed to a magic cookie or capability which does not allow such. Because pointers allow both protected and unprotected access to memory addresses, there are risks associated with using them, particularly in the latter case. Primitive pointers are often stored in a format similar to an integer; however, attempting to dereference or "look up" such a pointer whose value is not a valid memory address could cause a program to crash (or contain invalid data). To alleviate this potential problem, as a matter of type safety, pointers are considered a separate type parameterized by the type of data they point to, even if the underlying representation is an integer. Other measures may also be taken (such as validation & bounds checking), to verify that the pointer variable contains a value that is both a valid memory address and within the numerical range that the processor is capable of addressing.

History

In 1955, Soviet Ukrainian computer scientist Kateryna Yushchenko invented the Address programming language that made possible indirect addressing and addresses of the highest rank – analogous to pointers. This language was widely used on the Soviet Union computers. However, it was unknown outside the Soviet Union and usually Harold Lawson is credited with the invention, in 1964, of the pointer. In 2000, Lawson was presented the Computer Pioneer Award by the IEEE "[f]or inventing the pointer variable and introducing this concept into PL/I, thus providing for the first time, the capability to flexibly treat linked lists in a general-purpose high-level language". His seminal paper on the concepts appeared in the June 1967 issue of CACM entitled: PL/I List Processing.  According to the Oxford English Dictionary, the word pointer first appeared in print as a stack pointer in a technical memorandum by the System Development Corporation.

Formal description
In computer science, a pointer is a kind of reference.

A data primitive (or just primitive) is any datum that can be read from or written to computer memory using one memory access (for instance, both a byte and a word are primitives).

A data aggregate (or just aggregate) is a group of primitives that are logically contiguous in memory and that are viewed collectively as one datum (for instance, an aggregate could be 3 logically contiguous bytes, the values of which represent the 3 coordinates of a point in space). When an aggregate is entirely composed of the same type of primitive, the aggregate may be called an array; in a sense, a multi-byte word primitive is an array of bytes, and some programs use words in this way.

A pointer is a programming concept used in computer science to reference or point to a memory location that stores a value or an object. It is essentially a variable that stores the memory address of another variable or data structure rather than storing the data itself.

Pointers are commonly used in programming languages that support direct memory manipulation, such as C and C++. They allow programmers to work with memory directly, enabling efficient memory management and more complex data structures. By using pointers, you can access and modify data located in memory, pass data efficiently between functions, and create dynamic data structures like linked lists, trees, and graphs.

In simpler terms, you can think of a pointer as an arrow that points to a specific spot in a computer's memory, allowing you to interact with the data stored at that location.

A memory pointer (or just pointer) is a primitive, the value of which is intended to be used as a memory address; it is said that a pointer points to a memory address. It is also said that a pointer points to a datum [in memory] when the pointer's value is the datum's memory address.

More generally, a pointer is a kind of reference, and it is said that a pointer references a datum stored somewhere in memory; to obtain that datum is to dereference the pointer. The feature that separates pointers from other kinds of reference is that a pointer's value is meant to be interpreted as a memory address, which is a rather low-level concept.

References serve as a level of indirection: A pointer's value determines which memory address (that is, which datum) is to be used in a calculation. Because indirection is a fundamental aspect of algorithms, pointers are often expressed as a fundamental data type in programming languages; in statically (or strongly) typed programming languages, the type of a pointer determines the type of the datum to which the pointer points.

Architectural roots
Pointers are a very thin abstraction on top of the addressing capabilities provided by most modern architectures. In the simplest scheme, an address, or a numeric index, is assigned to each unit of memory in the system, where the unit is typically either a byte or a word – depending on whether the architecture is byte-addressable or word-addressable – effectively transforming all of memory into a very large array. The system would then also provide an operation to retrieve the value stored in the memory unit at a given address (usually utilizing the machine's general-purpose registers).

In the usual case, a pointer is large enough to hold more addresses than there are units of memory in the system. This introduces the possibility that a program may attempt to access an address which corresponds to no unit of memory, either because not enough memory is installed (i.e. beyond the range of available memory) or the architecture does not support such addresses. The first case may, in certain platforms such as the Intel x86 architecture, be called a segmentation fault (segfault). The second case is possible in the current implementation of AMD64, where pointers are 64 bit long and addresses only extend to 48 bits. Pointers must conform to certain rules (canonical addresses), so if a non-canonical pointer is dereferenced, the processor raises a general protection fault.

On the other hand, some systems have more units of memory than there are addresses. In this case, a more complex scheme such as memory segmentation or paging is employed to use different parts of the memory at different times. The last incarnations of the x86 architecture support up to 36 bits of physical memory addresses, which were mapped to the 32-bit linear address space through the PAE paging mechanism. Thus, only 1/16 of the possible total memory may be accessed at a time. Another example in the same computer family was the 16-bit protected mode of the 80286 processor, which, though supporting only 16 MB of physical memory, could access up to 1 GB of virtual memory, but the combination of 16-bit address and segment registers made accessing more than 64 KB in one data structure cumbersome.

In order to provide a consistent interface, some architectures provide memory-mapped I/O, which allows some addresses to refer to units of memory while others refer to device registers of other devices in the computer. There are analogous concepts such as file offsets, array indices, and remote object references that serve some of the same purposes as addresses for other types of objects.

Uses
Pointers are directly supported without restrictions in languages such as PL/I, C, C++, Pascal, FreeBASIC, and implicitly in most assembly languages. They are primarily used for constructing references, which in turn are fundamental to constructing nearly all data structures, as well as in passing data between different parts of a program.

In functional programming languages that rely heavily on lists, data references are managed abstractly by using primitive constructs like cons and the corresponding elements car and cdr, which can be thought of as specialised pointers to the first and second components of a cons-cell. This gives rise to some of the idiomatic "flavour" of functional programming. By structuring data in such cons-lists, these languages facilitate recursive means for building and processing data—for example, by recursively accessing the head and tail elements of lists of lists; e.g. "taking the car of the cdr of the cdr". By contrast, memory management based on pointer dereferencing in some approximation of an array of memory addresses facilitates treating variables as slots into which data can be assigned imperatively.

When dealing with arrays, the critical lookup operation typically involves a stage called address calculation which involves constructing a pointer to the desired data element in the array. In other data structures, such as linked lists, pointers are used as references to explicitly tie one piece of the structure to another.

Pointers are used to pass parameters by reference. This is useful if the programmer wants a function's modifications to a parameter to be visible to the function's caller.  This is also useful for returning multiple values from a function.

Pointers can also be used to allocate and deallocate dynamic variables and arrays in memory. Since a variable will often become redundant after it has served its purpose, it is a waste of memory to keep it, and therefore it is good practice to deallocate it (using the original pointer reference) when it is no longer needed. Failure to do so may result in a memory leak (where available free memory gradually, or in severe cases rapidly, diminishes because of an accumulation of numerous redundant memory blocks).

C pointers
The basic syntax to define a pointer is:

int *ptr;

This declares ptr as the identifier of an object of the following type:
 pointer that points to an object of type int
This is usually stated more succinctly as "ptr is a pointer to int."

Because the C language does not specify an implicit initialization for objects of automatic storage duration, care should often be taken to ensure that the address to which ptr points is valid; this is why it is sometimes suggested that a pointer be explicitly initialized to the null pointer value, which is traditionally specified in C with the standardized macro NULL:

int *ptr = NULL;

Dereferencing a null pointer in C produces undefined behavior, which could be catastrophic. However, most implementations simply halt execution of the program in question, usually with a segmentation fault.

However, initializing pointers unnecessarily could hinder program analysis, thereby hiding bugs.

In any case, once a pointer has been declared, the next logical step is for it to point at something:

int a = 5;
int *ptr = NULL;

ptr = &a;

This assigns the value of the address of a to ptr. For example, if a is stored at memory location of 0x8130 then the value of ptr will be 0x8130 after the assignment. To dereference the pointer, an asterisk is used again:

*ptr = 8;

This means take the contents of ptr (which is 0x8130), "locate" that address in memory and set its value to 8.
If a is later accessed again, its new value will be 8.

This example may be clearer if memory is examined directly.
Assume that a is located at address 0x8130 in memory and ptr at 0x8134; also assume this is a 32-bit machine such that an int is 32-bits wide. The following is what would be in memory after the following code snippet is executed:

int a = 5;
int *ptr = NULL;

(The NULL pointer shown here is 0x00000000.)
By assigning the address of a to ptr:

ptr = &a;

yields the following memory values:

Then by dereferencing ptr by coding:

*ptr = 8;

the computer will take the contents of ptr (which is 0x8130), 'locate' that address, and assign 8 to that location yielding the following memory:

Clearly, accessing a will yield the value of 8 because the previous instruction modified the contents of a by way of the pointer ptr.

Use in data structures
When setting up data structures like lists, queues and trees, it is necessary to have pointers to help manage how the structure is implemented and controlled. Typical examples of pointers are start pointers, end pointers, and stack pointers. These pointers can either be absolute (the actual physical address or a virtual address in virtual memory) or relative (an offset from an absolute start address ("base") that typically uses fewer bits than a full address, but will usually require one additional arithmetic operation to resolve).

Relative addresses are a form of manual memory segmentation, and share many of its advantages and disadvantages. A two-byte offset, containing a 16-bit, unsigned integer, can be used to provide relative addressing for up to 64 KiB (216 bytes) of a data structure. This can easily be extended to 128, 256 or 512 KiB if the address pointed to is forced to be aligned on a half-word, word or double-word boundary (but, requiring an additional "shift left" bitwise operation—by 1, 2 or 3 bits—in order to adjust the offset by a factor of 2, 4 or 8, before its addition to the base address). Generally, though, such schemes are a lot of trouble, and for convenience to the programmer absolute addresses (and underlying that, a flat address space) is preferred.

A one byte offset, such as the hexadecimal ASCII value of a character (e.g. X'29') can be used to point to an alternative integer value (or index) in an array (e.g., X'01'). In this way, characters can be very efficiently translated from 'raw data' to a usable sequential index and then to an absolute address without a lookup table.

C arrays
In C, array indexing is formally defined in terms of pointer arithmetic; that is, the language specification requires that array[i] be equivalent to *(array + i). Thus in C, arrays can be thought of as pointers to consecutive areas of memory (with no gaps), and the syntax for accessing arrays is identical for that which can be used to dereference pointers. For example, an array array can be declared and used in the following manner:

int array[5];      /* Declares 5 contiguous integers */
int *ptr = array;  /* Arrays can be used as pointers */
ptr[0] = 1;        /* Pointers can be indexed with array syntax */
*(array + 1) = 2;  /* Arrays can be dereferenced with pointer syntax */
*(1 + array) = 2;  /* Pointer addition is commutative */
2[array] = 4;      /* Subscript operator is commutative */

This allocates a block of five integers and names the block array, which acts as a pointer to the block. Another common use of pointers is to point to dynamically allocated memory from malloc which returns a consecutive block of memory of no less than the requested size that can be used as an array.

While most operators on arrays and pointers are equivalent, the result of the sizeof operator differs. In this example, sizeof(array) will evaluate to 5*sizeof(int) (the size of the array), while sizeof(ptr) will evaluate to sizeof(int*), the size of the pointer itself.

Default values of an array can be declared like:

int array[5] = {2, 4, 3, 1, 5};

If array is located in memory starting at address 0x1000 on a 32-bit little-endian machine then memory will contain the following (values are in hexadecimal, like the addresses):

{| class="wikitable" style="font-family:monospace;"
|-
|
! 0 || 1 || 2 || 3
|-
! 1000
| 2 || 0 || 0 || 0
|-
! 1004
| 4 || 0 || 0 || 0
|-
! 1008
| 3 || 0 || 0 || 0
|-
! 100C
| 1 || 0 || 0 || 0
|-
! 1010
| 5 || 0 || 0 || 0
|}
Represented here are five integers: 2, 4, 3, 1, and 5. These five integers occupy 32 bits (4 bytes) each with the least-significant byte stored first (this is a little-endian CPU architecture) and are stored consecutively starting at address 0x1000.

The syntax for C with pointers is:
 array means 0x1000;
 array + 1 means 0x1004: the "+ 1" means to add the size of 1 int, which is 4 bytes;
 *array means to dereference the contents of array. Considering the contents as a memory address (0x1000), look up the value at that location (0x0002);
 array[i] means element number i, 0-based, of array which is translated into *(array + i).

The last example is how to access the contents of array. Breaking it down:
 array + i is the memory location of the (i)th element of array, starting at i=0;
 *(array + i) takes that memory address and dereferences it to access the value.

C linked list
Below is an example definition of a linked list in C.

/* the empty linked list is represented by NULL
 * or some other sentinel value */
#define EMPTY_LIST  NULL

struct link {
    void        *data;  /* data of this link */
    struct link *next;  /* next link; EMPTY_LIST if there is none */
};

This pointer-recursive definition is essentially the same as the reference-recursive definition from the Haskell programming language:

 data Link a = Nil
             | Cons a (Link a)
Nil is the empty list, and Cons a (Link a) is a cons cell of type a with another link also of type a.

The definition with references, however, is type-checked and does not use potentially confusing signal values.  For this reason, data structures in C are usually dealt with via wrapper functions, which are carefully checked for correctness.

Pass-by-address using pointers
Pointers can be used to pass variables by their address, allowing their value to be changed.  For example, consider the following C code:

/* a copy of the int n can be changed within the function without affecting the calling code */
void passByValue(int n) {
    n = 12;
}

/* a pointer m is passed instead. No copy of the value pointed to by m is created */
void passByAddress(int *m) {
    *m = 14;
}

int main(void) {
    int x = 3;

    /* pass a copy of x's value as the argument */
    passByValue(x);
    // the value was changed inside the function, but x is still 3 from here on

    /* pass x's address as the argument */
    passByAddress(&x);
    // x was actually changed by the function and is now equal to 14 here

    return 0;
}

Dynamic memory allocation
In some programs, the required amount of memory depends on what the user may enter. In such cases the programmer needs to allocate memory dynamically. This is done by allocating memory at the heap rather than on the stack, where variables usually are stored (although variables can also be stored in the CPU registers). Dynamic memory allocation can only be made through pointers, and names – like with common variables – cannot be given.

Pointers are used to store and manage the addresses of dynamically allocated blocks of memory. Such blocks are used to store data objects or arrays of objects. Most structured and object-oriented languages provide an area of memory, called the heap or free store, from which objects are dynamically allocated.

The example C code below illustrates how structure objects are dynamically allocated and referenced. The standard C library provides the function malloc() for allocating memory blocks from the heap. It takes the size of an object to allocate as a parameter and returns a pointer to a newly allocated block of memory suitable for storing the object, or it returns a null pointer if the allocation failed.

/* Parts inventory item */
struct Item {
    int         id;     /* Part number */
    char *      name;   /* Part name   */
    float       cost;   /* Cost        */
};

/* Allocate and initialize a new Item object */
struct Item * make_item(const char *name) {
    struct Item * item;

    /* Allocate a block of memory for a new Item object */
    item = malloc(sizeof(struct Item));
    if (item == NULL)
        return NULL;

    /* Initialize the members of the new Item */
    memset(item, 0, sizeof(struct Item));
    item->id =   -1;
    item->name = NULL;
    item->cost = 0.0;

    /* Save a copy of the name in the new Item */
    item->name = malloc(strlen(name) + 1);
    if (item->name == NULL) {
        free(item);
        return NULL;
    }
    strcpy(item->name, name);

    /* Return the newly created Item object */
    return item;
}

The code below illustrates how memory objects are dynamically deallocated, i.e., returned to the heap or free store. The standard C library provides the function free() for deallocating a previously allocated memory block and returning it back to the heap.

/* Deallocate an Item object */
void destroy_item(struct Item *item) {
    /* Check for a null object pointer */
    if (item == NULL)
        return;

    /* Deallocate the name string saved within the Item */
    if (item->name != NULL) {
        free(item->name);
        item->name = NULL;
    }

    /* Deallocate the Item object itself */
    free(item);
}

Memory-mapped hardware
On some computing architectures, pointers can be used to directly manipulate memory or memory-mapped devices.

Assigning addresses to pointers is an invaluable tool when programming microcontrollers. Below is a simple example declaring a pointer of type int and initialising it to a hexadecimal address in this example the constant 0x7FFF:

int *hardware_address = (int *)0x7FFF;

In the mid 80s, using the BIOS to access the video capabilities of PCs was slow. Applications that were display-intensive typically used to access CGA video memory directly by casting the hexadecimal constant 0xB8000 to a pointer to an array of 80 unsigned 16-bit int values. Each value consisted of an ASCII code in the low byte, and a colour in the high byte. Thus, to put the letter 'A' at row 5, column 2 in bright white on blue, one would write code like the following:

#define VID ((unsigned short (*)[80])0xB8000)

void foo(void) {
    VID[4][1] = 0x1F00 | 'A';
}

Use in control tables

Control tables that are used to control program flow usually make extensive use of pointers. The pointers, usually embedded in a table entry, may, for instance, be used to hold the entry points to subroutines to be executed, based on certain conditions defined in the same table entry. The pointers can however be simply indexes to other separate, but associated, tables comprising an array of the actual addresses or the addresses themselves (depending upon the programming language constructs available). They can also be used to point to earlier table entries (as in loop processing) or forward to skip some table entries (as in a switch or "early" exit from a loop). For this latter purpose, the "pointer" may simply be the table entry number itself and can be transformed into an actual address by simple arithmetic.

Typed pointers and casting
In many languages, pointers have the additional restriction that the object they point to has a specific type. For example, a pointer may be declared to point to an integer; the language will then attempt to prevent the programmer from pointing it to objects which are not integers, such as floating-point numbers, eliminating some errors.

For example, in C

int *money;
char *bags;

money would be an integer pointer and bags would be a char pointer.
The following would yield a compiler warning of "assignment from incompatible pointer type" under GCC

bags = money;

because money and bags were declared with different types.
To suppress the compiler warning, it must be made explicit that you do indeed wish to make the assignment by typecasting it

bags = (char *)money;

which says to cast the integer pointer of money to a char pointer and assign to bags.

A 2005 draft of the C standard requires that casting a pointer derived from one type to one of another type should maintain the alignment correctness for both types (188.8.131.52 Pointers, par. 7):
char *external_buffer = "abcdef";
int *internal_data;

internal_data = (int *)external_buffer;  // UNDEFINED BEHAVIOUR if "the resulting pointer
                                         // is not correctly aligned"

In languages that allow pointer arithmetic, arithmetic on pointers takes into account the size of the type. For example, adding an integer number to a pointer produces another pointer that points to an address that is higher by that number times the size of the type. This allows us to easily compute the address of elements of an array of a given type, as was shown in the C arrays example above. When a pointer of one type is cast to another type of a different size, the programmer should expect that pointer arithmetic will be calculated differently. In C, for example, if the money array starts at 0x2000 and sizeof(int) is 4 bytes whereas sizeof(char) is 1 byte, then money + 1 will point to 0x2004, but bags + 1 would point to 0x2001. Other risks of casting include loss of data when "wide" data is written to "narrow" locations (e.g. bags[0] = 65537;), unexpected results when bit-shifting values, and comparison problems, especially with signed vs unsigned values.

Although it is impossible in general to determine at compile-time which casts are safe, some languages store run-time type information which can be used to confirm that these dangerous casts are valid at runtime. Other languages merely accept a conservative approximation of safe casts, or none at all.

Value of pointers
In C and C++, even if two pointers compare as equal that doesn't mean they are equivalent. In these languages and LLVM, the rule is interpreted to mean that "just because two pointers point to the same address, does not mean they are equal in the sense that they can be used interchangeably", the difference between the pointers referred to as their provenance. Casting to an integer type such as uintptr_t is implementation-defined and the comparison it provides does not provide any more insight as to whether the two pointers are interchangeable. In addition, further conversion to bytes and arithmetic will throw off optimizers trying to keep track the use of pointers, a problem still being elucidated in academic research.

Making pointers safer
As a pointer allows a program to attempt to access an object that may not be defined, pointers can be the origin of a variety of programming errors. However, the usefulness of pointers is so great that it can be difficult to perform programming tasks without them. Consequently, many languages have created constructs designed to provide some of the useful features of pointers without some of their pitfalls, also sometimes referred to as pointer hazards. In this context, pointers that directly address memory (as used in this article) are referred to as s, by contrast with smart pointers or other variants.

One major problem with pointers is that as long as they can be directly manipulated as a number, they can be made to point to unused addresses or to data which is being used for other purposes. Many languages, including most functional programming languages and recent imperative languages like Java, replace pointers with a more opaque type of reference, typically referred to as simply a reference, which can only be used to refer to objects and not manipulated as numbers, preventing this type of error. Array indexing is handled as a special case.

A pointer which does not have any address assigned to it is called a wild pointer. Any attempt to use such uninitialized pointers can cause unexpected behavior, either because the initial value is not a valid address, or because using it may damage other parts of the program. The result is often a segmentation fault, storage violation or wild branch (if used as a function pointer or branch address).

In systems with explicit memory allocation, it is possible to create a dangling pointer by deallocating the memory region it points into. This type of pointer is dangerous and subtle because a deallocated memory region may contain the same data as it did before it was deallocated but may be then reallocated and overwritten by unrelated code, unknown to the earlier code. Languages with garbage collection prevent this type of error because deallocation is performed automatically when there are no more references in scope.

Some languages, like C++, support smart pointers, which use a simple form of reference counting to help track allocation of dynamic memory in addition to acting as a reference. In the absence of reference cycles, where an object refers to itself indirectly through a sequence of smart pointers, these eliminate the possibility of dangling pointers and memory leaks. Delphi strings support reference counting natively.

The Rust programming language introduces a borrow checker, pointer lifetimes, and an optimisation based around option types for null pointers to eliminate pointer bugs, without resorting to garbage collection.

Special kinds of pointers

Kinds defined by value

Null pointer

A null pointer has a value reserved for indicating that the pointer does not refer to a valid object. Null pointers are routinely used to represent conditions such as the end of a list of unknown length or the failure to perform some action; this use of null pointers can be compared to nullable types and to the Nothing value in an option type.

Dangling pointer

A dangling pointer is a pointer that does not point to a valid object and consequently may make a program crash or behave oddly. In the Pascal or C programming languages, pointers that are not specifically initialized may point to unpredictable addresses in memory.

The following example code shows a dangling pointer:

int func(void) {
    char *p1 = malloc(sizeof(char)); /* (undefined) value of some place on the heap */
    char *p2;       /* dangling (uninitialized) pointer */
    *p1 = 'a';      /* This is OK, assuming malloc() has not returned NULL. */
    *p2 = 'b';      /* This invokes undefined behavior */
}

Here, p2 may point to anywhere in memory, so performing the assignment *p2 = 'b'; can corrupt an unknown area of memory or trigger a segmentation fault.

Wild branch
Where a pointer is used as the address of the entry point to a program or start of a function which doesn't return anything and is also either uninitialized or corrupted, if a call or jump is nevertheless made to this address, a "wild branch" is said to have occurred. In other words, a wild branch is a function pointer that is wild (dangling).

The consequences are usually unpredictable and the error may present itself in several different ways depending upon whether or not the pointer is a "valid" address and whether or not there is (coincidentally) a valid instruction (opcode) at that address. The detection of a wild branch can present one of the most difficult and frustrating debugging exercises since much of the evidence may already have been destroyed beforehand or by execution of one or more inappropriate instructions at the branch location. If available, an instruction set simulator can usually not only detect a wild branch before it takes effect, but also provide a complete or partial trace of its history.

Kinds defined by structure

Autorelative pointer
An autorelative pointer is a pointer whose value is interpreted as an offset from the address of the pointer itself; thus, if a data structure has an autorelative pointer member that points to some portion of the data structure itself, then the data structure may be relocated in memory without having to update the value of the auto relative pointer.

The cited patent also uses the term self-relative pointer to mean the same thing. However, the meaning of that term has been used in other ways:
 to mean an offset from the address of a structure rather than from the address of the pointer itself;
 to mean a pointer containing its own address, which can be useful for reconstructing in any arbitrary region of memory a collection of data structures that point to each other.

Based pointer
A based pointer is a pointer whose value is an offset from the value of another pointer. This can be used to store and load blocks of data, assigning the address of the beginning of the block to the base pointer.

Kinds defined by use or datatype

Multiple indirection
In some languages, a pointer can reference another pointer, requiring multiple dereference operations to get to the original value. While each level of indirection may add a performance cost, it is sometimes necessary in order to provide correct behavior for complex data structures. For example, in C it is typical to define a linked list in terms of an element that contains a pointer to the next element of the list:

struct element {
    struct element *next;
    int            value;
};

struct element *head = NULL;

This implementation uses a pointer to the first element in the list as a surrogate for the entire list. If a new value is added to the beginning of the list, head has to be changed to point to the new element. Since C arguments are always passed by value, using double indirection allows the insertion to be implemented correctly, and has the desirable side-effect of eliminating special case code to deal with insertions at the front of the list:

// Given a sorted list at *head, insert the element item at the first
// location where all earlier elements have lesser or equal value.
void insert(struct element **head, struct element *item) {
    struct element **p;  // p points to a pointer to an element
    for (p = head; *p != NULL; p = &(*p)->next) {
        if (item->value <= (*p)->value)
            break;
    }
    item->next = *p;
    *p = item;
}

// Caller does this:
insert(&head, item);

In this case, if the value of item is less than that of head, the caller's head is properly updated to the address of the new item.

A basic example is in the argv argument to the main function in C (and C++), which is given in the prototype as char **argv—this is because the variable argv itself is a pointer to an array of strings (an array of arrays), so *argv is a pointer to the 0th string (by convention the name of the program), and **argv is the 0th character of the 0th string.

Function pointer
In some languages, a pointer can reference executable code, i.e., it can point to a function, method, or procedure. A function pointer will store the address of a function to be invoked. While this facility can be used to call functions dynamically, it is often a favorite technique of virus and other malicious software writers.

int sum(int n1, int n2) {   // Function with two integer parameters returning an integer value
    return n1 + n2;
}

int main(void) {
    int a, b, x, y;
    int (*fp)(int, int);    // Function pointer which can point to a function like sum
    fp = ∑              // fp now points to function sum
    x = (*fp)(a, b);        // Calls function sum with arguments a and b
    y = sum(a, b);          // Calls function sum with arguments a and b
}

Back pointer
In doubly linked lists or tree structures, a back pointer held on an element 'points back' to the item referring to the current element. These are useful for navigation and manipulation, at the expense of greater memory use.

Simulation using an array index
It is possible to simulate pointer behavior using an index to an (normally one-dimensional) array.

Primarily for languages which do not support pointers explicitly but do support arrays, the array can be thought of and processed as if it were the entire memory range (within the scope of the particular array) and any index to it can be thought of as equivalent to a general-purpose register in assembly language (that points to the individual bytes but whose actual value is relative to the start of the array, not its absolute address in memory).
Assuming the array is, say, a contiguous 16 megabyte character data structure, individual bytes (or a string of contiguous bytes within the array) can be directly addressed and manipulated using the name of the array with a 31 bit unsigned integer as the simulated pointer (this is quite similar to the C arrays example shown above). Pointer arithmetic can be simulated by adding or subtracting from the index, with minimal additional overhead compared to genuine pointer arithmetic.

It is even theoretically possible, using the above technique, together with a suitable instruction set simulator to simulate any machine code or the intermediate (byte code) of any processor/language in another language that does not support pointers at all (for example Java / JavaScript). To achieve this, the binary code can initially be loaded into contiguous bytes of the array for the simulator to "read", interpret and action entirely within the memory contained of the same array.
If necessary, to completely avoid buffer overflow problems, bounds checking can usually be actioned for the compiler (or if not, hand coded in the simulator).

Support in various programming languages

Ada
Ada is a strongly typed language where all pointers are typed and only safe type conversions are permitted. All pointers are by default initialized to null, and any attempt to access data through a null pointer causes an exception to be raised. Pointers in Ada are called access types. Ada 83 did not permit arithmetic on access types (although many compiler vendors provided for it as a non-standard feature), but Ada 95 supports "safe" arithmetic on access types via the package System.Storage_Elements.

BASIC
Several old versions of BASIC for the Windows platform had support for STRPTR() to return the address of a string, and for VARPTR() to return the address of a variable. Visual Basic 5 also had support for OBJPTR() to return the address of an object interface, and for an ADDRESSOF operator to return the address of a function. The types of all of these are integers, but their values are equivalent to those held by pointer types.

Newer dialects of BASIC, such as FreeBASIC or BlitzMax, have exhaustive pointer implementations, however. In FreeBASIC, arithmetic on ANY pointers (equivalent to C's void*) are treated as though the ANY pointer was a byte width. ANY pointers cannot be dereferenced, as in C. Also, casting between ANY and any other type's pointers will not generate any warnings.

dim as integer f = 257
dim as any ptr g = @f
dim as integer ptr i = g
assert(*i = 257)
assert( (g + 4) = (@f + 1) )

C and C++
In C and C++ pointers are variables that store addresses and can be null. Each pointer has a type it points to, but one can freely cast between pointer types (but not between a function pointer and an object pointer). A special pointer type called the "void pointer" allows pointing to any (non-function) object, but is limited by the fact that it cannot be dereferenced directly (it shall be cast). The address itself can often be directly manipulated by casting a pointer to and from an integral type of sufficient size, though the results are implementation-defined and may indeed cause undefined behavior; while earlier C standards did not have an integral type that was guaranteed to be large enough, C99 specifies the uintptr_t typedef name defined in <stdint.h>, but an implementation need not provide it.

C++ fully supports C pointers and C typecasting. It also supports a new group of typecasting operators to help catch some unintended dangerous casts at compile-time. Since C++11, the C++ standard library also provides smart pointers (unique_ptr, shared_ptr and weak_ptr) which can be used in some situations as a safer alternative to primitive C pointers. C++ also supports another form of reference, quite different from a pointer, called simply a reference or reference type.

Pointer arithmetic, that is, the ability to modify a pointer's target address with arithmetic operations (as well as magnitude comparisons), is restricted by the language standard to remain within the bounds of a single array object (or just after it), and will otherwise invoke undefined behavior. Adding or subtracting from a pointer moves it by a multiple of the size of its datatype. For example, adding 1 to a pointer to 4-byte integer values will increment the pointer's pointed-to byte-address by 4. This has the effect of incrementing the pointer to point at the next element in a contiguous array of integers—which is often the intended result. Pointer arithmetic cannot be performed on void pointers because the void type has no size, and thus the pointed address can not be added to, although gcc and other compilers will perform byte arithmetic on void* as a non-standard extension, treating it as if it were char *.

Pointer arithmetic provides the programmer with a single way of dealing with different types: adding and subtracting the number of elements required instead of the actual offset in bytes. (Pointer arithmetic with char * pointers uses byte offsets, because sizeof(char) is 1 by definition.) In particular, the C definition explicitly declares that the syntax a[n], which is the n-th element of the array a, is equivalent to *(a + n), which is the content of the element pointed by a + n.  This implies that n[a] is equivalent to a[n], and one can write, e.g., a[3] or 3[a] equally well to access the fourth element of an array a.

While powerful, pointer arithmetic can be a source of computer bugs. It tends to confuse novice programmers, forcing them into different contexts: an expression can be an ordinary arithmetic one or a pointer arithmetic one, and sometimes it is easy to mistake one for the other. In response to this, many modern high-level computer languages (for example Java) do not permit direct access to memory using addresses.  Also, the safe C dialect Cyclone addresses many of the issues with pointers. See C programming language for more discussion.

The void pointer, or void*, is supported in ANSI C and C++ as a generic pointer type. A pointer to void can store the address of any object (not function), and, in C, is implicitly converted to any other object pointer type on assignment, but it must be explicitly cast if dereferenced.
K&R C used char* for the "type-agnostic pointer" purpose (before ANSI C).

int x = 4;
void* p1 = &x;
int* p2 = p1;       // void* implicitly converted to int*: valid C, but not C++
int a = *p2;
int b = *(int*)p1;  // when dereferencing inline, there is no implicit conversion

C++ does not allow the implicit conversion of void* to other pointer types, even in assignments. This was a design decision to avoid careless and even unintended casts, though most compilers only output warnings, not errors, when encountering other casts.

int x = 4;
void* p1 = &x;
int* p2 = p1;                     // this fails in C++: there is no implicit conversion from void*
int* p3 = (int*)p1;               // C-style cast
int* p4 = reinterpret_cast<int*>(p1);  // C++ cast

In C++, there is no void& (reference to void) to complement void* (pointer to void), because references behave like aliases to the variables they point to, and there can never be a variable whose type is void.

Pointer-to-member

In C++ pointers to non-static members of a class can be defined. If a class C has a member T a then &C::a is a pointer to the member a of type T C::*. This member can be an object or a function. They can be used on the right-hand side of operators .* and ->* to access the corresponding member.

struct S {
int a;
int f() const {return a;}
};
S s1{};
S* ptrS = &s1;

int S::* ptr = &S::a; // pointer to S::a
int (S::* fp)()const = &S::f; // pointer to S::f

s1.*ptr = 1;
std::cout << (s1.*fp)() << "\n"; // prints 1
ptrS->*ptr = 2;
std::cout << (ptrS->*fp)() << "\n"; // prints 2

Pointer declaration syntax overview
These pointer declarations cover most variants of pointer declarations. Of course it is possible to have triple pointers, but the main principles behind a triple pointer already exist in a double pointer. The naming used here is what the expression typeid(type).name() equals for each of these types when using g++ or clang.

char A5_A5_c [5][5];   /* array of arrays of chars */
char *A5_Pc [5];       /* array of pointers to chars */
char **PPc;            /* pointer to pointer to char ("double pointer") */
char (*PA5_c) [5];     /* pointer to array(s) of chars */
char *FPcvE();         /* function which returns a pointer to char(s) */
char (*PFcvE)();       /* pointer to a function which returns a char */
char (*FPA5_cvE())[5]; /* function which returns pointer to an array of chars */
char (*A5_PFcvE[5])(); /* an array of pointers to functions which return a char */
The following declarations involving pointers-to-member are valid only in C++:
class C;
class D;
char C::* M1Cc;              /* pointer-to-member to char */
char C::*A5_M1Cc [5];        /* array of pointers-to-member to char */
char* C::* M1CPc;            /* pointer-to-member to pointer to char(s) */
char C::** PM1Cc;            /* pointer to pointer-to-member to char */
char (*M1CA5_c) [5];         /* pointer-to-member to array(s) of chars */
char C::* FM1CcvE();         /* function which returns a pointer-to-member to char */
char D::* C::* M1CM1Dc;      /* pointer-to-member to pointer-to-member to pointer to char(s) */
char C::* C::* M1CMS_c;      /* pointer-to-member to pointer-to-member to pointer to char(s) */
char (C::* FM1CA5_cvE())[5]; /* function which returns pointer-to-member to an array of chars */
char (C::* M1CFcvE)()        /* pointer-to-member-function which returns a char */
char (C::* A5_M1CFcvE[5])(); /* an array of pointers-to-member-functions which return a char */
The () and [] have a higher priority than *.

C#
In the C# programming language, pointers are supported by either marking blocks of code that include pointers with the unsafe keyword, or by using the System.Runtime.CompilerServices assembly provisions for pointer access.
The syntax is essentially the same as in C++, and the address pointed can be either managed or unmanaged memory. However, pointers to managed memory (any pointer to a managed object) must be declared using the fixed keyword, which prevents the garbage collector from moving the pointed object as part of memory management while the pointer is in scope, thus keeping the pointer address valid.

However, an exception to this is from using the IntPtr structure, which is a memory managed equivalent to int*, and does not require the unsafe keyword nor the CompilerServices assembly.  This type is often returned when using methods from the System.Runtime.InteropServices, for example:

// Get 16 bytes of memory from the process's unmanaged memory
IntPtr pointer = System.Runtime.InteropServices.Marshal.AllocHGlobal(16);

// Do something with the allocated memory

// Free the allocated memory
System.Runtime.InteropServices.Marshal.FreeHGlobal(pointer);

The .NET framework includes many classes and methods in the System and System.Runtime.InteropServices namespaces (such as the Marshal class) which convert .NET types (for example, System.String) to and from many unmanaged types and pointers (for example, LPWSTR or void*) to allow communication with unmanaged code. Most such methods have the same security permission requirements as unmanaged code, since they can affect arbitrary places in memory.

COBOL
The COBOL programming language supports pointers to variables. Primitive or group (record) data objects declared within the LINKAGE SECTION of a program are inherently pointer-based, where the only memory allocated within the program is space for the address of the data item (typically a single memory word). In program source code, these data items are used just like any other WORKING-STORAGE variable, but their contents are implicitly accessed indirectly through their LINKAGE pointers.

Memory space for each pointed-to data object is typically allocated dynamically using external CALL statements or via embedded extended language constructs such as EXEC CICS or EXEC SQL statements.

Extended versions of COBOL also provide pointer variables declared with USAGE IS POINTER clauses. The values of such pointer variables are established and modified using SET and SET ADDRESS statements.

Some extended versions of COBOL also provide PROCEDURE-POINTER variables, which are capable of storing the addresses of executable code.

PL/I
The PL/I language provides full support for pointers to all data types (including pointers to structures), recursion, multitasking, string handling, and extensive built-in functions. PL/I was quite a leap forward compared to the programming languages of its time. PL/I pointers are untyped, and therefore no casting is required for pointer dereferencing or assignment. The declaration syntax for a pointer is DECLARE xxx POINTER;, which declares a pointer named "xxx". Pointers are used with BASED variables. A based variable can be declared with a default locator (DECLARE xxx BASED(ppp); or without (DECLARE xxx BASED;), where xxx is a based variable, which may be an element variable, a structure, or an array, and ppp is the default pointer). Such a variable can be address without an explicit pointer reference (xxx=1;, or may be addressed with an explicit reference to the default locator (ppp), or to any other pointer (qqq->xxx=1;).

Pointer arithmetic is not part of the PL/I standard, but many compilers allow expressions of the form ptr = ptr±expression.  IBM PL/I also has the builtin function PTRADD to perform the arithmetic. Pointer arithmetic is always performed in bytes.

IBM Enterprise PL/I compilers have a new form of typed pointer called a HANDLE.

D
The D programming language is a derivative of C and C++ which fully supports C pointers and C typecasting.

Eiffel
The Eiffel object-oriented language employs value and reference semantics without pointer arithmetic. Nevertheless, pointer classes are provided. They offer pointer arithmetic, typecasting, explicit memory management,
interfacing with non-Eiffel software, and other features.

Fortran
Fortran-90 introduced a strongly typed pointer capability.  Fortran pointers contain more than just a simple memory address.  They also encapsulate the lower and upper bounds of array dimensions, strides (for example, to support arbitrary array sections), and other metadata.  An association operator, => is used to associate a POINTER to a variable which has a TARGET attribute.  The Fortran-90 ALLOCATE statement may also be used to associate a pointer to a block of memory.  For example, the following code might be used to define and create a linked list structure:
type real_list_t
  real :: sample_data(100)
  type (real_list_t), pointer :: next => null ()
end type

type (real_list_t), target :: my_real_list
type (real_list_t), pointer :: real_list_temp

real_list_temp => my_real_list
do
  read (1,iostat=ioerr) real_list_temp%sample_data
  if (ioerr /= 0) exit
  allocate (real_list_temp%next)
  real_list_temp => real_list_temp%next
end do

Fortran-2003 adds support for procedure pointers.  Also, as part of the C Interoperability feature, Fortran-2003 supports intrinsic functions for converting C-style pointers into Fortran pointers and back.

Go
Go has pointers. Its declaration syntax is equivalent to that of C, but written the other way around, ending with the type. Unlike C, Go has garbage collection, and disallows pointer arithmetic. Reference types, like in C++, do not exist. Some built-in types, like maps and channels, are boxed (i.e. internally they are pointers to mutable structures), and are initialized using the make function. In an approach to unified syntax between pointers and non-pointers, the arrow (->) operator has been dropped: the dot operator on a pointer refers to the field or method of the dereferenced object. This, however, only works with 1 level of indirection.

Java
There is no explicit representation of pointers in Java. Instead, more complex data structures like objects and arrays are implemented using references. The language does not provide any explicit pointer manipulation operators. It is still possible for code to attempt to dereference a null reference (null pointer), however, which results in a run-time exception being thrown. The space occupied by unreferenced memory objects is recovered automatically by garbage collection at run-time.

Modula-2
Pointers are implemented very much as in Pascal, as are VAR parameters in procedure calls. Modula-2 is even more strongly typed than Pascal, with fewer ways to escape the type system. Some of the variants of Modula-2 (such as Modula-3) include garbage collection.

Oberon
Much as with Modula-2, pointers are available. There are still fewer ways to evade the type system and so Oberon and its variants are still safer with respect to pointers than Modula-2 or its variants. As with Modula-3, garbage collection is a part of the language specification.

Pascal
Unlike many languages that feature pointers, standard ISO Pascal only allows pointers to reference dynamically created variables that are anonymous and does not allow them to reference standard static or local variables. It does not have pointer arithmetic. Pointers also must have an associated type and a pointer to one type is not compatible with a pointer to another type (e.g. a pointer to a char is not compatible with a pointer to an integer). This helps eliminate the type security issues inherent with other pointer implementations, particularly those used for PL/I or C. It also removes some risks caused by dangling pointers, but the ability to dynamically let go of referenced space by using the dispose standard procedure (which has the same effect as the free library function found in C) means that the risk of dangling pointers has not been entirely eliminated.

However, in some commercial and open source Pascal (or derivatives) compiler implementations —like Free Pascal, Turbo Pascal or the Object Pascal in Embarcadero Delphi— a pointer is allowed to reference standard static or local variables and can be cast from one pointer type to another. Moreover, pointer arithmetic is unrestricted: adding or subtracting from a pointer moves it by that number of bytes in either direction, but using the Inc or Dec standard procedures with it moves the pointer by the size of the data type it is declared to point to. An untyped pointer is also provided under the name Pointer, which is compatible with other pointer types.

Perl
The Perl programming language supports pointers, although rarely used, in the form of the pack and unpack functions. These are intended only for simple interactions with compiled OS libraries. In all other cases, Perl uses references, which are typed and do not allow any form of pointer arithmetic. They are used to construct complex data structures.

See also

 Address constant
 Bounded pointer
 Buffer overflow
 Cray pointer
 Fat pointer
 Function pointer
 Hazard pointer
 Iterator
 Opaque pointer
 Pointee
 Pointer swizzling
 Reference (computer science)
 Static program analysis
 Storage violation
 Tagged pointer
 Variable (computer science)
 Zero-based numbering

References

External links

PL/I List Processing Paper from the June, 1967 issue of CACM
cdecl.org A tool to convert pointer declarations to plain English
Over IQ.com A beginner level guide describing pointers in a plain English.
Pointers and Memory Introduction to pointers – Stanford Computer Science Education Library
Pointers in C programming  A visual model for the beginners in C programming
0pointer.de A terse list of minimum length source codes that dereference a null pointer in several different programming languages
"The C book" – containing pointer examples in ANSI C
.

Articles with example C code
Data types
Primitive types
American inventions

sv:Datatyp#Pekare och referenstyper

Pointer (computer programming)


Daniel Edward Howard (4 August 1861 – 9 July 1935) was the 16th president of Liberia, serving from 1912 to 1920.

Howard was elected president in 1911 and assumed office on 1 January 1912. With the outbreak of World War I, he attempted to maintain the country's neutrality, though he tended to support the Allies, whose colonial territories in Africa surrounded Liberia. Despite German protests, he allowed the French to operate a wireless station in the capital, Monrovia. Realizing that their complaints were in vain, the Germans sent a submarine to attack the city in 1917, forcing the reluctant Howard to side with the Allies and declare war on Germany.

Howard remained in office for two years after the war's end. He died in Monrovia in 1935.

Before Presidency
Born in the town of Buchanan, Grand Bassa County, Daniel Edward Howard was the son of Thomas Howard, chairman of the National True Whig Party and Treasurer of Liberia. He was educated at Liberia College.

He worked his way up through the civil service to become secretary of the True Whig Party, the country's only political party at the time. Howard was the Secretary of the Treasury before becoming the president.

Presidency (1912–1920)

Daniel Edward Howard was the President of Liberia from 1912 to 1920. The finances of Liberia were so shaky that the pay of government employees was often suspended for months at a time.

Rebellion of indigenous
In 1915, the coastal Kru people, who had long resisted Monrovia's authority, rose in rebellion, declaring their loyalty to Great Britain and demanding annexation by Crown Colony of Sierra Leone. In response, the United States diverted the USS Chester to Africa en route home from Turkey to help quash the uprising.

World War I

At the outbreak of World War I, President Howard attempted to maintain the country's neutrality.  However, he tended to support the Allies, whose colonial territories in Africa surrounded Liberia and whose naval superiority quickly disrupted trade with Germany.  As Germany was Liberia's major trading partner, the loss of customs revenue severely impacted government finances. What little revenue remained was diminished by the blockade imposed by German submarines which effectively halted trade between Liberia and the Allies as well. Since Liberia's economy was almost completely dependent on export revenues, this sudden evaporation of customs revenues forced Liberia to postpone payment on the $1.7 million loan, and led President Daniel E. Howard to seek a $5 million loan from the Woodrow Wilson Administration. However, the United States Congress refused to approve the loan.

Despite German protests, Howard allowed the French to operate a wireless station in the capital, Monrovia. Realizing that their complaints were in vain, the Germans sent a submarine to attack the city in 1917, forcing the reluctant Howard to side with the Allies and declare war on Germany on 12 January 1918.

Liberia then liquidated the property of German nationals in Liberia. The money generated from this liquidation was deposited into the Liberian government bank account to compensate for loss of revenue from the blockade. The war ended in 1918, and Liberia's legislature ratified the Treaty of Versailles.

Territorial conflicts
In 1919, Liberia became a charter member of the League of Nations.

Conflicts over territorial claims again resulted in the loss of land to Britain and/or France in 1919. Whenever the British and French seemed intent on enlarging at Liberia's expense the neighboring territories they already controlled, periodic appearances by U.S. warships helped discourage encroachment, even though successive American administrations rejected appeals from Monrovia for more forceful support.

See also
History of Liberia

References

Further reading
see History of Liberia, further reading

External links
see History of Liberia, external links

Americo-Liberian people
1861 births
1935 deaths
Presidents of Liberia
Finance Ministers of Liberia
True Whig Party politicians
People from Buchanan, Liberia
University of Liberia alumni
20th-century Liberian politicians
20th-century presidents in Africa

Daniel Edward Howard


Lost Lagoon is an artificial, captive 16.6-hectare (41 acre) body of water, west of Georgia Street, near the entrance to Stanley Park in Vancouver, British Columbia, Canada. Surrounding the lake is a  trail. The lake features a lit fountain that was erected by Robert Harold Williams to commemorate the city's golden jubilee. It is a nesting ground to many species of birds, including non-native mute swan (whose wing tendons have been clipped to prevent escaping), Canada geese, numerous species of ducks, such as mallard ducks, and great blue herons.  Also many turtles are usually resident on the northern shore.

Naming and history
Native food gatherers used the low tide mudflats as a source for clams, and a midden on the north side indicates that a large dwelling once stood there.  In the Squamish language, the name is Ch'ekxwa'7lech, meaning "gets dry at times".  Settlers also built cabins around the lake, which were all removed between 1913 and 1916 during construction of the causeway. The lake was created in 1916 by the construction of the Stanley Park causeway; until then, Lost Lagoon was a shallow part of Coal Harbour, which itself is an extension of Burrard Inlet.

The name for Lost Lagoon comes from a poem written by Pauline Johnson, who later explained her inspiration:

The lake was officially named Lost Lagoon in 1922 by the park board, long after Johnson's death and, ironically, after the lagoon had been permanently lost after becoming landlocked.

Development
When the causeway was first proposed in 1909, an intense public debate took place over the fate of the basin. As with most of the early controversies concerning the use of Stanley Park, organized labour was pitted against the more upper and middle class proponents of the City Beautiful movement. Trade union representatives argued that the majority working class population was in need of recreational facilities, while their opponents maintained that more aesthetic or ethereal considerations should take precedence in park development. The Vancouver Trades and Labour Council was adamantly opposed to the idea of an artificial lake, and argued for it to instead be filled in for use as a sports field. The park board retained the services of T. Mawson and Associates, an architectural landscaping firm that had designed the park's zoo and many other facilities in Stanley Park. The proposal the board settled on featured an artificial lake with a sports stadium on the northwest side and a large museum on the southwest shore. The $800,000 price tag, however, proved too steep for the board's budget, and the non-lake parts of the proposal were quashed.

The next phase in the lake's development came in 1929, when the saltwater pipes entering from Coal Harbour were shut off, turning it into a freshwater lake. The BC Fish and Game Protection Association was given permission to stock the lake with trout. The Stanley Park Flyfishing Association was formed, and charged members to fish in the lake, while the park board profited from the canoe and boat rentals. This came to an end in 1938 when the walkway around the lake was constructed and the area declared a bird sanctuary. Civic budgets were significantly reduced during the depression, but the park board benefited from the free labour of relief recipients, who were used to landscape Lost Lagoon.

The next controversy surrounding the lake followed the proposal for a fountain to be erected in the lake to coincide with the city's Golden Jubilee anniversary celebrations in 1936. For the mayor, it would be "a miracle of engineering," with the spray of water lit by virtually "limitless combinations" of colour. The public, in contrast, were not impressed by the proposal. Its $33,019.96 price tag was considered extremely frivolous in the midst of an economic crisis. As written in The Sunday Sun Edition of the Vancouver Sun Newspaper, Saturday, August 8. 1936. The lead story in the Magazine section is; SECRETS OF THE FOUNTAIN. It was the conception and idea of then, Chief Electrical Engineer, Robert Harold Williams with Hume and Rumble Ltd. electrical contractors. R.Harold Williams designed and supervised the erection of the Vancouver's Golden Jubilee fountain. After a business trip to Los Angeles he saw a fountain and thought this would be a great gift for the city for their up and coming birthday, Golden Jubilee celebration. To build the fountain, Lost Lagoon was drained. Seventy piles were driven into the mud. On these a concrete mat was laid. The fountain was built upon this mat. The work was of necessity rushed; it was done in a month. "The fountain is worthy of all the traditions of art, worthy of Vancouver's Golden Jubilee, and it will be a permanent, decorative joy in Stanley Park". "When operating , it is like a symphony concert, in motion and color instead of music, says Harold Williams, engineer, of Hume & Rumble Ltd., under whose personal supervision the work has been done."  Vancouver's Jubilee Committee and private citizens who contributed are to be commended on their work in pushing for this beautiful fountain, which is sure to be one of the major attractions during the Golden Jubilee celebration. "We've had to hurry," says Mr. Williams," in that time 285 tons of cement have been utilized and all the special equipment was built."  All equipment was built in Canada and the pumps were constructed in Vancouver. All union labor was employed. It was restored for Expo in 1986.

Lost Lagoon is a popular place for park users for strolling the perimeter trail and bird watching. On the southeast corner of the lake is the Lost Lagoon Nature House, an old boathouse that is now an interpretive centre for the Stanley Park Ecology Society. While rare in recent decades, Lost Lagoon can freeze during a cold spell, permitting public ice skating and ice hockey.

See also
 Bodies of water in Vancouver

Notes

History of Vancouver
Lakes of the Lower Mainland
Stanley Park
New Westminster Land District

Lost Lagoon


Charles Alexander (Karl Alexander August Johann; 24 June 1818 – 5 January 1901) was the ruler of Saxe-Weimar-Eisenach as its grand duke from 1853 until his death.

Biography
Born in Weimar, Karl Alexander was the second but eldest surviving son of Karl Frederick, Grand Duke of Saxe-Weimar-Eisenach and Grand Duchess Maria Pavlovna of Russia. His mother engaged as tutor for Karl the Swiss scholar Frédéric Soret who became a close acquaintance to Johann Wolfgang von Goethe.

When he was the Hereditary Grand Duke, Karl Alexander established a strong friendship with Fanny Lewald and Hans Christian Andersen, but this close relationship stopped in 1849 for the war against Denmark over the duchies of Schleswig-Holstein (the First Schleswig War). On 8 July 1853 his father died, and Karl Alexander became Grand Duke; however, he postponed his constitutional accession until Goethe's birthday, on 28 August 1853.

The Danish author and poet Hans Christian Andersen was reportedly infatuated with Karl Alexander, writing "I quite love the young duke, he is the first of all princes that I really find attractive".
Karl Alexander renovated Wartburg Castle and left his traces in many places in Eisenach. He was the protector of Richard Wagner and Franz Liszt, retained the tradition of Weimar's classical period, and gave the old part of Weimar a new and better appearance with the establishment of the Herder monument and the double monument for Goethe and Schiller. In 1860, he founded the Grand-Ducal Saxon Art School in Weimar (with Arnold Böcklin, Franz von Lenbach, and the plastic artist Reinhold Begas). As Grand Duke he was automatically rector, or president, of the University of Jena, where he supported especially the collections, among them prominently the Oriental Coin Cabinet.

In the Franco-Prussian War (1870–1871), Karl Alexander participated only in "Samaritan"; he stressed, however, for his entrance into the war in favor of Schleswig in 1849. The Weimar Congress of the Goethe Federation (opposing the Lex Heinze) occurred towards the end of his reign, in November 1900. That congress described his government as the Silver Age of Weimar.

In late December 1900, Karl Alexander reportedly fell ill with influenza. His condition soon worsened, becoming complicated with inflammation of the lungs and a slowing heart rate before the end of the month. He died at Weimar on 5 January 1901. Following his death, he was succeeded as Grand Duke by his grandson Wilhelm Ernst, his only son Carl August having predeceased him.

Family and children

At Kneuterdijk Palace in The Hague, on 8 October 1842, Karl Alexander married his first cousin, Princess Sophie of the Netherlands, daughter of William II and Grand Duchess Anna Pavlovna of Russia, sister of his mother. They had four children:
Karl August Wilhelm Nicolaus Alexander Michael Bernhard Heinrich Frederick Stefan, Hereditary Grand Duke of Saxe-Weimar-Eisenach (b. Weimar, 31 July 1844 – d. Cap Martin, France, 20 November 1894).
Marie Anna Alexandrine Sophie Auguste Helene (b. Weimar, 20 January 1849 – d. Trebschen, 6 May 1922), known as Marie; married on 6 February 1876 to Prince Heinrich VII Reuss of Köstritz.
Maria Anna Sophia Elisabeth Bernhardine Ida Auguste Helene (b. Weimar, 29 March 1851 – d. Weimar, 26 April 1859), known as Anna.
Elisabeth Sibylle Maria Dorothea Anna Amalie Luise (b. Weimar, 28 February 1854 – d. Wiligrad, 10 July 1908), known as Elisabeth; married on 6 November 1886 to Duke Johann Albrecht of Mecklenburg-Schwerin.

Honours and awards
He received the following awards:
German honours

Foreign honours

Ancestry

References

External links

1818 births
1901 deaths
People from Saxe-Weimar-Eisenach
Princes of Saxe-Weimar-Eisenach
Protestant monarchs
Hereditary Grand Dukes of Saxe-Weimar-Eisenach
Nobility from Weimar
Grand Dukes of Saxe-Weimar-Eisenach
Hans Christian Andersen
Grand Crosses of the Order of Saint Stephen of Hungary
Knights of the Golden Fleece of Spain

Charles Alexander, Grand Duke of Saxe-Weimar-Eisenach


This is a list of Ceylonese executive councils from its inception on 13 March 1833 until the creation of the Board of Ministers in 1931.

The Executive Council created in British Ceylon by the British colonial administration on the recommendations of the Colebrooke-Cameron Commission along with the Legislative Council of Ceylon as the legislative body.

At its creation the Executive Council was headed by the Governor, along with five members appointed by the Governor. These five members were officials who held the posts of the Colonial Secretary, the Attorney General, the Auditor-General, the Treasurer and the General Officer Commanding, Ceylon. The Council exercised executive power and advised the governor. As a result of the First Manning Reforms three non-officials were elected to the executive council.

Executive Councils

Dissolution
With enactment of the new constitution of the Dominion of Ceylon in 1947 the Board of Ministers was replaced by a National Cabinet.

See also

 Cabinet of Sri Lanka
 List of Sri Lankan cabinets

References

Sri Lanka politics-related lists
1833 establishments in Ceylon
1947 disestablishments in Ceylon

List of Ceylonese executive councils


Shu was the ancient Egyptian god of dry air, and so was a calming and cooling influence. He was also like Atlas from Greek mythology—his job was to separate Nut and Geb

Power and Magic
Shu had warlike traits like strength, speed and stamina and became associated with the pharaoh. He takes a human form wearing a plume (the hieroglyph of his name) on his head and with his arms raised supporting the sky-goddess. Nut to keep her apart from her consort the earth god Geb. Shu was described as dwelling in the sun's disk.  He often appeared as a bearded man holding up the sky while protecting the earth.  At times he was depicted as a lion or a human with a lion's head.  At other times he wore four ostrich feathers.  These feathers symbolized the four columns that held up the sky when Shu himself was not there to do the job.  When in his role as god of light, Shu carried a sun disk.

Hymn
"That is my daughter, the living female one, Tefnut, who shall be with her brother Shu. Life is his name, Order is her name. [At first] I lived with my two children, my little ones, the one before me, the other behind me. Life reposed with my daughter Order, the one within me, the other without me. I rose over them, but their arms were around me." Was a hymn to Shu. Ancient Egyptians prayed to him for a good life and prayed to him for light. People worshipped Shu in prayers, hymns, and in a chapel. People gave him offerings. Shu appeared in tombs and temples. He was a well known god.

Temples
Shu belongs to the cosmic deities and as such no temples were dedicated to him.  Cosmic deity's were never worshipped in a personified form, therefore there was no need for temples to worshipped them.  A chapel was built to Shu, Atum, and Tefnut. No festivals has been historically verified Shu was worshipped through prayers and gatherings.

Worshipped
Shu was the god of the water, light, wind, and the atmosphere. He was also the god of dry air. Shu's name meant "dryness" or "emptiness".  Shu was mentioned in Coffin Texts and Pyramid Texts, but is not well known outside these religious texts until after the New Kingdom. During this time period, Shu became connected with the gods Onuris, Khonsu, and Soptu, and was worshipped along with them in their people. He was praised by some and not by others.

Myths
Ra created Shu. He was created when Ra said, "Shu the moisture", and then Shu was sneezed out of Ra's nostrils. There are many creation myths about how Ra was born. For example, an egg that hatched created Ra. Shu was one of the first deities.

Other websites
 touregypt.net
 pantheon.org
 ancientegypt.co.uk
 Egyptian Mythology and Religion

Egyptian gods and goddesses

Shu (Egyptian god)


Heparin is an anticoagulant (substance that stops blood clots) discovered by Jay McLean and William Henry Howell. It is generally injected under the skin or into veins. As of now it seems safe to use on pregnant people. It is identified as a glycosaminoglycan (long polysaccharide (the stuff that cells are made of) chains consisting of long repeating disaccharide chains.

The discoverers first extracted heparin from the guts of animals such as turkey, atlantic salmon, mice, and even humans. The specimen of choice is a fresh, nonhemolyzed (intact red blood cells is broken) plasma anticoagulated by fluorides. Overdose can cause heparin-caused thrombocytopenia, a condition where white blood cells attack platelets (the stuff in your blood that heal wounds), causing a slowed heal time, bad breakdown of tissue in the leg, heart infections, and strokes, none of which will be benign.

Heparin is rated one of the World Health Organization's List of Essential Medicines, showing its value and popularity and rate of success.

References

Blood

Heparin


The Essex Town Hall and TOHP Burnham Library is an exuberant Shingle Style building at 30 Martin Street in Essex, Massachusetts in the United States. Containing town offices, a public library and an auditorium, it was built in 1893-1894, and its architect was Frank W. Weston, of Boston and Malden, Massachusetts.

The new building was described in the March 1894 issue of The Library Journal:
Essex (Mass). Public Library, The new town-hall and library building was dedicated on the afternoon of Feb. 15. A large audience was present at the dedication exercises, which included an oration by Rev. D.O Mears, music, several short addresses, and the reading of poems. In the evening there was a concert, followed by dancing.

The building which combines town-hall and library has just been completed after plans by Frank W. Weston, a Malden architect. The lower story is built of field-stone, and the upper part, including the tower, of wood. The interior is finished in antique oak, and the walls are painted in hues of brown and yellow. In the upper story is situated the town-hall proper. It has a seating capacity for 550. There is a stage and a gallery which will allow of entertainments being given there. One-half of the lower floor is devoted to the library, and will accommodate several thousand books. From the entrance there is a hallway that turns abruptly to the right, and on this passage are doors leading to the offices of the selectmen, the treasurer, and other officials. There are three entrances to the building, the main entrance being through an attractive carriageway into a spacious vestibule.

In the tower is the clock, with chime-bells, which strike the hour, presented to the town by L. G. Burnham.

Both the land and the building were gifts of the late T.O.H.P Burnham, of Boston, who was a native of Essex. Mr. Burnham died in 1891, and by his will the town received $30,000, half of which was for the town and the other half for a public library. Previous to this the town had come into possession of $5000 through the will of the late Dr. J. D. Russ, also a native of Essex. It was decided to build the town-hall and the library together.

The building was added to the National Register of Historic Places in 2007.

See also
National Register of Historic Places listings in Essex County, Massachusetts

References

External links
 Essex Town Hall at Historic American Buildings Survey

Shingle Style architecture in Massachusetts
Government buildings completed in 1894
Library buildings completed in 1894
Libraries on the National Register of Historic Places in Massachusetts
Buildings and structures in Essex, Massachusetts
City and town halls on the National Register of Historic Places in Massachusetts
Libraries in Essex County, Massachusetts
Clock towers in Massachusetts
National Register of Historic Places in Essex County, Massachusetts
1894 establishments in Massachusetts


Ruben Agasievich Zakharian (, 14 July 1901 – 25 May 1992) was a Russian painter, who lived and worked in Leningrad. He was a member of the Leningrad Union of Artists, and regarded as one of the representatives of the Leningrad School of Painting.

Early life and education
Ruben Agasievich Zakharian was born on 14 July 1901 in Tiflis, Russia Empire.

In 1921 Ruben Zakharian entered in Tiflis drawing school (since 1922 – Tbilisi Academy of Arts), where he studied of Evgeny Lansere and Boris Fogel.

In 1923 he moved to Petrograd to continue art education in VKHUTEIN (The Leningrad Higher Institute of Industrial Art, formerly known as the High Art School under Imperial Academy of Arts; since 1944 known as the Repin Institute of Arts), where he studied under Kuzma Petrov-Vodkin and Alexander Karev.

In 1927 Ruben Zakharian graduated from the Leningrad Vkhutein. His graduation work was painting "Athletes".

Career
Since 1926 Ruben Zakharian has participated in art exhibitions. He painted portraits, landscapes, still lifes, sketches from the life. His personal exhibitions were in Leningrad in 1974, and in 1983.

In 1939 Ruben Zakharian was drafted into the Red Army and took part in the Winter War, and in the Great Patriotic War of the Soviet people against Nazi Germany and its allies. As a soldier he fought on the Leningrad Front. He was wounded and marked by military awards.

After demobilization in 1945, Ruben Zakharian gradually restoring skills. This is facilitated by extensive travels and hard work from nature.

In 1951 Ruben Zakharian has become a member of Leningrad Union of Artists.

In 1950–1970 years Ruben Zakharian has repeatedly visited the Caucasus and Black Sea, works in Gurzuf, at the Staraya Ladoga and Academic Dacha. In last years the artist has worked lot in the genre of decorative still life.

Ruben Agasievich Zakharian died in Saint-Petersburg on May 25, 1992. His paintings reside in Art museums and private collections in the Russia, Japan, France, in the U.S., Armenia, and other countries.

See also
 List of Russian artists
 List of 20th-century Russian painters
 List of painters of Saint Petersburg Union of Artists

References

Sources
 Artists of the USSR. Biography and Bibliography Dictionary. Volume 4, part 1. - Moscow: Iskusstvo, 1983. - p. 258.
 Directory of members of the Leningrad branch of Union of Artists of Russian Federation. - Leningrad: Khudozhnik RSFSR, 1987. - p. 47.
 Sots'Art a St Petersbourg. Catalogue. - St Germain en Laye: 23 Fevrier 1992. - p. 7.
 Matthew C. Bown. Dictionary of 20th Century Russian and Soviet Painters 1900-1980s. - London: Izomar, 1998. , .
 Sergei V. Ivanov. Unknown Socialist Realism. The Leningrad School. - Saint Petersburg: NP-Print Edition, 2007. – pp. 27, 81, 202, 361, 384, 385, 388–392, 394–397, 402–405, 413–422, 444. , .

1901 births
1992 deaths
20th-century Russian painters
Artists from Tbilisi
Leningrad School artists
Members of the Leningrad Union of Artists
People from Tiflis Governorate
Repin Institute of Arts alumni
Russian male painters
Russian people of Armenian descent
Russian people of World War II
Russian portrait painters
Socialist realist artists
Soviet military personnel of World War II
Soviet painters
20th-century Russian male artists

Ruben Zakharian


The Burgenland (Austro-Bavarian: Burgnlaund, Croatian: Gradišće, Hungarian: Felsőőrvidék, Őrvidék, Lajtabánság) is one of the nine federal states of the Federal Republic of Austria. It is the youngest of the nine states and came to Austria after the First World War in 1921. The name Vierburgenland (Land of Four Castles) was created in 1919. It was derived from the name of the four vármegye of the Kingdom of Hungary (in German Komitate, 'counties') known in Hungarian as Pozsony, Moson, Sopron and Vas, or in German as Pressburg, Wieselburg, Ödenburg and Eisenburg. Because Pressburg was given to Czechoslovakia, the number was dropped. In 1922 the name was adopted by the province assembly.

Geography

Burgenland has an area of 3961.80 km². It is divided into 3 regions (districts):
Nordburgenland (northern Burgenland): Eisenstadt, Eisenstadt-Umgebung, Neusiedl am See, Mattersburg and Rust
Mittelburgenland (middle Burgenland): Oberpullendorf
Südburgenland (southern Burgenland): Güssing, Jennersdorf and Oberwart
Sometimes Mittelburgenland is seen as a part of southern Burgenland.

The highest point of the state is the Geschriebenstein at 884 m, the lowest point is near Apetlon at 114 m. Burgenland and Hungary share the Neusiedler See. Leitha, Pulka and Raab are important rivers.

Minorities

Burgenland has Croatian (29,000 - 45,000) and Hungarian (5,000 - 15,000) populations. The Burgenland Croatian language is an 16th-century dialect which is different from standard Croatian. In former times there was also a Roma and Jewish population, but the Nazis destroyed them.
Languages in Burgenland
German 82,9 %
Burgenland Croatian 10,4 %
Hungarian 2,4 %

History
In 1043 a peace treaty between Henry III and King Samuel Aba of Hungary fixed the western border of the Kingdom of Hungary along the Leitha and Lafnitz rivers, among others. The territory of the present-day Burgenland became the western border-zone of the medieval Kingdom of Hungary until the 16th century. The majority of the population was Germanic. There was also immigration  in the Middle Ages from the neighbouring Austria. During occupation of Hungary by the Ottoman Empire some parts of today's Burgenland stayed within Habsburg rule. After the Austro-Hungarian  empire was formed in 1867 Burgenland was part of the Hungarian part of the monarchy. Because 74% of the inhabitants were of German origin the area came to the new formed Republic of Austria. In the time till the Second World War many people emigrated to the United States. It is said that Chicago is the largest town of the Burgenland.

During the Nazi occupation the state was part of Styria and Lower Danube. In addition to the oppression of the Jews, the ethnic groups Roma and Sinti also suffered under the Nazi regime. The  Lackenbach concentration camp for Gypsies was in the area.

After the Second World War Burgenland was part of the Soviet occupation zone. After the Staatsvertrag it had a long border to the communist area in eastern Europe. The economic development was very slow. After joining the European Union this development became faster.

Politics
Burgenland's provincial assembly (Landtag) has 36 seats.  The provincial government is a combination of Social Democratic Party (SPÖ) and the Austrian People's Party (ÖVP). The voting age for regional elections in Burgenland was reduced to 16 in 2003.

Landeshauptleute (governors)

Culture and tourism
The area's main attractions are the Neusiedler See (the lake), the hot springs at Lutzmannsburg, Stegersbach and Bad Tatzmannsdorf. There is also over 500 km of bicycle tracks in Also.

There are several events in summer:
 Seefestspiele Mörbisch is an operetta festival held on a stage on the lakeshore
 St. Margarethen Opera Festival is held across the town at venues like Schlossspiele Kobersdorf
 Burgspiele Güssing, a theatre festival
 Jennersdorf summer festival
 Several music festivals are held in Wiesen

References

Other websites
 Official website
 Burgenland Travel Guide
 Burgenland-Croatian Center

Burgenland


Eurocypria Airlines Limited was a charter airline with its head office in the Artemis Building in Larnaca, Cyprus, owned by the government of Cyprus, operating mostly chartered flights. Its main base was Larnaca International Airport, with a secondary base at Paphos International Airport. On 4 November 2010 it was announced that the airline would file for bankruptcy and cease all flights by 13 November. All flights were suspended by decision of the Board of Directors on 4 November 2010.

History

Eurocypria was established on 25 March 1992 as a wholly owned subsidiary of Cyprus Airways, as the first Cyprus based charter airline. Operations began on 12 June 1992 with two new Airbus A320 aircraft. Two more were added later. Since 2001, the airline has operated scheduled services from Cyprus, and charter flights.

In 2003 Eurocypria replaced its Airbus fleet with four new Boeing 737-800 aircraft. Three of its former Airbus A320s were transferred and operated by Cyprus Airways. Two additional units of the same type and configuration were added in 2006.

On 28 June 2006, Cyprus Airways sold the share capital of Eurocypria to the Government of Cyprus for CY£13,425,000. The charter arm was sold mostly due to the poor financial situation at Cyprus Airways and because it was one of the few ventures of Cyprus Airways Group to make a profit.

The airline has a long history of operating flights on behalf of Egyptian carrier AMC Airlines between Egypt and Europe.

Bailout
It was announced on 19 February 2010 that the Cyprus Government would inject €35m into Eurocypria's capitalization, to enable the airline to pay off €28m of owed debt and invest in the airline's future. Cyprus Airways stated Eurocypria should shut down as "a small island cannot withstand two state-owned airlines and if they're not shut down, we might both go bust", but the government declined this prospect and the House of Representatives went ahead with the bailout.

Yet the approval of the cash injection for Eurocypria was, as the 'Cyprus Mail' reported on 19 February 2010, "unlikely to be the final word". Anastasios Antoniou LLC, a Law Firm based in Limassol, filed an official complaint on 17 February 2010 with the European Commission regarding the proposed financing of Eurocypria on behalf of a client who wished to remain anonymous. As national daily 'Phileleftheros' reported on 19 February 2010 - based on its own sources - the complainant could be a competitor in the relevant market that has unsuccessfully attempted to enter the market. In a statement issued on 19 February 2010 in response to the media commentary, Anastasios Antoniou LLC explained that the capital injection on the part of the Republic of Cyprus is likely to be in violation of the applicable EU legislation regarding State Aid. The Firm pursued its complaint before the European Commission further in the following months, also filing a request for interim measures on behalf of the Commission pursuant to the provisions of Council Regulation (EC) No 659/1999.

In June 2010, it was unveiled that two reports, prepared in February 2010 before the capital injection had been approved, were opposed to the bailout. Made public by Finance Minister Charilaos Stavrakis on 10 June 2010, the two reports created a series of debates and rows with the island's political parties, who felt they were misled into approving the money. The first report, carried out by the Accountant-general on February 3, proposed a strict implementation of Eurocypria's business plan to reinforce its profit-making abilities. Meanwhile, it was proposed that a strategic investor be found. Failure to do so by mid-2010, it added, would lead to Eurocypria going bankrupt, in combination with some of its human and material resources being absorbed by national carrier Cyprus Airways. According to the Accountant-general, this would reduce the cost of bankruptcy from €84 million to €55 million. The second report - carried out by technocrats at the Finance Ministry and Planning Office – contradicted Finance Minister Charilaos Stavrakis' claims that the reports had nothing to do with the €35 million injection, as its conclusions were centred on the specific fund.

In September 2010, Minister of Finance Mr Stavrakis announced that a possible merge of operations between Cyprus Airways and Eurocypria Airlines was under consideration, in an attempt to staunch losses. These considerations were geared, after the disclosure of the 1H2010 troubled financial results of Cyprus Airways Ltd, in which the Government is the major shareholder. European Union rejected this possibility, and Eurocypria ceased operations in November 2010.

Destinations

All flights were suspended on 4 November 2010 and the company entered liquidation by decision of the board of directors.

Fleet

Eurocypria Airlines fleet consisted of the following aircraft as at 1 November 2010:

Eurocypria's aircraft were named after a wind and each featured a differently colored tailfin.

In July 2010, the average age of Eurocypria's fleet was 6.1 years.

On 3 September 2010, Eurocypria pilots went on strike due to the government's proposal of reducing Eurocypria's fleet to 4 aircraft in 2011. Finally, all operations ceased on 4 November 2010.

References

External links

Official website

Defunct airlines of Cyprus
Airlines established in 1992
Airlines disestablished in 2010
Government-owned airlines
1992 establishments in Cyprus
2010s disestablishments in Cyprus

Eurocypria Airlines


Vidal Sassoon International Center for the Study of Antisemitism (SICSA) () is a research center affiliated with the Hebrew University of Jerusalem. It was named for Vidal Sassoon, who financed its establishment in 1983.

The Vidal Sassoon center is as an interdisciplinary research center devoted to the independent, non-political accumulation and dissemination of materials related to antisemitism.  The director is Prof. Manuela Consonni who replaced Robert Wistrich after his death in 2015.

Over 120 studies have been conducted under the auspices of the center, covering a wide range of disciplines — history, psychology, sociology, anthropology, literature and art. The center awards Felix Posen Fellowships  to doctoral candidates whose dissertation focuses on some aspect of antisemitism.

Publications
The center has produced numerous publications, including book-length studies, collections of papers presented at conferences, occasional papers, and a journal.

The ACTA series is an annual report from a special SICSA research unit that provides in-depth analysis of current trends in antisemitism and explores the influence of anti-Jewish and anti-Zionist ideology on public opinion, and the arts, mass media, and political movements. Papers in this series are available in print and online.

As a supplement to the ACTA series, the Posen Papers aim to provide a more rapid response to issues of global antisemitism.  Antisemitism International is a  semi-annual research journal that focuses on topics of current importance.

In 1984, the Center initiated a bibliographic project on antisemitism. It comprises the most comprehensive computerized database of works published in most English and most European languages about antisemitism throughout the world in every period, including the events of the Holocaust. Each entry is accompanied by an English abstract.

A massive and increasing number of books and articles have been written on the topic since 1945; whether popular or scholarly, descriptive or interpretative. Prior to the establishment of the bibliographic project these publications were not listed in a way that permitted optimal use of them by scholars and students, as well as to enhance public awareness of the subject.

For the purpose of the bibliography, antisemitism is defined as antagonism toward Jews and Judaism as expressed in writings (i.e. in religious texts, polemical literature, and works of fiction), in the visual arts (i.e. art, caricatures, posters, and film), and in actions (i.e. massacres and pogroms, discriminatory legislation, and the Holocaust).

The online data base is accessible through the Israel University Inter-Library Network and the Center's website(go to "search the bibliography"). It also appears as a series of printed volumes entitled Antisemitism — An Annotated Bibliography published by K. G. Saur Verlag, Munich, Germany.

Conferences, symposia and lectures

Throughout the academic year, the Center sponsors international conferences on such topics as Demonizing the Other and Antisemitism and Multiculturalism. A number of lectures and presentations from its conferences are available as streaming audio and/or video files on the Center's website.

Monthly lectures on topics currently researched by scholars supported by or affiliated with the Center are held on the Hebrew University campus.

References

External links
 SICSA Official Website
 Official Facebook Page
 The Felix Posen Bibliographic Project on Antisemitism
Voices on Antisemitism Interview with Vidal Sassoon from the U.S. Holocaust Memorial Museum

Centers for the study of antisemitism
Education in Jerusalem
Hebrew University of Jerusalem
Israel based opposition to antisemitism


Morning Light is a 2008 film written and directed by Mark Monroe and executive produced by Roy E. Disney. The film was released on October 17, 2008 by Walt Disney Studios Motion Pictures. The film chronicles a real-life crew training and competing in the 44th Transpacific Yacht Race aboard a TP52 class sailing yacht, Morning Light.

Plot
Morning Light  is a documentary that follows the youngest crew (by average age) to compete in the Transpac. All crew members were between 18 and 23 at the time. The film follows the formation of the Morning Light sailing team, their six months of training in advance of the yacht race, and finally the weeklong Los Angeles to Honolulu race itself.

The crew numbered 15 young sailors of varied experience: Chris Branning, Graham Brant-Zawadzki, Chris Clark, Charlie Enright, Jesse Fielding, Robbie Kane, Steve Manson, Chris Schubert, Kate Theisen, Mark Towill (at 18, the youngest crew member), Genny Tulloch, navigator Piet van Os, Chris Welch, Kit Will and the 21-year-old skipper, Jeremy Wilmot.

Production
Executive producer Roy Disney was a sailing enthusiast and Transpac competitor who held several sailing speed records including the Los Angeles to Honolulu monohull time record, which he set on his boat Pyewacket in July 1999. The concept for the film came from TP52 Class Association executive director Tom Pollack, who passed it on to former ESPN producer Leslie DeMeuse, who has worked with Disney on other sailing-related film projects.

In early 2006, Roy E. Disney, longtime sailing master Robbie Haines and DeMeuse considered 538 applications and picked 30 finalists, from which 15 were chosen in a week of selection trials in Long Beach, California. Training began in Honolulu, Hawaii in January 2007, for two weeks at a time through late June, with time off in May. The
team trained aboard the Morning Light, which Disney purchased from software executive Philippe Kahn. Filming coincided with training and the race itself, which started July 15, 2007 and concluded ten days later.

Release
The film was released on October 17, 2008. Prior to theatrical release, private screenings were held for yacht racing enthusiasts, including one hosted by Roy  E. Disney for U.S. Sailing on March 14, 2008 in Newport, Rhode Island.

References

External links

 An Interview with Roy Disney about the Morning Light Project
 Account of filming at SailTexas.com

2008 films
2000s adventure films
2008 documentary films
Disney documentary films
American documentary films
Competitive sailing films
Seafaring films based on actual events
Walt Disney Pictures films
2000s English-language films
2000s American films

Morning Light (film)


The pianola (pronounce: "pee-ah-NO-la"), also called the player piano, is a piano which has a pneumatic mechanism  so that it can play by itself. The air for this system came from a pump operated by the player's feet, and in some later models, an electric pump. Inside the piano are paper rolls which have holes punched in them. These holes release air which in turn triggers the keys to play. When the pianola plays itself the keys of the piano can be seen "playing themselves".

The pianola was developed around the 1880s. It was fitted with control levers so that the player ("player pianist" or "pianolist") could play in the way he wanted. The pianola made it possible for the player to sound as if he was playing very difficult music that he was not capable of playing. At the same time he could control the performance.

The pianola became popular in the late 19th and early 20th century as mass-produced pianos became popular in people's homes and more and more people bought sheet music.  By the 1920s it started to become less popular again as the gramophone had been invented.

A pianola is the same as any other piano except it is fitted with a pneumatic player action, which plays paper rolls. This mechanism consists of about one hundred bellows, large and small, the smaller ones being called pneumatics of which there are 88, one for each note on the piano.The largest are the foot operated ones,called the bellows. Other pneumatics of varying sizes operate the roll motor, tracking device, motor speed governor, and the sustain and soft pedals.

Percussion instruments

Pianola