Metaprogramming

Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data. It means that a program can be designed to read, generate, analyze or transform other programs, and even modify itself while running. In some cases, this allows programmers to minimize the number of lines of code to express a solution, in turn reducing development time. It also allows programs greater flexibility to efficiently handle new situations without recompilation.
Metaprogramming can be used to move computations from run-time to compile-time, to generate code using compile time computations, and to enable self-modifying code. The ability of a programming language to be its own metalanguage is called reflection. Reflection is a valuable language feature to facilitate metaprogramming.
Metaprogramming was popular in the 1970s and 1980s using list processing languages such as LISP. LISP hardware machines were popular in the 1980s and enabled applications that could process code. They were frequently used for artificial intelligence applications.
Approaches.
Metaprogramming enables developers to write programs and develop code that falls under the generic programming paradigm. Having the programming language itself as a first-class data type (as in Lisp, Prolog, SNOBOL, or Rebol) is also very useful; this is known as "homoiconicity". Generic programming invokes a metaprogramming facility within a language by allowing one to write code without the concern of specifying data types since they can be supplied as parameters when used.
Metaprogramming usually works in one of three ways.
Lisp is probably the quintessential language with metaprogramming facilities, both because of its historical precedence and because of the simplicity and power of its metaprogramming. In Lisp metaprogramming, the unquote operator (typically a comma) introduces code that is evaluated at program definition time rather than at run time; see Self-evaluating forms and quoting in Lisp. The metaprogramming language is thus identical to the host programming language, and existing Lisp routines can be directly reused for metaprogramming, if desired. This approach has been implemented in other languages by incorporating an interpreter in the program, which works directly with the program's data. There are implementations of this kind for some common high-level languages, such as RemObjects’ Pascal Script for Object Pascal.
Usages.
Code generation.
A simple example of a metaprogram is this POSIX Shell script, which is an example of generative programming:
echo '#!/bin/sh' > program
for i in $(seq 992)
do
 echo "echo $i" » program
done
chmod +x program
This script (or program) generates a new 993-line program that prints out the numbers 1–992. This is only an illustration of how to use code to write more code; it is not the most efficient way to print out a list of numbers. Nonetheless, a programmer can write and execute this metaprogram in less than a minute, and will have generated over 1000 lines of code in that amount of time.
A quine is a special kind of metaprogram that produces its own source code as its output. Quines are generally of recreational or theoretical interest only.
Not all metaprogramming involves generative programming. If programs are modifiable at runtime or if incremental compilation is available (such as in C#, Forth, Frink, Groovy, JavaScript, Lisp, Elixir, Lua, Perl, PHP, Python, REBOL, Ruby, Rust, SAS, Smalltalk, and Tcl), then techniques can be used to perform metaprogramming without actually generating source code.
One style of generative approach is to employ domain-specific languages (DSLs). A fairly common example of using DSLs involves generative metaprogramming: lex and yacc, two tools used to generate lexical analyzers and parsers, let the user describe the language using regular expressions and context-free grammars, and embed the complex algorithms required to efficiently parse the language.
Code instrumentation.
One usage of metaprogramming is to instrument programs in order to do dynamic program analysis.
Behavioral changes.
Metaprogramming can be used to weave behavioral changes in a program, as done in aspect-oriented programming. For instance, metaprogramming can be used to inject feature flags or to explore possible patches for fixing bugs.
Challenges.
Some argue that there is a sharp learning curve to make complete use of metaprogramming features. Since metaprogramming gives more flexibility and configurability at runtime, misuse or incorrect use of the metaprogramming can result in unwarranted and unexpected errors that can be extremely difficult to debug to an average developer. It can introduce risks in the system and make it more vulnerable if not used with care. Some of the common problems which can occur due to wrong use of metaprogramming are inability of the compiler to identify missing configuration parameters, invalid or incorrect data can result in unknown exception or different results. Due to this, some believe that only high-skilled developers should work on developing features which exercise metaprogramming in a language or platform and average developers must learn how to use these features as part of convention.
Uses in programming languages.
Macro assemblers.
The IBM/360 and derivatives had powerful macro assembler facilities that were often used to generate complete assembly language programs or sections of programs (for different operating systems for instance). Macros provided with CICS transaction processing system had assembler macros that generated COBOL statements as a pre-processing step.
Other assemblers, such as MASM, also support macros.
Metaclasses.
Metaclasses are provided by the following programming languages:
Dependent types.
Usage of dependent types allows proving that generated code is never invalid. However, this approach is bleeding-edge and is rarely found outside of research programming languages.
Implementations.
The list of notable metaprogramming systems is maintained at List of Program Transformation Systems.


Michael Loew

Michael Loew (May 8, 1907 — November 14, 1985) was an American Abstract Expressionist artist who was born in New York City.
Career.
In the late 1920s, Loew studied at the Art Students League with the Ashcan School and was a recipient of a Sadie A. May Fellowship which allowed Loew to continue his studies in France. Michael worked for New Deal art projects from 1933–37 and during this time painted murals for U.S. post offices, high schools and the Hall of Pharmacy for the 1939 New York World's Fair. Loew chose to share his private commission with close friend and fellow artist, Willem de Kooning.
From 1939 to 1940 Loew traveled to Mexico and the Yucatán, gathering inspiration for his future work. Joining the U.S. Navy Seabees in 1943 as a Battalion Painter, Loew documented the work being done on the airbase on Tinian Island. It was from this airbase that the Enola Gay would later take off from to drop the atomic bombs. Loew captured much of the work done on the island by the Navy in dozens of watercolors.
Returning to New York after the war, having lost much of his hearing, Loew started over with his art studies. He studied with Hans Hofmann in New York and Provincetown, and with Fernand Léger in Paris. Loew became a member of the American Abstract Artists and The Artist's Club as well as The Spiral Group. His works were shown at the Stable Gallery Annuals of 1951–1955.
In 1960 and again in 1966, Loew was hired to teach at the University of California, Berkeley. He also spent nearly three decades as a teacher at the School of Visual Arts. In 1976 he won a fellowship grant from the National Endowment for the Arts and in 1979 he was awarded a grant from the Guggenheim Foundation.
Over the course of his life, Michael's work was exhibited extensively in galleries, museums and other cultural institutions including: The Solomon R. Guggenheim Museum, The Dallas Museum of Art, The Whitney Museum of American Art, The Philadelphia Museum of Art and The Hirshhorn Museum and Sculpture Garden. The Michael Loew Papers are located in the Archives of American Art at the Smithsonian Institution. His works have been exhibited in galleries including the Anita Shapolsky Gallery in New York City and the Thomas McCormick Gallery.
In 1997 his estate was awarded the Judith Rothschild Foundation Grant.


Luis Merino

Luis Merino (born September 17, 1942 in Mexico City, Mexico) is a Mexican/Canadian painter. His work can be found in numerous public and private collections in Canada, Mexico, and the United States. Some of his most notable work is on display in the Maltwood Art Museum and Gallery, at the University of Victoria in Greater Victoria, British Columbia, Canada.
Biography.
Luis Merino was born in Mexico City, Mexico in 1942. At an early age, Luis knew he wanted to be a painter. When he was 16, he studied at the prestigious Academy of San Carlos in Mexico City. During this time, Merino intensified his study in oil painting. Following visits to various museums and exhibits throughout the city, he developed an affinity for Mexican, American, and European modernism.
In 1968, Luis Merino attended the Instituto Allende in San Miguel de Allende, Guanajuato, Mexico. While in school, he was taught by American/Yugoslavian abstract painter James Pinto. In his final semester, Merino accepted Pinto's invitation to teach life-drawing at the institute.
Upon immigrating to Canada in 1970, Merino began to reveal influences of cubism in his paintings, which can still be seen in his work to this day.
In 1972, Merino moved to Victoria, British Columbia with his wife, Sandra, and became a prominent member of the arts community. Luis remained active in the community by painting murals inside of public buildings, displaying his art in local galleries, and regularly organizing exhibitions for fellow artists.
Influences.
Merino's earliest influences were from Mexican muralism in particular Diego Rivera. He also places an emphasis on "peaceable content" that resonates with the post-revolution painters Pedro Coronel and Rufino Tamayo. Additionally, Luis cites the "humanism which had underlain much existential discourse in the 1960s" as a significant influence. Since the 1970s, Merino's work has been largely influenced by his affinity for the early, analytic cubism of Braque and Picasso. In the 1980s, he began to incorporate the "female form in expressions of sensuality, harmony, complexity and inner mystery", which has remained a consistent theme in most of his work to this day. In this regard Merino's work has parallels with that of Modigliani. This combination of abstraction from cubism with the figure results in a style of painting best described as Figurative Abstraction.
Work.
Currently, Luis Merino has a number of his paintings on display in the Maltwood Art Museum and Gallery at the University of Victoria in Greater Victoria, British Columbia, Canada. The most notable of these pieces are "Bar Maids III" (1990) and "Frida" (1990-1991).


Lazarus Goldschmidt

Lazarus Goldschmidt (born at Plungė, December 17, 1871; died in England, April 18, 1950) was a Lithuanian-born German Jewish writer and translator. He translated the Babylonian Talmud into German, and was the first to translate the entire Babylonian Talmud.
He received his rabbinical education at the Talmudic school in Slobodki, near Kovno. In 1888 he went to Germany, and in 1890 entered the Berlin University, where, under the guidance of Professors Dillmann and Schrader, he devoted himself to the study of Oriental languages, especially Ethiopic.
By 1903, Goldschmidt, living at the time in Berlin, had published the following works: ""Das Buch Henoch"," retranslated from the Ethiopic into Hebrew, and edited with introduction, notes, and explanations (Berlin, 1892); ""Bibliotheca Aethiopica"," a list and description of all the known Ethiopic prints (Leipsic, 1893); ""Das Buch der Schöpfung" (ספר יצירה)," critical text, translation notes, etc. (Frankfort-on-the-Main, 1894); ""Baraita de-Ma'ase Bereshit"," the story of the Creation, ascribed to Arzelai bar Bargelai (Strasburg, 1894; this supposed Midrash is an Aramaic translation of the Ethiopic "Hexaemeron" of Pseudo-Epiphanias, edited by Trumpp in Ethiopic with a German translation, Munich, 1882, and the name of the supposed author is an anagram of Goldschmidt's Hebrew name, Eliezer ben Gabriel); ""Vita do Abba Daniel"," Ethiopic text, published, translated, and annotated in collaboration with F. M. E. Pereira (Lisbon, 1897); ""Die Aethiopischen Handschriften der-Stadtbibliothek zu Frankfurt a. M." (Berlin, 1897). In the year 1896 Goldschmidt commenced the publication of the Babylonian Talmud (from the editio princeps), with German translation, variants, and explanations. By 1903, the sections Zera'im and Mo'ed have been published, together with a part of the section Neziḳin. Both the edition of the text and the translation have been severely criticized by David Hoffmann in Brody's "Zeitschrift für Hebräische Bibliographie"," i. 67-71, 100-103, 152-155, 181-185. Goldschmidt replied in a pamphlet, ""Die Recension des Herrn Dr. D. Hoffmann über Meine Talmudausgabe im Lichte der Wahrheit"," Charlottenburg, 1896. See also ""Theologische Literaturzeitung"," 1896, pp. 477-479, and 1897, pp. 631-633.
His translation of the Babylonian Talmud appeared from Leipzig 1897 to completion in London 1935.


Hirotaka Kajiura

 is a Japanese professional shogi player ranked 7-dan.
Early life.
Kajiura was born in the Shinjuku ward of Tokyo, Japan on July 6, 1995. He learned how to play shogi from his father when he was about five years old, and eventually entered the Japan Shogi Association's apprentice school at the rank of 6-kyū under the tutelage of shogi professional Daisuke Suzuki in 2008. He was promoted to the rank of 3-dan in 2012 and then obtained full professional status and the rank of 4-dan after finishing in second place in the 56th 3-dan League with a record of 13 wins and 5 losses.
Promotion history.
The promotion history for Kajiura is as follows.


Marika Nakamura

 is a Japanese women's professional shogi player ranked 3-dan.
Promotion history.
Nakamura's promotion history is as follows.
Note: All ranks are women's professional ranks.
Titles and other championships.
Nakamura has appeared in women's major title match three times, but has yet to win a major title. She was the challenger for the 17th title in 2009, the 34th in 2012 and the 40th in 2013.


Evelyn Buff-Segal

Evelyn Buff-Segal (1913-2000) was an abstract expressionist painter who lived and worked in Rochester, NY.
Early life.
Evelyn E. Buff was born as a twin in 1915, in Lowville, Lewis County, New York to Fannie (née Landsman) and Louis R. Buff.
Originally a student of architect Fritz Traut, she began studying under Vanclive Vitleture after meeting him during a visit to Martha's Vineyard in the late 1940s. He encouraged her to move to NYC and attend the prestigious Arts Students League on 57th Street, where she met Robert Rauschenberg. In a 1975 interview for the Rochester Oral History Project, Buff-Segal recalls that Robert Rauschenberg "had the easel to my right." and that among her other classmates at the time were both Paul Jenkins and Robert Cartwright.
As a mature artist she split her time between New York and Paris and was known for her compositions inspired by visits to Nigeria with her husband Dr. Harry J. Segal. In 1951 a special exhibition of these works entitled "Home to Nigeria" was featured at the College of Visual Arts in Syracuse, NY. That same year she founded the Rochester Arts Council (one of only three such groups in the country at the time) and served as its president until 1959. She also founded Rochester's 'Arena Arts Group' and served as director and co-founder of The Little Gallery.
Her work has been displayed at the Corcoran Gallery of Art in Washington, DC and the former Greer Gallery in NYC. Several pieces reside as part of the permanent collection of Emily Lowe Gallery at Syracuse University as well as in numerous private collections both in America and Europe.


Binary heap

A binary heap is a heap data structure that takes the form of a binary tree. Binary heaps are a common way of implementing priority queues. The binary heap was introduced by J. W. J. Williams in 1964, as a data structure for heapsort.
A binary heap is defined as a binary tree with two additional constraints:
Heaps where the parent key is greater than or equal to (≥) the child keys are called "max-heaps"; those where it is less than or equal to (≤) are called "min-heaps". Efficient (logarithmic time) algorithms are known for the two operations needed to implement a priority queue on a binary heap: inserting an element, and removing the smallest or largest element from a min-heap or max-heap, respectively. Binary heaps are also commonly employed in the heapsort sorting algorithm, which is an in-place algorithm because binary heaps can be implemented as an implicit data structure, storing keys in an array and using their relative positions within that array to represent child-parent relationships.
Heap operations.
Both the insert and remove operations modify the heap to conform to the shape property first, by adding or removing from the end of the heap. Then the heap property is restored by traversing up or down the heap. Both operations take O(log "n") time.
Insert.
To add an element to a heap, we can perform this algorithm:
Steps 2 and 3, which restore the heap property by comparing and possibly swapping a node with its parent, are called "the up-heap" operation (also known as "bubble-up", "percolate-up", "sift-up", "trickle-up", "swim-up", "heapify-up", or "cascade-up").
The number of operations required depends only on the number of levels the new element must rise to satisfy the heap property. Thus, the insertion operation has a worst-case time complexity of O(log "n"). For a random heap, and for repeated insertions, the insertion operation has an average-case complexity of O(1).
As an example of binary heap insertion, say we have a max-heap
and we want to add the number 15 to the heap. We first place the 15 in the position marked by the X. However, the heap property is violated since , so we need to swap the 15 and the 8. So, we have the heap looking as follows after the first swap:
However the heap property is still violated since , so we need to swap again:
which is a valid max-heap. There is no need to check the left child after this final step: at the start, the max-heap was valid, meaning the root was already greater than its left child, so replacing the root with an even greater value will maintain the property that each node is greater than its children (; if , and , then , because of the transitive relation).
Extract.
The procedure for deleting the root from the heap (effectively extracting the maximum element in a max-heap or the minimum element in a min-heap) while retaining the heap property is as follows:
Steps 2 and 3, which restore the heap property by comparing and possibly swapping a node with one of its children, are called the "down-heap" (also known as "bubble-down", "percolate-down", "sift-down", "sink-down", "trickle down", "heapify-down", "cascade-down", "extract-min" or "extract-max", or simply "heapify") operation.
So, if we have the same max-heap as before
We remove the 11 and replace it with the 4.
Now the heap property is violated since 8 is greater than 4. In this case, swapping the two elements, 4 and 8, is enough to restore the heap property and we need not swap elements further:
The downward-moving node is swapped with the "larger" of its children in a max-heap (in a min-heap it would be swapped with its smaller child), until it satisfies the heap property in its new position. This functionality is achieved by the Max-Heapify function as defined below in pseudocode for an array-backed heap "A" of length "length"("A"). Note that "A" is indexed starting at 1.
 // Perform a down-heap or heapify-down operation for a max-heap
 // "A": an array representing the heap, indexed starting at 1
 // "i": the index to start at when heapifying down
 Max-Heapify("A", "i"):
 "left" ← 2×"i"
 "right" ← 2×"i" + 1
 "largest" ← "i"
 if "left" ≤ "length"("A") and "A"["left"] > A["largest"] then:
 "largest" ← "left"
 if "right" ≤ "length"("A") and "A"["right"] > "A"["largest"] then:
 "largest" ← "right"
 if "largest" ≠ "i" then:
 swap "A"["i"] and "A"["largest"]
 Max-Heapify("A", "largest")
For the above algorithm to correctly re-heapify the array, no nodes besides the node at index "i" and its two direct children can violate the heap property. The down-heap operation (without the preceding swap) can also be used to modify the value of the root, even when an element is not being deleted.
In the worst case, the new root has to be swapped with its child on each level until it reaches the bottom level of the heap, meaning that the delete operation has a time complexity relative to the height of the tree, or O(log "n").
Insert then extract.
Inserting an element then extracting from the heap can be done more efficiently than simply calling the insert and extract functions defined above, which would involve both an upheap and downheap operation. Instead, we can do just a downheap operation, as follows:
Python provides such a function for insertion then extraction called "heappushpop", which is paraphrased below. The heap array is assumed to have its first element at index 1.
 // Push a new item to a (max) heap and then extract the root of the resulting heap.
 // "heap": an array representing the heap, indexed at 1
 // "item": an element to insert
 // Returns the greater of the two between "item" and the root of "heap".
 Push-Pop("heap": List<T>, "item": T) -> T:
 if "heap" is not empty and heap[1] > "item" then: // < if min heap
 swap "heap"[1] and "item"
 _downheap("heap" starting from index 1)
 return "item"
A similar function can be defined for popping and then inserting, which in Python is called "heapreplace":
 // Extract the root of the heap, and push a new item
 // "heap": an array representing the heap, indexed at 1
 // "item": an element to insert
 // Returns the current root of "heap"
 Replace("heap": List<T>, "item": T) -> T:
 swap "heap"[1] and "item"
 _downheap("heap" starting from index 1)
 return "item"
Search.
Finding an arbitrary element takes O(n) time.
Delete.
Deleting an arbitrary element can be done as follows:
Decrease or increase key.
The decrease key operation replaces the value of a node with a given value with a lower value, and the increase key operation does the same but with a higher value. This involves finding the node with the given value, changing the value, and then down-heapifying or up-heapifying to restore the heap property.
Decrease key can be done as follows:
Increase key can be done as follows:
Building a heap.
Building a heap from an array of input elements can be done by starting with an empty heap, then successively inserting each element. This approach, called Williams’ method after the inventor of binary heaps, is easily seen to run in time: it performs insertions at cost each.
However, Williams’ method is suboptimal. A faster method (due to Floyd) starts by arbitrarily putting the elements on a binary tree, respecting the shape property (the tree could be represented by an array, see below). Then starting from the lowest level and moving upwards, sift the root of each subtree downward as in the deletion algorithm until the heap property is restored. More specifically if all the subtrees starting at some height formula_4 have already been “heapified” (the bottommost level corresponding to formula_5), the trees at height formula_6 can be heapified by sending their root down along the path of maximum valued children when building a max-heap, or minimum valued children when building a min-heap. This process takes formula_7 operations (swaps) per node. In this method most of the heapification takes place in the lower levels. Since the height of the heap is formula_8, the number of nodes at height formula_4 is formula_10. Therefore, the cost of heapifying all subtrees is:
This uses the fact that the given infinite series formula_12 converges.
The exact value of the above (the worst-case number of comparisons during the heap construction) is known to be equal to:
where is the sum of all digits of the binary representation of and is the exponent of in the prime factorization of .
The average case is more complex to analyze, but it can be shown to asymptotically approach comparisons.
The Build-Max-Heap function that follows, converts an array "A" which stores a complete
binary tree with "n" nodes to a max-heap by repeatedly using Max-Heapify (down-heapify for a max-heap) in a bottom-up manner.
The array elements indexed by
, , ..., "n"
are all leaves for the tree (assuming that indices start at 1)—thus each is a one-element heap, and does not need to be down-heapified. Build-Max-Heap runs
Max-Heapify on each of the remaining tree nodes.
 Build-Max-Heap ("A"):
 for each index "i" from "floor"("length"("A")/2) downto 1 do:
 Max-Heapify("A", "i")
Heap implementation.
Heaps are commonly implemented with an array. Any binary tree can be stored in an array, but because a binary heap is always a complete binary tree, it can be stored compactly. No space is required for pointers; instead, the parent and children of each node can be found by arithmetic on array indices. These properties make this heap implementation a simple example of an implicit data structure or Ahnentafel list. Details depend on the root position, which in turn may depend on constraints of a programming language used for implementation, or programmer preference. Specifically, sometimes the root is placed at index 1, in order to simplify arithmetic.
Let "n" be the number of elements in the heap and "i" be an arbitrary valid index of the array storing the heap. If the tree root is at index 0, with valid indices 0 through "n − "1, then each element "a" at index "i" has
Alternatively, if the tree root is at index 1, with valid indices 1 through "n", then each element "a" at index "i" has
This implementation is used in the heapsort algorithm, where it allows the space in the input array to be reused to store the heap (i.e. the algorithm is done in-place). The implementation is also useful for use as a Priority queue where use of a dynamic array allows insertion of an unbounded number of items.
The upheap/downheap operations can then be stated in terms of an array as follows: suppose that the heap property holds for the indices "b", "b"+1, ..., "e". The sift-down function extends the heap property to "b"−1, "b", "b"+1, ..., "e".
Only index "i" = "b"−1 can violate the heap property.
Let "j" be the index of the largest child of "a"["i"] (for a max-heap, or the smallest child for a min-heap) within the range "b", ..., "e".
By swapping the values "a"["i"] and "a"["j"] the heap property for position "i" is established.
At this point, the only problem is that the heap property might not hold for index "j".
The sift-down function is applied tail-recursively to index "j" until the heap property is established for all elements.
The sift-down function is fast. In each step it only needs two comparisons and one swap. The index value where it is working doubles in each iteration, so that at most log2 "e" steps are required.
For big heaps and using virtual memory, storing elements in an array according to the above scheme is inefficient: (almost) every level is in a different page. B-heaps are binary heaps that keep subtrees in a single page, reducing the number of pages accessed by up to a factor of ten.
The operation of merging two binary heaps takes Θ("n") for equal-sized heaps. The best you can do is (in case of array implementation) simply concatenating the two heap arrays and build a heap of the result. A heap on "n" elements can be merged with a heap on "k" elements using O(log "n" log "k") key comparisons, or, in case of a pointer-based implementation, in O(log "n" log "k") time. An algorithm for splitting a heap on "n" elements into two heaps on "k" and "n-k" elements, respectively, based on a new view
of heaps as an ordered collections of subheaps was presented in. The algorithm requires O(log "n" * log "n") comparisons. The view also presents a new and conceptually simple algorithm for merging heaps. When merging is a common task, a different heap implementation is recommended, such as binomial heaps, which can be merged in O(log "n").
Additionally, a binary heap can be implemented with a traditional binary tree data structure, but there is an issue with finding the adjacent element on the last level on the binary heap when adding an element. This element can be determined algorithmically or by adding extra data to the nodes, called "threading" the tree—instead of merely storing references to the children, we store the inorder successor of the node as well.
It is possible to modify the heap structure to allow extraction of both the smallest and largest element in formula_14formula_15 time. To do this, the rows alternate between min heap and max-heap. The algorithms are roughly the same, but, in each step, one must consider the alternating rows with alternating comparisons. The performance is roughly the same as a normal single direction heap. This idea can be generalized to a min-max-median heap.
Derivation of index equations.
In an array-based heap, the children and parent of a node can be located via simple arithmetic on the node's index. This section derives the relevant equations for heaps with their root at index 0, with additional notes on heaps with their root at index 1.
To avoid confusion, we'll define the level of a node as its distance from the root, such that the root itself occupies level 0.
Child nodes.
For a general node located at index formula_1 (beginning from 0), we will first derive the index of its right child, formula_17.
Let node formula_1 be located in level formula_19, and note that any level formula_20 contains exactly formula_21 nodes. Furthermore, there are exactly formula_22 nodes contained in the layers up to and including layer formula_20 (think of binary arithmetic; 0111...111 = 1000...000 - 1). Because the root is stored at 0, the formula_24th node will be stored at index formula_25. Putting these observations together yields the following expression for the index of the last node in layer l.
Let there be formula_27 nodes after node formula_1 in layer L, such that
Each of these formula_27 nodes must have exactly 2 children, so there must be formula_31 nodes separating formula_1's right child from the end of its layer (formula_33).
As required.
Noting that the left child of any node is always 1 place before its right child, we get formula_35.
If the root is located at index 1 instead of 0, the last node in each level is instead at index formula_22. Using this throughout yields formula_37 and formula_38 for heaps with their root at 1.
Parent node.
Every node is either the left or right child of its parent, so we know that either of the following is true.
Hence,
Now consider the expression formula_42.
If node formula_1 is a left child, this gives the result immediately, however, it also gives the correct result if node formula_1 is a right child. In this case, formula_45 must be even, and hence formula_46 must be odd.
Therefore, irrespective of whether a node is a left or right child, its parent can be found by the expression:
Related structures.
Since the ordering of siblings in a heap is not specified by the heap property, a single node's two children can be freely interchanged unless doing so violates the shape property (compare with treap). Note, however, that in the common array-based heap, simply swapping the children might also necessitate moving the children's sub-tree nodes to retain the heap property.
The binary heap is a special case of the d-ary heap in which d = 2.


Academic ranks in Kenya

Academic ranks in Kenya are the titles, relative importance and power of professors, researchers, and administrative personnel held in academia.
Overview.
Kenya’s Universities Act of 2012 defines an "academic staff'” as a "person appointed to teach, train or to do research at a university and any other employee designated as such by the university council". The definition of professor is left to each individual university. Professors are primarily senior members of university teaching and/or research faculty. Generally, there is no clear distinction between research and academic. However, the University of Nairobi has a tradition of appointing faculty in both the research and academic streams, thus, Junior Research Fellow =Assistant Lecturer, Research Fellow=Lecturer, Associated Professorial Research Fellow=Associate Professor and the Professorial Research Fellow=Professor.
Both the associate and full professors must have PhDs or a qualification considered equivalent. In the Moi University and University of Nairobi where they have a longer history offering medical qualifications, a post medical qualification Masters of Medicine (M Med.) is considered an equivalent of a PhD in other fields. So a holder of an M.Med who has been a senior lecturer for three years, together with requisite publications and supervisions may be appointed associate professor, then full professor. In Moi University again, there is an example of a senior legal scholar and practitioner who was appointed full Professor based on a personal evaluation. His long teaching experience, myriad academic and technical publications and his two LL Ms were considered as equivalents. Generally lower degree holders can not go beyond the senior lecturer level, however this is left for each university to decide. To be a full Professor in all the Kenyan Universities, one ought to have served as an associate professor for four year and at least three peer reviewed publications in international journals or similarly considered technical publications. Technical patents too are considered. Post graduate research supervision and outreach are also crucial.
Outside of the appointive tenures, some very senior academic staff in the Kenyan Universities do get baptized "professor" by their students or colleagues. This is because they are usually very senior, have mentored many, or they have achieved a lot of academic grounding without the benefit of promotions which can get gruesomely political. A lot of victims are those with solid research credentials combined with great teaching and outreach experience but have not acquired a PhD or equivalent for one reason or the other. The same also applies to some extremely productive young academics that have not attained the right longevity for appointment as professors. Many people from outside of the university fraternity might also just refer to any long serving academic staff as professor. All these are usually acceptable without any question.
Many people rightly argue that professorial appointments should not be based on longevity, loyalty or sheer availability of vacancies to be filled, but rather on prowess as evidenced by ground breaking research, teaching and outreach. Professorship should not be a reward for loyalty. Whatever the criteria of appointment, it should remain a mark of highest academic and research pedigree, they assert.


Katsuhiko Murooka

 is a Japanese professional shogi player ranked 7-dan.
Promotion history.
Murooka's promotion history is as follows:


Gladys Goldstein

Gladys Goldstein (1918–2010) was an American artist who lived and worked within the art community of Baltimore, Maryland. Having begun as a representational artist specializing in portraits, she achieved recognition first for abstractions that were clearly based on natural forms and later for abstractions whose origin in natural forms was imperceptible. She was known for her deft handling of light and color in these works: atmospheric and subtle in some of them, intense and garish in others. Some critics saw an impressionist impulse in her paintings while others noted an expressionist ability to imbue them with emotion. In 1958 a critic said, "In nature Mrs. Goldstein finds a constant change in mood through patterns, rhythms, color; flamboyant now, wistfully delicate tomorrow; light, light that is reflected, light that is absorbed, light that is charged with the buoyancy of champagne or as quietly, morosely romantic, as any passage of Baudelaire." Goldstein chose to be a regional artist. She occasionally exhibited elsewhere but did not actively promote her career outside a mid-Atlantic region centered on Baltimore. She taught art for most of her long career, first in classes held in community centers and later in Baltimore's College of Notre Dame.
Early life and training.
Born in Ohio, she was brought to Baltimore when her family relocated there in 1920. She took art classes as a child. After graduating from that city's Western High School, she attended, successively, Johns Hopkins and Columbia universities, the Art Students League of New York, and the Maryland Institute College of Art. While taking still more art classes in a summer session at Pennsylvania State College, she decided to become a professional artist.
Career in art.
At the beginning of her career she used Gladys V. Hack as her professional name. In the late 1940s Goldstein joined the Art Group of the Baltimore Branch, National League of American Pen Women. The group held annual exhibitions of members' art in the Peale Museum. The art on display was said to be predominantly representational and Goldstein's contributions were mostly portraits. In 1950 she became head of the Art Group and a year later she was jointly responsible for arranging the Baltimore branch's annual show. In 1952 she participated in an exhibition at the National Gallery of Art in Washington, D.C. that was held during the biennial convention of the National League. A year later she participated in a large exhibition of regional artists at the Baltimore Museum of Art. By this time she was using Gladys Hack Goldstein as her professional name.
At the end of that year she organized a show designed to sell paintings based on size rather than artistic value and priced low enough to be purchased as holiday gifts. The objective, she said, was to enable local citizens "to acquire an appreciation of original pictures by contemporary artists." The painting that she offered for sale was a departure from her earlier work. Called "Tree and Pink Sky," it was entirely abstract. She later said her transition from realist portraits to nature-derived abstractions was sudden and complete, but a fellow artist and art instructor, James G.A. Murphy, said that she continued to make portraits for private sale, but would only exhibit her abstract work.
In the early 1950s Goldstein joined a local group called the Painters' Seminar and in January 1956 she participated in, and help to hang, an exhibition of members' paintings in the lobby of a movie theater called the Film Center. The two paintings she showed, "Lights" and "Foliage of the Fall," were both abstracts. The critic for the Baltimore Sun said these two works dominated the show. In February 1956 she won second prize in the Maryland Artists Exhibition at the Baltimore Museum of Art. The award-winning painting, "Big City," was also the favorite of the show's visitors whose votes put it at the top of the best-liked list. A few months later, she received a best-in-show award for an oil painting in the art exhibition that accompanied the biennial conference of the National League of American Pen Women. In November she was given a solo exhibition at the Baltimore Museum of Arts. Her work appeared in one gallery while two other Baltimore artists, Shelby Shackelford and William Waller, were given separate solo shows. In 1956 Goldstein began using Gladys Goldstein rather than Gladys Hack Goldstein as her professional name. In 1957 Goldstein was given a solo exhibition at the Duveen-Graham Galleries in New York. She showed fifteen oil paintings along with watercolors and some drawings. a critic for the "New York Times" gave the show a positive review, saying "Her most promising work is in a lyrical vein; softly rendered drifts of color, freely moving over a luminous base."
In May 1959, when her work appeared in an invitational exhibition at Morgan State University, a critic for the "Baltimore Sun" said "Gladys Goldstein seldom fails to furnish a fresh insight on whatever matter she undertakes; her "Blossom," the sparest imaginable oil-on-paper, seems composed of light." In December of the same year her paintings appeared in a solo exhibition in the lobby of a motion picture theater called the Playhouse. Regarding the show, the same "Baltimore Sun" critic said, "Her Playhouse show is not a major effort given the aspiration of the recent oils, but in its small way it is perfection." In February of the next year she showed with Amalie Rothschild, Bernard Perlman, and William Waller in a four-artist exhibition at the I.F.A. Galleries in Washington, D.C. and in September she showed with Lowell Nesbitt in a two-artist exhibition at Johns Hopkins University. Regarding her work in the latter, a "Sun" said, "As always, her sources are nature in its multiple aspects: the sea, tempestuous or calm, a summer landscape, a stony bank at the first moment of spring. But Mrs. Goldstein increasingly works toward essences; the literal fact becomes the esthetic fact, for she is, above all things a painter... With a touch of brush, artist turns the literal into the esthetic."
The "Baltimore Sun" gave extensive coverage to a solo exhibition held in a Baltimore suburban gallery in 1963. The newspaper's article, by Robert G. Breen, included comments by Goldstein and others about a new direction her work had taken. It said she aimed at establishing what she called "horizontal perspective" and quoted her description of it. She said, "This perspective is perspective in space. It moves across the canvas, not back into the canvas. But it moves across in layers. This does not violate the picture plane but simply creates an illusion of movement by virtue of the depth created horizontally in flat layers, each layer retaining its own identity, yet uniting itself with the whole." The "Sun" gave a further description in reviewing another solo show the following year. The author said, "has set herself the sticky problem of capturing space and light by almost completely abstract means... Mrs. Goldstein is thus working with layers of lightnear and far and mediansomething as evanescent as smoke and more capricious." The exhibition was mounted in the library of College of Notre Dame, the school in Baltimore where Goldstein was then an art instructor.
During the 1960s and 1970s Goldstein's work continued to appear frequently in group or solo exhibitions held in non-commercial settings such as colleges, community centers, religious organizations, benefit auctions, and municipal spaces. By 1976 she had participated in somewhat more than 150 exhibitions according to an article in the "Baltimore Sun". She showed less frequently than before in commercial galleries such as the I.F.A. Gallery in Washington. When she showed at Villa Julie College in 1972, Lincoln F. Johnson, "Baltimore Sun" critic, wrote that, "Villa Julie College is showing works by Gladys Goldstein, abstractions which operate, most of them, as visual metaphors for states of nature." "Elegant and refined," he added, "they sometimes have the appearance of precious objects."
Oil paintings and gouaches had predominated in Goldstein's output until the late 1970s when she began to produce collages and other mixed-media work. Writing about a solo exhibition of close to fifty paintings and collages she had made during the previous few years, Elisabeth Stevens, a "Baltimore Sun" critic, called the collages "shimmering works featuring painstakingly placed fragments of foil, newspaper clippings and printed papers." In the 1980s showed paintings in square format that contained square and rectangular design elements. She told a reviewer that she found these shapes to be "peaceful and elegant," having "a purity of form" and the possibility of endless variations. At the end of the decade she showed mixed-media pieces which a critic called "collaged paintings," having on their surfaces pieces of paper and fabric as well as sand. They were "two-dimensional, non-illusionistic and non-representational," but they nonetheless suggested "land and landscape," "calligraphy and hieroglyph," and occasionally "stained glass window."
Critics had increasingly seen inconsistency in Goldstein's work. They saw some high-quality pieces alongside ones that disappointed them. Regarding an exhibition at a commercial gallery in 1991, John Dorsey, of the "Baltimore Sun", wrote: "Goldstein is nothing if not erratic. When her abstractions succeed, they're a delight to behold. When they don't, they're frustratingly disappointing. It's not as if they're someone else's pictures or as if they needed work; they're unmistakably hers, they're unquestionably finished and they're clearly professional -- but they somehow just don't make it." He added, "That's not to say that Goldstein, even when disappointing, is a bad artist. She works at a level that always deserves respect. But at her best the level is a lot higher than that." Between this time and her death nineteen years later, Goldstein seems to have stopped exhibiting, or, at any rate, news reports of exhibits stopped appearing. She died on March 20, 2010. After her death, a curator said that during her career she had "focused on creating and teaching art and was not as interested in the financial gain through the sale of her pieces."
Artistic style.
Goldstein began her career as a representational painter. In the late 1940s she showed realist portraits in the exhibitions of the League of Pen Women. "Babushka", painted about 1935 and shown at right, is one of her earliest works. When she turned to abstraction in the early 1950s, she took natural objects as the basis for her work. "Sunflowers," of 1968, shown at left illustrates this style. During the 1970s, she handled references to nature more obliquely, as seen in "Peace Doves" of 1974, shown at right. Thereafter her work became more purely abstract. "Summer Garden" of 1980, shown at left, is a painting of this type. Many of her mid-career paintings were notable for their handling of light. She possessed an ability, as one critic said, to produce works that seem to be "composed of light." Another said her paintings appeared to have "layers of filmy colored veils with one color moving into the next." Goldstein said she aimed to show light coming from within the canvas... a living force from within."
During roughly the first half of her long career she worked mainly in oil on canvas, supplemented by gouaches on paper and some drawings. She employed impasto for many of the early works and used the brush more and more toward the mid-point of her career. Later, she made many paintings in mixed media, collage forms and sometimes used staining and dripping techniques and incorporated metallics in her work. A critic said she maintained "extraordinary control" over her collages, weaving items "into the fabric of the painting so that it is the image rather than the materials which take precedence." Another said, "Her collages are small, shimmering works featuring painstakingly placed fragments of foil, newspaper clippings and printed papers." "Candy Wrappers," a small undated collage, shown at right, is an example of this style. She said, "I will sometimes take an object that I find on the floor or something that I've collected and I'll paste it on the canvas because that is part of living."
During the 1980s, Goldstein focused on square and rectangular shapes. Of one of these paintings, "Signals," shown at left, a critic wrote, "the colors—reds, greens, blues, pinks—are beautiful and they glow almost as if they were stained glass." Goldstein said the shapes had intrigued her for a long time. She found them to be "peaceful and elegant" and said her response to them sometimes "verges on the mystic. Some of these paintings were themselves squares and some were as large as six feet long or high.
Toward the end of her career Goldstein began to supplant oils with acrylics and to combine organic forms with geometric ones. In 1991 a critic said she made "subtle use of color and a reserved but sensuous touch to create graceful, somewhat veiled, almost seductive effects." During this period she also made prints using a technique that originated in Mexico in 1970 and was called mixographia. Employing a beeswax surface rather than a metal plate or lithographic stone, this printing process allowed the artist to add a three-dimensional texture to her work. The untitled and undated print shown at right ("mixographia print") is an example of the prints she made using this technique.
Art teacher.
In the mid-1950s Goldstein began to teach art in a program called "Forest Park Evening Classes" in Baltimore. The program offered instruction in practical subjects such as typing and dressmaking at no cost to Baltimore residents and was directed by her husband, Edward H. Goldstein. It had begun to offer art classes in 1950. In 1957 she also began to teach classes at the newly-opened Metropolitan School of Art. Aiming to give art students an alternative to the relatively conservative instruction offered at the Maryland Institute of Art, the school taught amateurs and professionals, children and adults, in day and evening classes from that year until 1960. The following year and for the next two, she taught at the Maryland Institute of Art. In 1959 she began teaching art classes in the recreation center of Oheb Shalom temple and from the early 1960s she left that position to teach at the Jewish Community Center. In 1964 Goldstein joined the faculty of the College of Notre Dame as an art instructor. In 1982, at the age of 62, she left her teaching jobs at the Jewish Community Center and Notre Dame, but continued to give private instruction.
Personal life and family.
Goldstein's father was Samuel Edward Hack (1893-1956), a ceramics artist and instructor. Her mother was Dorothy (Isaacson) Hack (1895-1952). Her paternal grandparents had been born in Polish Russia. Her paternal grandfather, Simon (18xx-1981), operated a shoe repair business in Baltimore. Her paternal grandmother, Goldie, died in 1915, age 44. She had an older brother, Ernest (1915-2003) and a younger one, Homer (1920-2007).
In the early 1940s Goldstein married Edward H. Goldstein (born about 1912, died 2002), an administrator in the Baltimore public school system. The couple had a son, William N. Goldstein (1943-2006), a psychiatrist and professor of psychiatry at Georgetown University Medical Center in Washington, D.C.
Goldstein died from complications after surgery at Seasons Hospice in Randallstown, Maryland on March 13, 2010, and was interred in Oheb Shalom Memorial Park, Reisterstown, Maryland.


David Sawin

David Sawin (April 22, 1922 – ) was an American painter working primarily in New York City during the middle part of the 20th century. His style, though singular, was described by Meyer Schapiro and Arthur Danto as second-generation abstract expressionism.
Biography.
Sawin was born in New York City. He attended Brown University, received a B.A. from Columbia University and an M.A. from the University of Iowa. He studied in Paris on the G.I. Bill with Fernand Léger.
t Columbia, Sawin studied under Meyer Schapiro, who admired him and collected his work. Their correspondence in the archives at Columbia University indicates a lifelong friendship. He was also deeply admired by the philosopher and critic Arthur Danto
Sawin taught at Brooklyn College from 1959-1984 in an art department that included Philip Pearlstein, Walter Rosenblum, Lois Dodd, and Lennart Anderson. He also taught at Sarah Lawrence College, Williams College, and Columbia University.
From 1949 to 1969 he was married to the art historian and writer Martica Sawin.
His work is held in numerous private collections. It was included in the 1955 Annual Exhibit of Contemporary Painting at the Whitney Museum of American Art and in “New York School – Second Generation” at the Jewish Museum in 1957. A 1986 exhibit at the Waverly gallery was the subject an article in The Nation by Arthur Danto and he was the subject of a retrospective at the Newport Art Museum in 1988, with a catalogue essay by Arthur Danto.
Work.
Meyer Schapiro and Arthur Danto held the view that Sawin’s paintings both share a certain spirit with the abstract expressionist movement yet decidedly defy that categorization.


Sequence point

A sequence point defines any point in a computer program's execution at which it is guaranteed that all side effects of previous evaluations will have been performed, and no side effects from subsequent evaluations have yet been performed. They are often mentioned in reference to C and C++, because they are a core concept for determining the validity and, if valid, the possible results of expressions. Adding more sequence points is sometimes necessary to make an expression defined and to ensure a single valid order of evaluation.
With C++11, usage of the term sequence point has been replaced by sequencing. There are three possibilities:
The execution of unsequenced evaluations can overlap, with catastrophic undefined behavior if they share state. This situation can arise in parallel computations, causing race conditions. However, it can already arise in simple non-concurrent situations like codice_1, where part of the assignment to codice_2 (eg., half of the bits) may happen before codice_3, and the rest afterwards, such that after evaluation of the expression, codice_4 may contain a meaningless intermediate state of codice_2.
Examples of ambiguity.
Consider two functions codice_6 and codice_7. In C and C++, the codice_8 operator is not associated with a sequence point, and therefore in the expression codice_9 it is possible that either codice_6 or codice_7 will be executed first. The comma operator introduces a sequence point, and therefore in the code codice_12 the order of evaluation is defined: first codice_6 is called, and then codice_7 is called.
Sequence points also come into play when the same variable is modified more than once within a single expression. An often-cited example is the C expression codice_15, which apparently both assigns codice_16 its previous value and increments codice_16. The final value of codice_16 is ambiguous, because, depending on the order of expression evaluation, the increment may occur before, after, or interleaved with the assignment. The definition of a particular language might specify one of the possible behaviors or simply say the behavior is undefined. In C and C++, evaluating such an expression yields undefined behavior. Other languages, such as C#, define the precedence of the assignment and increment operator in such a way that the result of the expression codice_15 is guaranteed.
Sequence points in C and C++.
In C and C++, sequence points occur in the following places. (In C++, overloaded operators act like functions, and thus operators that have been overloaded introduce sequence points in the same way as function calls.)


Yaneer Bar-Yam

Yaneer Bar-Yam (born 1959) is an American scientist and activist specializing in complex systems. An expert in the quantitative analysis of pandemics, he advised policy makers on the Western African Ebola virus epidemic and founded EndCoronavirus.org, a global network of over 4,000 volunteers formed in February 2020 to provide information, guidelines, and policy advocacy to fight the COVID-19 pandemic. He is the founding president of the New England Complex Systems Institute (NECSI), an independent research institution that studies complex systems science and its real-world applications.
Biography.
Yaneer Bar-Yam was born in Boston, Massachusetts in 1959 to Israeli parents. His father, Zvi Bar-Yam, is a high-energy particle physicist, and his mother, Miriam Bar-Yam, is a developmental psychologist. He received his BS degree in 1978 and his Ph.D. degree in 1984, both in physics from the Massachusetts Institute of Technology. He was a Bantrell Postdoctoral Fellow, and a joint postdoctoral fellow at MIT and IBM. In 1991, following a junior faculty appointment at the Weizmann Institute of Science, he was appointed an Associate Professor of Engineering at Boston University. He left Boston University in 1997 to become the founding president of the New England Complex Systems Institute, a position he holds as of May 2020.
Bar-Yam was a Visiting Scholar at the Department of Molecular and Cellular Biology at Harvard University and the Federal Reserve Bank of Boston. He was chairman of the International Conference on Complex Systems, an annual forum dedicated to bridging the domains of complexity science and real-world systems, and is the managing editor of InterJournal, a NECSI publication on selected topics in science and engineering.
Bar-Yam is currently a Research Scientist at the MIT Media Lab, and is the managing editor of the Springer book series on complexity.
Ideas and Theories.
The NECSI website defined "complex systems" as systems that "have multiple interacting components whose collective behavior cannot be simply inferred from the behavior of components." Bar-Yam is considered a contributor to the founding of the field of complex systems science, having introduced fundamental rigor, real-world applications, and educational programs to the field.
Bar-Yam studies the unified properties of complex systems as a systematic strategy for answering basic questions about the world. His research is focused both on formalizing complex systems concepts and relating them to everyday problems. In particular, he studies the relationship between observations at different scales, formal properties of descriptions of systems, the relationship of structure and function, the representation of information as a physical quantity, and quantitative properties of the complexity of real systems. Applications have been to physical, biological, and social systems.
His recent work analyzes the origins and impacts of market crashes, social unrest, ethnic violence, military conflict and pandemics, the structure and dynamics of social networks, and the bases of creativity, panic, evolution, and altruism. Bar-Yam has made further contributions to the theory of the structural and electronic dynamics of materials, the theory of polymer dynamics and protein folding, the theory of neural networks and structure-function relationships, the theory of quantitative multiscale complexity, and the theory of evolution. His development of multiscale representations as a generalization of renormalization group addressed the limitations of calculus and statistics in the study of nonlinear and network system dependencies on collective behaviors.
Work.
NECSI.
Bar-Yam is the president of Cambridge, Massachusetts-based NECSI, an independent research institution and think tank dedicated to the study of complex systems and its applications to solving real-world problems. NECSI was established by faculty members of various New England academic institutions, including MIT, Harvard, Brandeis, and others, to encourage collaboration among researchers. In addition to its in-house research team, NECSI has co-faculty, students, and affiliates from universities around the world. NECSI also conducts classes, seminars, and conferences to assist students, faculty, and professionals in their understanding of complex systems. NECSI's faculty, co-faculty, and affiliates represent a wide range of scientific disciplines, and have included Jerome Kagan, Thomas Schelling, and Nassim Nicholas Taleb. NECSI researchers have contributed to such varied areas as networks, social systems, food crises, and economic systems.
In February 2020, NECSI and Bar-Yam established EndCoronavirus.org to offer information, guidelines, and policy advocacy to fight the COVID-19 pandemic.
Consulting and advisory.
Bar-Yam has advised many policymaking and regulatory bodies on various topics, including: the Pentagon's Chairman Action Group on global social unrest and the crises in Egypt and Syria; the National Security Council and the National Counter Terrorism Council on global strategy; the Chief of Naval Operations Strategic Studies Group on military force transformation; the Centers for Disease Control and Prevention on delivery of prevention services and control of hospital infections; Congressman Barney Frank (as chairman of the House Financial Services Committee) on market regulation and the financial crisis. He has given 175 invited presentations, and has taught the concepts and methods of complex systems science to over 2,000 graduate students, professionals, and executives.
Pandemics Research and Activism.
Overview.
Pandemics are a natural field of study for complex systems scientists, as many of the main insights of the discipline—including network theory, nonlinearity, chaos, emergent properties, adaptation, and non-ergodicity—can be directly brought to bear on the analysis of infectious diseases and their spread.
Bar-Yam has studied pandemics since the early 2000s, in concert with NECSI's stated mission to foster collaboration among different disciplines (e.g. mathematics and epidemiology) and to apply theoretical work to problems in the real world. His research has emphasized the role of increasing global travel in pandemics; community monitoring of symptoms as potentially superior to conventional testing, tracking, and tracing techniques; and specific guidelines for individuals, policymakers, healthcare workers, and businesses to slow the spread of infectious diseases.
Bar-Yam's early research on pandemics identified the fatality rate of an infectious disease as a key limiting factor in its ability to spread. For the deadliest diseases, he argued that the pathogen would rapidly exhaust the local supply of hosts to infect, and would therefore disappear before it could spread beyond the initial local area of outbreak.
In a 2006 paper co-authored with Erik Rauch, Bar-Yam introduced global travel (e.g. international long-distance flights and overseas shipment of livestock) as a new variable to his earlier pandemic models, which yielded a nonlinear relationship between the amount of global travel and the ultimate severity of an outbreak. Specifically, the authors found that up to a certain point, increasing global travel had little impact on the overall severity of an outbreak. However, when the amount of travel approached a critical threshold, the ultimate severity of the outbreak (and its likelihood of becoming a global pandemic) increased suddenly and sharply. "Due to increasing global travel," Bar-Yam and Rauch wrote in the 2006 paper, "human beings may cross the transition into the realm of pandemics unless preventive actions are taken that either limit global transportation or its impact."
Ebola.
During the Western African Ebola virus epidemic which began in 2013, Bar-Yam advocated in favor of curtailing transportation from West Africa, arguing that even in cases where significant interconnectivity between populations already existed, even a small amount of "additional" interconnectivity could dramatically increase the severity of an outbreak.
Bar-Yam also advocated in favor of community monitoring to fight the Ebola epidemic. The conventional response to infectious disease outbreaks emphasizes individual contact tracing, i.e. the effort to locate all individuals who were in contact with an individual known to carry the disease. Bar-Yam argued that it would be more effective and efficient to monitor local communities (defined as a natural population unit to and from which transportation can be logically curtailed) as a whole—in other words, to treat an entire community as "infected" once one individual in that community is infected, and then intensively screen that community for additional cases while instituting local transportation restrictions. This type of community response would progressively limit the disease to smaller geographical areas, Bar-Yam argued, while improving the allocation of resources. Bar-Yam argued that community monitoring played a significant role in halting the Ebola epidemic in Liberia.
COVID-19.
On January 26, 2020, one week after the first case of COVID-19 disease in the United States was reported, Bar-Yam co-authored a note with Nassim Nicholas Taleb and Joseph Norman. The note outlined several principles in connection with the novel coronavirus outbreak, and argued that policy responses should follow a precautionary approach, including drastically constraining human mobility patterns as soon and as swiftly as possible.
On February 29, 2020, Bar-Yam and NECSI established EndCoronavirus.org, a global volunteer network, to provide information and guidelines for action to fight the COVID-19 pandemic. EndCoronavirus.org was among the first organizations in the United States to offer specific guidelines for policymakers, businesses, and individuals. As of May 2020, EndCoronavirus.org had over 4,000 volunteers.
On March 13, 2020, the "Coronavirus Guidelines for Businesses" written by EndCoronavirus.org were adopted by the International Chamber of Commerce, the global business organization representing over 45 million members in over 100 countries.
On March 21, 2020, "USA Today" published an opinion piece by Bar-Yam, in which he argued for an immediate five-week lockdown in the entire United States to defeat COVID-19.
On April 5, 2020, Bar-Yam and Chen Shen published a paper titled "COVID-19: How to Win," which summarized his recommendations. Those recommendations included a lockdown, separate quarantine facilities for mild and moderate COVID-19 cases to prevent transmission within households, mask wearing in shared spaces, travel restrictions, improved safety of essential services, increased testing, health guidelines to prevent mild cases from becoming severe, and increased support for hospitals and healthcare workers.
On April 15, 2020, Bar-Yam reported via Twitter that he was assisting the government of Kosovo in its efforts to fight the COVID-19 pandemic.
On April 28, 2020, Bar-Yam was consulted by Virginia residents on an open letter to Ralph Northam, the governor of Virginia, calling for more aggressive action to fight COVID-19 in that state. The letter was signed by 430 scientists, doctors, and citizens as of May 25, 2020.
On May 12, 2020, CNN.com published an opinion piece by Bar-Yam, in which he argued against the premature opening of states, and urged individual citizens to continue strict restrictions on their movement and contact with others.
Publications.
Bar-Yam is the author and/or editor of several books, as well as the author of more than 200 research papers in professional journals, including in Science, Nature, PNAS, American Naturalist, and Physical Review Letters. He has published on a range of scientific and real-world problems, including cell biology and the global financial crisis, and is the holder of four patents.


Hiromi Nakakura

 is a Japanese women's professional shogi player ranked 2-dan. She is the current representative director of the Ladies Professional Shogi-player's Association of Japan (LPSA).
LPSA representative director.
Nakakura was selected to replace Sachio Ishibashi as representative director of the in February 2014. She was re-elected as president in 2016 and 2018.
Personal life.
Nakakura's sister Akiko is a retired women's professional shogi player.
Promotion history.
Nakakura has been promoted as follows:
Note: All ranks are women's professional ranks.


Peter Lowe (artist)

Peter Lowe (born 17 June 1938) is an English artist. He was born in London at Victoria Park, Hackney. He studied at Goldsmiths College 1954–60 where he was taught by Mary Martin and Kenneth Martin. Lowe's work is rational, abstract and geometric. In 1960 he constructed and exhibited his first relief and experimented with balanced transformable constructions. His work is mainly exhibited and appreciated in Europe where it is in many national collections, Vienna mumok Sammlung Dieter und Gertraud Bogner, Muzeum Sztuki w Lodzi . In 1972 he cofounded Systems group. Since 1974 he has been a member of Arbeitskreis.
The constructivist work of Peter Lowe is mentioned in Alastair Grieve's authoritative book of 2005, and an interview with him by the art historian Alan Fowler is given in the Southampton City Art Gallery exhibition catalogue, 2008.


Functional programming

In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.
In functional programming, functions are treated as first-class citizens, meaning that they can be bound to names (including local identifiers), passed as arguments, and returned from other functions, just as any other data type can. This allows programs to be written in a declarative and composable style, where small functions are combined in a modular manner.
Functional programming is sometimes treated as synonymous with purely functional programming, a subset of functional programming which treats all functions as deterministic mathematical functions, or pure functions. When a pure function is called with some given arguments, it will always return the same result, and cannot be affected by any mutable state or other side effects. This is in contrast with impure procedures, common in imperative programming, which can have side effects (such as modifying the program's state or taking input from a user). Proponents of purely functional programming claim that by restricting side effects, programs can have fewer bugs, be easier to debug and test, and be more suited to formal verification.
Functional programming has its roots in academia, evolving from the lambda calculus, a formal system of computation based only on functions. Functional programming has historically been less popular than imperative programming, but many functional languages are seeing use today in industry and education, including Common Lisp, Scheme, Clojure, Wolfram Language, Racket, Erlang, Elixir, OCaml, Haskell, and F#. Functional programming is also key to some languages that have found success in specific domains, like JavaScript in the Web, R in statistics, J, K and Q in financial analysis, and XQuery/XSLT for XML. Domain-specific declarative languages like SQL and Lex/Yacc use some elements of functional programming, such as not allowing mutable values. In addition, many other programming languages support programming in a functional style or have implemented features from functional programming, such as C++11, Kotlin, Perl, PHP, Python, Go, Rust, Raku, and Scala.
History.
The lambda calculus, developed in the 1930s by Alonzo Church, is a formal system of computation built from function application. In 1937 Alan Turing proved that the lambda calculus and Turing machines are equivalent models of computation, showing that the lambda calculus is Turing complete. Lambda calculus forms the basis of all functional programming languages. An equivalent theoretical formulation, combinatory logic, was developed by Moses Schönfinkel and Haskell Curry in the 1920s and 1930s.
Church later developed a weaker system, the simply-typed lambda calculus, which extended the lambda calculus by assigning a type to all terms. This forms the basis for statically-typed functional programming.
The first functional programming language, LISP, was developed in the late 1950s for the IBM 700/7000 series of scientific computers by John McCarthy while at Massachusetts Institute of Technology (MIT). LISP functions were defined using Church's lambda notation, extended with a label construct to allow recursive functions. Lisp first introduced many paradigmatic features of functional programming, though early Lisps were multi-paradigm languages, and incorporated support for numerous programming styles as new paradigms evolved. Later dialects, such as Scheme and Clojure, and offshoots such as Dylan and Julia, sought to simplify and rationalise Lisp around a cleanly functional core, while Common Lisp was designed to preserve and update the paradigmatic features of the numerous older dialects it replaced.
Information Processing Language (IPL), 1956, is sometimes cited as the first computer-based functional programming language. It is an assembly-style language for manipulating lists of symbols. It does have a notion of "generator", which amounts to a function that accepts a function as an argument, and, since it is an assembly-level language, code can be data, so IPL can be regarded as having higher-order functions. However, it relies heavily on the mutating list structure and similar imperative features.
Kenneth E. Iverson developed APL in the early 1960s, described in his 1962 book "A Programming Language" (). APL was the primary influence on John Backus's FP. In the early 1990s, Iverson and Roger Hui created J. In the mid-1990s, Arthur Whitney, who had previously worked with Iverson, created K, which is used commercially in financial industries along with its descendant Q.
John Backus presented FP in his 1977 Turing Award lecture "Can Programming Be Liberated From the von Neumann Style? A Functional Style and its Algebra of Programs". He defines functional programs as being built up in a hierarchical way by means of "combining forms" that allow an "algebra of programs"; in modern language, this means that functional programs follow the principle of compositionality. Backus's paper popularized research into functional programming, though it emphasized function-level programming rather than the lambda-calculus style now associated with functional programming.
The 1973 language ML was created by Robin Milner at the University of Edinburgh, and David Turner developed the language SASL at the University of St Andrews. Also in Edinburgh in the 1970s, Burstall and Darlington developed the functional language NPL. NPL was based on Kleene Recursion Equations and was first introduced in their work on program transformation. Burstall, MacQueen and Sannella then incorporated the polymorphic type checking from ML to produce the language Hope. ML eventually developed into several dialects, the most common of which are now OCaml and Standard ML.
In the 1970s, Guy L. Steele and Gerald Jay Sussman developed Scheme, as described in the Lambda Papers and the 1985 textbook "Structure and Interpretation of Computer Programs". Scheme was the first dialect of lisp to use lexical scoping and to require tail-call optimization, features that encourage functional programming.
In the 1980s, Per Martin-Löf developed intuitionistic type theory (also called "constructive" type theory), which associated functional programs with constructive proofs expressed as dependent types. This led to new approaches to interactive theorem proving and has influenced the development of subsequent functional programming languages.
The lazy functional language, Miranda, developed by David Turner, initially appeared in 1985 and had a strong influence on Haskell. With Miranda being proprietary, Haskell began with a consensus in 1987 to form an open standard for functional programming research; implementation releases have been ongoing since 1990.
More recently it has found use in niches such as parametric CAD courtesy of the OpenSCAD language built on the CSG geometry framework, although its restriction on reassigning values (all values are treated as constants) has led to confusion among users who are unfamiliar with functional programming as a concept.
Functional programming continues to be used in commercial settings.
Concepts.
A number of concepts and paradigms are specific to functional programming, and generally foreign to imperative programming (including object-oriented programming). However, programming languages often cater to several programming paradigms, so programmers using "mostly imperative" languages may have utilized some of these concepts.
First-class and higher-order functions.
Higher-order functions are functions that can either take other functions as arguments or return them as results. In calculus, an example of a higher-order function is the differential operator formula_1, which returns the derivative of a function formula_2.
Higher-order functions are closely related to first-class functions in that higher-order functions and first-class functions both allow functions as arguments and results of other functions. The distinction between the two is subtle: "higher-order" describes a mathematical concept of functions that operate on other functions, while "first-class" is a computer science term for programming language entities that have no restriction on their use (thus first-class functions can appear anywhere in the program that other first-class entities like numbers can, including as arguments to other functions and as their return values).
Higher-order functions enable partial application or currying, a technique that applies a function to its arguments one at a time, with each application returning a new function that accepts the next argument. This lets a programmer succinctly express, for example, the successor function as the addition operator partially applied to the natural number one.
Pure functions.
Pure functions (or expressions) have no side effects (memory or I/O). This means that pure functions have several useful properties, many of which can be used to optimize the code:
While most compilers for imperative programming languages detect pure functions and perform common-subexpression elimination for pure function calls, they cannot always do this for pre-compiled libraries, which generally do not expose this information, thus preventing optimizations that involve those external functions. Some compilers, such as gcc, add extra keywords for a programmer to explicitly mark external functions as pure, to enable such optimizations. Fortran 95 also lets functions be designated "pure". C++11 added codice_1 keyword with similar semantics.
Recursion.
Iteration (looping) in functional languages is usually accomplished via recursion. Recursive functions invoke themselves, letting an operation be repeated until it reaches the base case. In general, recursion requires maintaining a stack, which consumes space in a linear amount to the depth of recursion. This could make recursion prohibitively expensive to use instead of imperative loops. However, a special form of recursion known as tail recursion can be recognized and optimized by a compiler into the same code used to implement iteration in imperative languages. Tail recursion optimization can be implemented by transforming the program into continuation passing style during compiling, among other approaches.
The Scheme language standard requires implementations to support proper tail recursion, meaning they must allow an unbounded number of active tail calls. Proper tail recursion is not simply an optimization; it is a language feature that assures users that they can use recursion to express a loop and doing so would be safe-for-space. Moreover, contrary to its name, it accounts for all tail calls, not just tail recursion. While proper tail recursion is usually implemented by turning code into imperative loops, implementations might implement it in other ways. For example, CHICKEN intentionally maintains a stack and lets the stack overflow. However, when this happens, its garbage collector will claim space back, allowing an unbounded number of active tail calls even though it does not turn tail recursion into a loop.
Common patterns of recursion can be abstracted away using higher-order functions, with catamorphisms and anamorphisms (or "folds" and "unfolds") being the most obvious examples. Such recursion schemes play a role analogous to built-in control structures such as loops in imperative languages.
Most general purpose functional programming languages allow unrestricted recursion and are Turing complete, which makes the halting problem undecidable, can cause unsoundness of equational reasoning, and generally requires the introduction of inconsistency into the logic expressed by the language's type system. Some special purpose languages such as Coq allow only well-founded recursion and are strongly normalizing (nonterminating computations can be expressed only with infinite streams of values called codata). As a consequence, these languages fail to be Turing complete and expressing certain functions in them is impossible, but they can still express a wide class of interesting computations while avoiding the problems introduced by unrestricted recursion. Functional programming limited to well-founded recursion with a few other constraints is called total functional programming.
Strict versus non-strict evaluation.
Functional languages can be categorized by whether they use "strict (eager)" or "non-strict (lazy)" evaluation, concepts that refer to how function arguments are processed when an expression is being evaluated. The technical difference is in the denotational semantics of expressions containing failing or divergent computations. Under strict evaluation, the evaluation of any term containing a failing subterm fails. For example, the expression:
 print length([2+1, 3*2, 1/0, 5-4])
fails under strict evaluation because of the division by zero in the third element of the list. Under lazy evaluation, the length function returns the value 4 (i.e., the number of items in the list), since evaluating it does not attempt to evaluate the terms making up the list. In brief, strict evaluation always fully evaluates function arguments before invoking the function. Lazy evaluation does not evaluate function arguments unless their values are required to evaluate the function call itself.
The usual implementation strategy for lazy evaluation in functional languages is graph reduction. Lazy evaluation is used by default in several pure functional languages, including Miranda, Clean, and Haskell.
 argues for lazy evaluation as a mechanism for improving program modularity through separation of concerns, by easing independent implementation of producers and consumers of data streams. Launchbury 1993 describes some difficulties that lazy evaluation introduces, particularly in analyzing a program's storage requirements, and proposes an operational semantics to aid in such analysis. Harper 2009 proposes including both strict and lazy evaluation in the same language, using the language's type system to distinguish them.
Type systems.
Especially since the development of Hindley–Milner type inference in the 1970s, functional programming languages have tended to use typed lambda calculus, rejecting all invalid programs at compilation time and risking false positive errors, as opposed to the untyped lambda calculus, that accepts all valid programs at compilation time and risks false negative errors, used in Lisp and its variants (such as Scheme), though they reject all invalid programs at runtime when the information is enough to not reject valid programs. The use of algebraic datatypes makes manipulation of complex data structures convenient; the presence of strong compile-time type checking makes programs more reliable in absence of other reliability techniques like test-driven development, while type inference frees the programmer from the need to manually declare types to the compiler in most cases.
Some research-oriented functional languages such as Coq, Agda, Cayenne, and Epigram are based on intuitionistic type theory, which lets types depend on terms. Such types are called dependent types. These type systems do not have decidable type inference and are difficult to understand and program with. But dependent types can express arbitrary propositions in higher-order logic. Through the Curry–Howard isomorphism, then, well-typed programs in these languages become a means of writing formal mathematical proofs from which a compiler can generate certified code. While these languages are mainly of interest in academic research (including in formalized mathematics), they have begun to be used in engineering as well. Compcert is a compiler for a subset of the C programming language that is written in Coq and formally verified.
A limited form of dependent types called generalized algebraic data types (GADT's) can be implemented in a way that provides some of the benefits of dependently typed programming while avoiding most of its inconvenience. GADT's are available in the Glasgow Haskell Compiler, in OCaml and in Scala, and have been proposed as additions to other languages including Java and C#.
Referential transparency.
Functional programs do not have assignment statements, that is, the value of a variable in a functional program never changes once defined. This eliminates any chances of side effects because any variable can be replaced with its actual value at any point of execution. So, functional programs are referentially transparent.
Consider C assignment statement codice_2, this changes the value assigned to the variable codice_3. Let us say that the initial value of codice_3 was codice_5, then two consecutive evaluations of the variable codice_3 yields codice_7 and codice_8 respectively. Clearly, replacing codice_2 with either codice_7 or codice_8 gives a program a different meaning, and so the expression "is not" referentially transparent. In fact, assignment statements are never referentially transparent.
Now, consider another function such as int plusone(int x) {return x+1;} "is" transparent, as it does not implicitly change the input x and thus has no such side effects.
Functional programs exclusively use this type of function and are therefore referentially transparent.
Data structures.
Purely functional data structures are often represented in a different way than their imperative counterparts. For example, the array with constant access and update times is a basic component of most imperative languages, and many imperative data-structures, such as the hash table and binary heap, are based on arrays. Arrays can be replaced by maps or random access lists, which admit purely functional implementation, but have logarithmic access and update times. Purely functional data structures have persistence, a property of keeping previous versions of the data structure unmodified. In Clojure, persistent data structures are used as functional alternatives to their imperative counterparts. Persistent vectors, for example, use trees for partial updating. Calling the insert method will result in some but not all nodes being created.
Comparison to imperative programming.
Functional programming is very different from imperative programming. The most significant differences stem from the fact that functional programming avoids side effects, which are used in imperative programming to implement state and I/O. Pure functional programming completely prevents side-effects and provides referential transparency.
Higher-order functions are rarely used in older imperative programming. A traditional imperative program might use a loop to traverse and modify a list. A functional program, on the other hand, would probably use a higher-order “map” function that takes a function and a list, generating and returning a new list by applying the function to each list item.
Side-by-side comparison of imperative vs. functional programming.
The following two examples (written in JavaScript) achieve the same effect: they multiply all even numbers in an array by 10 and add them all, storing the final sum in the variable "result".
Traditional Imperative Loop:
const numList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let result = 0;
for (let i = 0; i < numList.length; i++) {
 if (numList[i] % 2 === 0) {
 result += numList[i] * 10;
Functional Programming with higher-order functions:
const result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 .filter(n => n % 2 === 0)
 .map(a => a * 10)
 .reduce((a, b) => a + b);
Simulating state.
There are tasks (for example, maintaining a bank account balance) that often seem most naturally implemented with state. Pure functional programming performs these tasks, and I/O tasks such as accepting user input and printing to the screen, in a different way.
The pure functional programming language Haskell implements them using monads, derived from category theory. Monads offer a way to abstract certain types of computational patterns, including (but not limited to) modeling of computations with mutable state (and other side effects such as I/O) in an imperative manner without losing purity. While existing monads may be easy to apply in a program, given appropriate templates and examples, many students find them difficult to understand conceptually, e.g., when asked to define new monads (which is sometimes needed for certain types of libraries).
Functional languages also simulate states by passing around immutable states. This can be done by making a function accept the state as one of its parameters, and return a new state together with the result, leaving the old state unchanged.
Impure functional languages usually include a more direct method of managing mutable state. Clojure, for example, uses managed references that can be updated by applying pure functions to the current state. This kind of approach enables mutability while still promoting the use of pure functions as the preferred way to express computations.
Alternative methods such as Hoare logic and uniqueness have been developed to track side effects in programs. Some modern research languages use effect systems to make the presence of side effects explicit.
Efficiency issues.
Functional programming languages are typically less efficient in their use of CPU and memory than imperative languages such as C and Pascal. This is related to the fact that some mutable data structures like arrays have a very straightforward implementation using present hardware. Flat arrays may be accessed very efficiently with deeply pipelined CPUs, prefetched efficiently through caches (with no complex pointer chasing), or handled with SIMD instructions. It is also not easy to create their equally efficient general-purpose immutable counterparts. For purely functional languages, the worst-case slowdown is logarithmic in the number of memory cells used, because mutable memory can be represented by a purely functional data structure with logarithmic access time (such as a balanced tree). However, such slowdowns are not universal. For programs that perform intensive numerical computations, functional languages such as OCaml and Clean are only slightly slower than C according to The Computer Language Benchmarks Game. For programs that handle large matrices and multidimensional databases, array functional languages (such as J and K) were designed with speed optimizations.
Immutability of data can in many cases lead to execution efficiency by allowing the compiler to make assumptions that are unsafe in an imperative language, thus increasing opportunities for inline expansion.
Lazy evaluation may also speed up the program, even asymptotically, whereas it may slow it down at most by a constant factor (however, it may introduce memory leaks if used improperly). Launchbury 1993 discusses theoretical issues related to memory leaks from lazy evaluation, and O'Sullivan "et al." 2008 give some practical advice for analyzing and fixing them.
However, the most general implementations of lazy evaluation making extensive use of dereferenced code and data perform poorly on modern processors with deep pipelines and multi-level caches (where a cache miss may cost hundreds of cycles) .
Functional programming in non-functional languages.
It is possible to use a functional style of programming in languages that are not traditionally considered functional languages. For example, both D and Fortran 95 explicitly support pure functions.
JavaScript, Lua, Python and Go had first class functions from their inception. Python had support for "lambda", "map", "reduce", and "filter" in 1994, as well as closures in Python 2.2, though Python 3 relegated "reduce" to the codice_12 standard library module. First-class functions have been introduced into other mainstream languages such as PHP 5.3, Visual Basic 9, C# 3.0, C++11, and Kotlin.
In PHP, anonymous classes, closures and lambdas are fully supported. Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style.
In Java, anonymous classes can sometimes be used to simulate closures; however, anonymous classes are not always proper replacements to closures because they have more limited capabilities. Java 8 supports lambda expressions as a replacement for some anonymous classes.
In C#, anonymous classes are not necessary, because closures and lambdas are fully supported. Libraries and language extensions for immutable data structures are being developed to aid programming in the functional style in C#.
Many object-oriented design patterns are expressible in functional programming terms: for example, the strategy pattern simply dictates use of a higher-order function, and the visitor pattern roughly corresponds to a catamorphism, or fold.
Similarly, the idea of immutable data from functional programming is often included in imperative programming languages, for example the tuple in Python, which is an immutable array, and Object.freeze() in JavaScript.
Applications.
Spreadsheets.
Spreadsheets can be considered a form of pure, zeroth-order, strict-evaluation functional programming system. However, spreadsheets generally lack higher-order functions as well as code reuse, and in some implementations, also lack recursion. Several extensions have been developed for spreadsheet programs to enable higher-order and reusable functions, but so far remain primarily academic in nature.
Academia.
Functional programming is an active area of research in the field of programming language theory. There are several peer-reviewed publication venues focusing on functional programming, including the International Conference on Functional Programming, the Journal of Functional Programming, and the Symposium on Trends in Functional Programming.
Industry.
Functional programming has seen use in a wide variety of industrial applications. For example, Erlang, which was developed by the Swedish company Ericsson in the late 1980s, was originally used to implement fault-tolerant telecommunications systems, but has since become popular for building a range of applications at companies such as Nortel, Facebook, Électricité de France and WhatsApp. Scheme, a dialect of Lisp, was used as the basis for several applications on early Apple Macintosh computers, and has been applied to problems such as training simulation software and telescope control. OCaml, which was introduced in the mid-1990s, has seen commercial use in areas such as financial analysis, driver verification, industrial robot programming, and static analysis of embedded software. Haskell, though initially intended as a research language, has also been applied by a range of companies, in areas such as aerospace systems, hardware design, and web programming.
Other functional programming languages that have seen use in industry include Scala, F#, Wolfram Language, Lisp, Standard ML, and Clojure.
Functional "platforms" have been popular in finance for risk analytics (particularly with the larger investment banks). Risk factors are coded as functions that form interdependent graphs (categories) to measure correlations in market shifts not unlike Gröbner basis optimizations but also for regulatory compliance such as Comprehensive Capital Analysis and Review. Given the use of OCAML or CAML variations in finance, these systems are sometimes considered related to a categorical abstract machine or CAM. Indeed, functional programming is heavily influenced by category theory.
Education.
Many universities teach or have taught functional programming as part of their undergraduate Computer Science degrees. Some use it as their introduction to programming, while others teach it after teaching imperative programming.
Outside of computer science, functional programming is being used as a method to teach problem solving, algebra and geometric concepts.
It has also been used as a tool to teach classical mechanics in "Structure and Interpretation of Classical Mechanics".


Isao Nakata

 is a Japanese professional shogi player, ranked 8-dan.
Nakata's nickname is コーヤン "Kōyan," after the on'yomi reading of his first name.
Theoretical contributions.
The Kōyan variation (コーヤン流 "Kōyan-ryū") of Third File Rook is named after him. In particular, his development of the so-called "Isao Nakata XP" is a very popular Third File Rook quick attack countermeasure against Static Rook Anaguma.
Promotion history.
Nakata's promotion history is as follows:
Awards and honors.
Nakata received the Japan Shogi Association's "25 Years Service Award" in 2011 in recognition of being an active professional for twenty-five years.


Akira Inaba

 is a Japanese professional shogi player, ranked 8-dan. Inaba, together with Tetsurō Itodani, Masayuki Toyoshima and Akihiro Murata, is one of four Kansai-based young shogi professionals who are collectively referred to as the "Young Kansai Big Four" (関西若手四天王 "Kansai Wakate Shitennō").
Promotion history.
Inaba's promotion history is as follows:
Titles and other championships.
Inaba has appeared in a major title match only once: he was the challenger for the Meijin title in 2017. He earned the right to challenge Amahiko Satō for the title by winning the 2016-2017 Class A ranking tournament with a record of 8 wins and 1 loss, thus becoming the eighth player in history to win the right to challenge for the Meijin title in his first year in Class A.
Inaba has won two non-major title championships: the 21st tournament in 2013, and the 70th NHK Cup tournament in 2021.
Year-end prize money and game fee ranking.
Inaba has finished in the "Top 10" of the JSA's once: he finished 6th with JPY 28,010,000 in earnings in 2017.


Clara Steinitz

Clara Steinitz (; 16 April 1852 – 1931) was a German novelist, feuilletonist, and translator from English, French, Italian, and Norwegian.
She was born to Jewish parents Bernhard and Pauline Klausner in Kobylin, Prussia, and was educated at Halle-on-the-Saale. In 1873 she married Siegfried Heinrich Steinitz, editor of "Die Deutsche Presse", with whom she moved to Berlin.
Among Steinitz's novels were "Des Volkes Tochter" (1878), "Die Hässliche" (1884), "Ihr Beruf" (1886), "Im Priesterhause" (1890), "Ring der Nibelungen" (1893), and "Irrlicht" (1895). She also translated several novels from foreign languages, including Bayard Taylor's "", Octave Feuillet's "Les amours de Philippe", Hjalmar Hjorth Boyesen's "Gunnar: A Tale of Norse Life" and "Under the Glacier", and Edward Bellamy's "Miss Ludington's Sister: A Romance of Immortality".