THE BOXER
Reviewed by Harvey Karten, Ph.D. Universal Pictures Director: Jim Sheridan Writer: Jim Sheridan, Terry George Cast: Daniel Day-Lewis, Emily Watson, Brian Cox. Ken Stott, Gerard McSorley, Eleanor Methven, Ciaran Fitzgerald, David McBlain, Damien Denny, Clayon Stewart, Kenneth Cranham
The troubles in Northern Ireland have been going since 1969, the term referring to the effort by Catholics living there, particularly by militant organizations like the Irish Republican Army, to force out the British troops whom they consider an army of occupation. As shown in Jim Sheridan's straightforward yet highly emotional and visceral movie "The Boxer," the city of Belfast looks bombed out, and what's more the hapless metropolis is separated into East and West districts by sandbags and checkpoints with British troops on patrol to check I.D. cards of those passing through. You wonder why the Catholics don't move to Ireland, the Protestants, perhaps, to London. Danny Flynn (Daniel Day-Lewis), the film's quietly intense hero, explains in his typically terse manner: This is my home. Not only does Danny choose not to move to London where he could pursue a promising career in the boxing ring: he returns from a British prison where he has served a fourteen-year sentence for IRA activities, and when he finds his flat sealed with stones, he takes a sledgehammer to the shelter and re-opens it for occupancy. Not that Danny has retained a dyed-in-the-wool yearning for the city of Belfast. He has returned from jail, from a sentence he could have avoided if he had only mentioned names of his co-conspirators, to reclaim the woman he romanced in his teen years and who remained in his mind throughout his incarceration.
With "The Boxer," Daniel Day-Lewis, an Oscar recipient from his role in "My Left Foot," is once again collaborating with his favorite director, Jim Sheridan, perhaps the most Irish of all filmmakers from a land actors, writers, and storytellers. This time Day-Lewis is teamed up with a marvelous English actress, the thirty-year-old Emily Watson, who turned in a magnificent performance as an eccentric Scottish 19-year-old in "Breaking the Waves," and the chemistry is palpable. As the unhappy wife of Danny's best friend who insists that her marriage was "over" before her son Liam was born, Maggie (Emily Watson) is herself in a kind of imprisonment. Since her husband--who was Danny's best friend--is now a political prisoner of the British, her activities are scrutinized by the whole community. Her Catholic neighbors, whether highly politicized or not, believe that any fooling around by women in her circumstances would demoralize them in their struggle against the Brits. The sexual tension between Danny and Maggie remains in the foreground of this complex film as Danny, who has barely uttered two words to his long-time sweetheart because of his emotional bottling up in prison, gradually warms up once again to Maggie while realizing that the two can barely touch without bringing on the condemnation of the neighbors, and even worse, severe punishment from the IRA.
Jim Sheridan succeeds in bringing home the torment of the people of Belfast who are surrounded by British soldiers, watched over by British helicopters, and kept under surveillance by their fellow Catholics in the IRA. Maggie's own father, Joe Hamill (Brian Cox), is the district leader of the organization. He must contend not only with Maggie's obvious attraction to Danny but with a hothead in his own organization, Harry (Gerard McSorley) who threatens to stoke the fires of hatred even as Joe is close to negotiating a peaceful end to the conflict with Britain. For her part Maggie must not only fend off the advances of the man to whom she is still mightily attracted but deal with her son, Liam (Ciaran Fitzgerald), a troubled lad who is convinced that his mom is about to leave him and run off with her teenage heartthrob.
Director Sheridan's sympathies appear to be with the peace faction of the IRA led by Joe and decidedly against the fanatical Harry, who is so opposed to any compromises with London that he singlehandedly reverses a peace process which is bringing opposing camps together. Using the sport of boxing as metaphor to bring home the conflicts faced on Europe's edge, Jim Sheridan and Terry George's script has its mellowed hero organize a gym to give the district kids something to do while simultaneously unifying the community by making his ring non-sectarian: Catholics and Protestants have been invited to box and to join as spectators and contestants together. In the movie's most surprising scene, Danny resorts to a tactic while boxing in London amid a crowd of upper-class British spectators which will bring to mind a surprisingly rebellious act in Tony Richardson's wonderful "The Loneliness of the Long Distance Runner."
Ultimately, "The Boxer" does not take sides between the British and the IRA, as such partisanship would not serve the cause of peace. Sheridan seems, however, to want the Catholics move forward and not be imprisoned--as both Maggie and Danny feel they are--by memories of the people who died for the cause, particularly for the ten imprisoned young men who starved themselves to death to call the world's attention to their country's plight. He is as sincere in bringing home the necessity for peace as is Kevin Costner in that actor-director's corny but equally unaffected epic, "The Postman." He succeeds in evoking audience sympathy not only by an honest screenplay which resorts to melodramatics only when clearly called for, but by superb ensemble performances highlighted by the suppressed romance of its principals. Daniel Day-Lewis once again shows his range as an overly controlled prizefighter whose most challenging struggle is in a continued pursuit of his romance with Maggie, while Emily Watson gives an endearing performance as a woman bound by her community's strictures, moving both toward and away from the man with whom she is still in love like a puppy exploring the trials of a new territory. The fight scenes are believable, if not particularly awe-inspiring while a broken-down area of Dublin serves well to depict the barbarous nature of Belfast's dilemma. Rated R. Running Time: 107 minutes. (C) 1997 Harvey Karten
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


|
Luwra
Minimal-overhead Lua wrapper for C++
|
Lifecycle of a reference. More...
#include <reference.hpp>
Public Member Functions | |
| void | push () const |
| Push the value inside the reference cell onto the originating Lua stack. | |
| void | push (State *target) const |
| Push the value inside the reference cell onto the given Lua stack. | |
| RefLifecycle (const RefLifecycle &other) | |
| Create a reference using an existing one. The lifecycles of these references are independent. | |
| RefLifecycle (RefLifecycle &&other) | |
| Take over an existing reference. The given reference's lifecycle is terminated. | |
| RefLifecycle (State *state) | |
| Create a reference using the value on top of the stack. Consumes the value. | |
| RefLifecycle (State *state, int index) | |
| Create a reference to a value on the stack. Does not consume the value. | |
| ~RefLifecycle () | |
Public Attributes | |
| int | ref |
| Reference identification. | |
| State * | state |
| State with the reference registry. | |
Lifecycle of a reference.
|
inline |
Create a reference using the value on top of the stack. Consumes the value.
|
inline |
Create a reference to a value on the stack. Does not consume the value.
|
inline |
Create a reference using an existing one. The lifecycles of these references are independent.
|
inline |
Take over an existing reference. The given reference's lifecycle is terminated.
|
inline |
|
inline |
Push the value inside the reference cell onto the originating Lua stack.
|
inline |
Push the value inside the reference cell onto the given Lua stack.
| int luwra::RefLifecycle::ref |
Reference identification.
| State* luwra::RefLifecycle::state |
State with the reference registry.


The learning process of a task motivates me in exploring the new dimensions of life. An inquisitive person, a problem solver, and a team player. I am always willing to dive deep into problems for a novel solution. Stays a self-motivated and insightful person while working on my things. Experienced in working on startup products where I curated things from end to end.
 I enjoy mountain hiking and rafting.
When forced indoors, I follow a number of sci-fi and fantasy genre movies and television shows, I spend a large amount of my free time exploring the latest technolgy advancements in the development world.
Technologies: Java,SpringBoot,Kafka,Elastic,AWS,MySQL,API
Building the product with designing the system.Worked as a committed team player and handled the ownership of tasks achieving the efficient results. Worked in fintech and ecommerce domain.
Taking ownership and researching on technologies to achieve the objectives.
Worked with the team end-to-end to launch a new product on the market named Zillion(previously Payback India)
Exposure of working with diverse technologies.Use case based analysis and break down the problems in different control flows.
Understood the organizational and systems oriented culture of working.Automate the real life problems through robotic process automation.
Creating a bridge between our cars and humans, equipped with anti-car theft management containing location tracker, voice control based
air-conditioner, and window panes control. It can be controlled easily through simple voice commands say ”Windowpanes up” or ”Turn on the
air conditioner”.
Tech Stack::Node MCU with ESP8266,IFTTT, Blynk Server,C++,Python,Flask,AWS.
Enhance your vocabulary by adding new words and retrieving the stored meanings.
 I enjoy mountain hiking and rafting.
When forced indoors, I follow a number of sci-fi and fantasy genre movies and television shows, I spend a large amount of my free time exploring the latest technolgy advancements in the development world.


KELLIA (the Koptische/Coptic Electronic Language and Literature International Alliance) is a partnership between digital Coptic projects and Copticists in Germany and the United States. Kellia’s goals are to establish standards for digital Coptic projects, including for transcription of Coptic and metadata curation, and to create or adapt open-source tools for linguistic analysis and annotation. Kellia is funded by a bilateral NEH/DFG grant.


We enhance methodologies!
- e-enable rich infomediaries
- disintermediate innovative e-markets
- deliver global bandwidth
- unleash integrated convergence
- repurpose holistic applications
- architect one-to-one bandwidth
- leverage vertical vortals
- disintermediate seamless niches
- transition revolutionary technologies
- e-enable distributed mindshare
- strategize frictionless markets


Registration allows you to keep track of all alerts you make on HashFlag. You can delete and modify specific alerts, as well as view past email digests that were sent to you.
Also, if you have previously opted to spam-protect your email address, you must register in order to unblock your email and start receiving alerts.


Some ticket
Reported by Dr Nic Williams | June 21st, 2009 @ 01:14 AM | in First Set
This is a ticket
The images below should be shown as thumbnails.
Reported by Dr Nic Williams | June 21st, 2009 @ 01:14 AM | in First Set
This is a ticket
The images below should be shown as thumbnails.


Arsenal 'will not recall Eddie Nketiah from Leeds United'
Arsenal reportedly have no intention of recalling Eddie Nketiah from his loan spell at Leeds United.
by Darren PlantDespite being sent to Elland Road to be provided with regular first-team football, the 20-year-old has been given just 12 substitute appearances in the Championship.
The lack of game time has led to speculation over the striker's immediate future, with it being suggested that the Gunners could send the England Under-21 international to another club.
However, The Sun claims that Nketiah will see out the campaign at Leeds, who are attempting to secure promotion to the Premier League.
Nkeitah has scored two goals from 289 minutes of football in the Championship, while another three strikes have come from two starts in the EFL Cup.
body check tags ::


--- layout: post title: 'NPR Story Mentions Clarkson University Biometric Expert: "WikiLeaks Raises Specter Of Biometric Data"' categories: [] tags: - biometrics - clarkson_university - geek - npr status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
"Among the cables obtained by WikiLeaks are several that point to the State Department's directive to embassy staff to collect human intelligence on foreign diplomats, including biometric information. NPR's Guy Raz talks to Stephanie Schuckers, professor of electrical and computer engineering at Clarkson University, about how one might go about collecting biometric information." -- http://www.npr.org/2010/11/30/131704360/wikileaks-raises-specter-of-biometric-data
Clarkson University is my alma mater. Go "Golden Knights!"


Enter Side 1:
Enter Side 2:
Enter Side 3:
A triangle is a polygon with three edges and three vertices. It has three sides and three angles.
Equilateral TriangleThree equal sides |
|
Isosceles TriangleTwo equal sides |
|
Scalene TriangleNo equal sides |
Enter Side 1:
Enter Side 2:
Enter Side 3:


CONSOLE
Section: Linux Programmer's Manual (4)Updated: 1994-10-31
Index Return to Main Contents
NAME
console - console terminal and virtual consolesDESCRIPTION
A Linux system has up to 63 virtual consoles (character devices with major number 4 and minor number 1 to 63), usually called /dev/ttyn with 1 < n < 63. The current console is also addressed by /dev/console or /dev/tty0, the character device with major number 4 and minor number 0. The device files /dev/* are usually created using the script MAKEDEV, or using mknod(1), usually with mode 0622 and owner root.tty.Before kernel version 1.1.54 the number of virtual consoles was compiled into the kernel (in tty.h: #define NR_CONSOLES 8) and could be changed by editing and recompiling. Since version 1.1.54 virtual consoles are created on the fly, as soon as they are needed.
Common ways to start a process on a console are: (a) tell init(8) (in inittab(5)) to start a mingetty(8) (or agetty(8)) on the console; (b) ask openvt(1) to start a process on the console; (c) start X --- it will find the first unused console, and display its output there. (There is also the ancient doshell(8).)
Common ways to switch consoles are: (a) use Alt+Fn or Ctrl+Alt+Fn to switch to console n; AltGr+Fn might bring you to console n+12 [here Alt and AltGr refer to the left and right Alt keys, respectively]; (b) use Alt+RightArrow or Alt+LeftArrow to cycle through the presently allocated consoles; (c) use the program chvt(1). (The key mapping is user settable, see loadkeys(1); the above mentioned key combinations are according to the default settings.)
The command deallocvt(1) (formerly disalloc) will free the memory taken by the screen buffers for consoles that no longer have any associated process.
Properties
Consoles carry a lot of state. I hope to document that some other time. The most important fact is that the consoles simulate vt100 terminals. In particular, a console is reset to the initial state by printing the two characters ESC c. All escape sequences can be found in console_codes(4).FILES
/dev/console/dev/tty*
SEE ALSO
chvt(1), deallocvt(1), loadkeys(1), mknod(1), openvt(1), console_codes(4), console_ioctl(4), tty(4), ttyS(4), charsets(7), agetty(8), init(8), mapscrn(8), mingetty(8), resizecons(8), setfont(8)COLOPHON
This page is part of release 3.22 of the Linux man-pages project. A description of the project, and information about reporting bugs, can be found at http://www.kernel.org/doc/man-pages/.
Index
This document was created by man2html, using the manual pages.
Time: 05:33:53 GMT, December 24, 2015


Michael Flynn texts Russian ambassador Sergey Kislyak to wish him a merry Christmas and to express condolences for a plane crash.


A Gentle Introduction to Haskell, Version 98
Because Haskell is a purely functional language, all computations are done via the evaluation of expressions (syntactic terms) to yield values (abstract entities that we regard as answers). Every value has an associated type. (Intuitively, we can think of types as sets of values.) Examples of expressions include atomic values such as the integer 5, the character 'a', and the function \x -> x+1, as well as structured values such as the list [1,2,3] and the pair ('b',4).
Just as expressions denote values, type expressions are syntactic terms that denote type values (or just types). Examples of type expressions include the atomic types Integer (infinite-precision integers), Char (characters), Integer->Integer (functions mapping Integer to Integer), as well as the structured types [Integer] (homogeneous lists of integers) and (Char,Integer) (character, integer pairs).
All Haskell values are "first-class"---they may be passed as
arguments to functions, returned as results, placed in data
structures, etc. Haskell types, on the other hand, are not
first-class. Types in a sense describe values, and the
association of a value with its type is called a typing. Using
the examples of values and types above, we write typings as follows:
5 :: Integer
'a' :: Char
inc :: Integer -> Integer
[1,2,3] :: [Integer]
('b',4) :: (Char,Integer)
The "::" can be read "has type."
Functions in Haskell are normally defined by a series of
equations. For example, the function inc can be
defined by the single equation:
inc n = n+1
An equation is an example of a declaration. Another kind of
declaration is a type signature declaration
(§4.4.1), with which we can declare an explicit typing
for inc:
inc :: Integer -> Integer
We will have much more to say about function definitions in Section
3.
For pedagogical purposes, when we wish to indicate that an expression e1 evaluates, or "reduces," to another expression or value e2, we will write:
e1 => e2
For example, note that:
inc (inc 3) => 5
Haskell's static type system defines the formal relationship between types and values (§4.1.4). The static type system ensures that Haskell programs are type safe; that is, that the programmer has not mismatched types in some way. For example, we cannot generally add together two characters, so the expression 'a'+'b' is ill-typed. The main advantage of statically typed languages is well-known: All type errors are detected at compile-time. Not all errors are caught by the type system; an expression such as 1/0 is typable but its evaluation will result in an error at execution time. Still, the type system finds many program errors at compile time, aids the user in reasoning about programs, and also permits a compiler to generate more efficient code (for example, no run-time type tags or tests are required).
The type system also ensures that user-supplied type signatures are correct. In fact, Haskell's type system is powerful enough to allow us to avoid writing any type signatures at all; (With a few exceptions to be described later.) we say that the type system infers the correct types for us. Nevertheless, judicious placement of type signatures such as that we gave for inc is a good idea, since type signatures are a very effective form of documentation and help bring programming errors to light.
[The reader will note that we have capitalized identifiers that denote specific types, such as Integer and Char, but not identifiers that denote values, such as inc. This is not just a convention: it is enforced by Haskell's lexical syntax. In fact, the case of the other characters matters, too: foo, fOo, and fOO are all distinct identifiers.]
Haskell also incorporates polymorphic types---types that are universally quantified in some way over all types. Polymorphic type expressions essentially describe families of types. For example, (forall a)[a] is the family of types consisting of, for every type a, the type of lists of a. Lists of integers (e.g. [1,2,3]), lists of characters (['a','b','c']), even lists of lists of integers, etc., are all members of this family. (Note, however, that [2,'b'] is not a valid example, since there is no single type that contains both 2 and 'b'.)
[Identifiers such as a above are called type variables, and are uncapitalized to distinguish them from specific types such as Int. Furthermore, since Haskell has only universally quantified types, there is no need to explicitly write out the symbol for universal quantification, and thus we simply write [a] in the example above. In other words, all type variables are implicitly universally quantified.]
Lists are a commonly used data structure in functional languages, and are a good vehicle for explaining the principles of polymorphism. The list [1,2,3] in Haskell is actually shorthand for the list 1:(2:(3:[])), where [] is the empty list and : is the infix operator that adds its first argument to the front of its second argument (a list). (: and [] are like Lisp's cons and nil, respectively.) Since : is right associative, we can also write this list as 1:2:3:[].
As an example of a user-defined function that operates on lists,
consider the problem of counting the number of elements in a list:
length :: [a] -> Integer
length [] = 0
length (x:xs) = 1 + length xs
This definition is almost self-explanatory. We can read the equations
as saying: "The length of the empty list is 0, and the length of a
list whose first element is x and remainder is xs is 1 plus the
length of xs." (Note the naming convention used here; xs is the
plural of x, and should be read that way.)
Although intuitive, this example highlights an important aspect of Haskell that is yet to be explained: pattern matching. The left-hand sides of the equations contain patterns such as [] and x:xs. In a function application these patterns are matched against actual parameters in a fairly intuitive way ([] only matches the empty list, and x:xs will successfully match any list with at least one element, binding x to the first element and xs to the rest of the list). If the match succeeds, the right-hand side is evaluated and returned as the result of the application. If it fails, the next equation is tried, and if all equations fail, an error results.
Defining functions by pattern matching is quite common in Haskell, and the user should become familiar with the various kinds of patterns that are allowed; we will return to this issue in Section 4.
The length function is also an example of a polymorphic function. It can be applied to a list containing elements of any type, for example [Integer], [Char], or [[Integer]].
| length [1,2,3] | => | 3 |
| length ['a','b','c'] | => | 3 |
| length [[1],[2],[3]] | => | 3 |
Here are two other useful polymorphic functions on lists that will be
used later. Function head returns the first element of a list,
function tail returns all but the first.
head :: [a] -> a
head (x:xs) = x
tail :: [a] -> [a]
tail (x:xs) = xs
Unlike length, these functions are not defined for all possible
values of their argument. A runtime error occurs when these functions
are applied to an empty list.
With polymorphic types, we find that some types are in a sense strictly more general than others in the sense that the set of values they define is larger. For example, the type [a] is more general than [Char]. In other words, the latter type can be derived from the former by a suitable substitution for a. With regard to this generalization ordering, Haskell's type system possesses two important properties: First, every well-typed expression is guaranteed to have a unique principal type (explained below), and second, the principal type can be inferred automatically (§4.1.4). In comparison to a monomorphically typed language such as C, the reader will find that polymorphism improves expressiveness, and type inference lessens the burden of types on the programmer.
An expression's or function's principal type is the least general type that, intuitively, "contains all instances of the expression". For example, the principal type of head is [a]->a; [b]->a, a->a, or even a are correct types, but too general, whereas something like [Integer]->Integer is too specific. The existence of unique principal types is the hallmark feature of the Hindley-Milner type system, which forms the basis of the type systems of Haskell, ML, Miranda, ("Miranda" is a trademark of Research Software, Ltd.) and several other (mostly functional) languages.
We can define our own types in Haskell using a data declaration, which we introduce via a series of examples (§4.2.1).
An important predefined type in Haskell is that of truth values:
data Bool = False | True
The type being defined here is Bool, and it has exactly two values:
True and False. Type Bool is an example of a (nullary) type
constructor, and True and False are (also nullary) data
constructors (or just constructors, for short).
Similarly, we might wish to define a color type:
data Color = Red | Green | Blue | Indigo | Violet
Both Bool and Color are examples of enumerated types, since
they consist of a finite number of nullary data constructors.
Here is an example of a type with just one data constructor:
data Point a = Pt a a
Because of the single constructor, a type like Point is often
called a tuple type, since it is essentially just a cartesian
product (in this case binary) of other types. (Tuples are
somewhat like records in other languages.)
In contrast, multi-constructor types, such as Bool and
Color, are called (disjoint) union or sum types.
More importantly, however, Point is an example of a polymorphic type: for any type t, it defines the type of cartesian points that use t as the coordinate type. The Point type can now be seen clearly as a unary type constructor, since from the type t it constructs a new type Point t. (In the same sense, using the list example given earlier, [] is also a type constructor. Given any type t we can "apply" [] to yield a new type [t]. The Haskell syntax allows [] t to be written as [t]. Similarly, -> is a type constructor: given two types t and u, t->u is the type of functions mapping elements of type t to elements of type u.)
Note that the type of the binary data constructor Pt is a -> a -> Point a,
and thus the following typings are valid:
Pt 2.0 3.0 :: Point Float
Pt 'a' 'b' :: Point Char
Pt True False :: Point Bool
On the other hand, an expression such as Pt 'a' 1 is ill-typed
because 'a' and 1 are of different types.
It is important to distinguish between applying a data constructor to yield a value, and applying a type constructor to yield a type; the former happens at run-time and is how we compute things in Haskell, whereas the latter happens at compile-time and is part of the type system's process of ensuring type safety.
[Type constructors such as Point and data constructors such as
Pt are in separate namespaces. This allows the same name to be used
for both a type constructor and data constructor, as in the following:
data Point a = Point a a
While this may seem a little confusing at first, it serves to make the
link between a type and its data constructor more obvious.]
Types can also be recursive, as in the type of binary trees:
data Tree a = Leaf a | Branch (Tree a) (Tree a)
Here we have defined a polymorphic binary tree type whose elements
are either leaf nodes containing a value of type a, or internal
nodes ("branches") containing (recursively) two sub-trees.
When reading data declarations such as this, remember again that Tree is a
type constructor, whereas Branch and Leaf are data constructors.
Aside from establishing a connection between these constructors, the
above declaration is essentially defining the following types for
Branch and Leaf:
Branch :: Tree a -> Tree a -> Tree a
Leaf :: a -> Tree a
With this example we have defined a type sufficiently rich to
allow defining some interesting (recursive) functions that use it.
For example, suppose we wish to define a function fringe that
returns a list of all the elements in the leaves of a tree from left
to right. It's usually helpful to write down the type of new
functions first; in this case we see that the type should be
Tree a -> [a]. That is, fringe is a polymorphic function that,
for any type a, maps trees of a into lists of a. A suitable
definition follows:
fringe :: Tree a -> [a]
fringe (Leaf x) = [x]
fringe (Branch left right) = fringe left ++ fringe right
Here ++ is the infix operator that concatenates two lists (its full
definition will be given in Section 9.1). As
with the length example given earlier, the fringe function is
defined using pattern matching, except that here we see patterns involving
user-defined constructors: Leaf and Branch. [Note that the
formal parameters are easily identified as the ones beginning with
lower-case letters.]
For convenience, Haskell provides a way to define type synonyms;
i.e. names for commonly used types. Type synonyms are created using a
type declaration (§4.2.2). Here are several
examples:
type String = [Char]
type Person = (Name,Address)
type Name = String
data Address = None | Addr String
Type synonyms do not define new types, but simply give new names
for existing types. For example, the type Person -> Name is
precisely equivalent to (String,Address) -> String. The new names
are often shorter than the types they are synonymous with, but this is
not the only purpose of type synonyms: they can also improve
readability of programs by being more mnemonic; indeed, the above
examples highlight this. We can even give new names to polymorphic
types:
type AssocList a b = [(a,b)]
This is the type of "association lists" which associate values of
type a with those of type b.
Earlier we introduced several "built-in" types such as lists, tuples, integers, and characters. We have also shown how new user-defined types can be defined. Aside from special syntax, are the built-in types in any way more special than the user-defined ones? The answer is no. The special syntax is for convenience and for consistency with historical convention, but has no semantic consequences.
We can emphasize this point by considering what the type
declarations would look like for these built-in types if in fact we
were allowed to use the special syntax in defining them. For example,
the Char type might be written as:
data Char = 'a' | 'b' | 'c' | ... -- This is not valid
| 'A' | 'B' | 'C' | ... -- Haskell code!
| '1' | '2' | '3' | ...
...
These constructor names are not syntactically valid; to fix them we
would have to write something like:
data Char = Ca | Cb | Cc | ...
| CA | CB | CC | ...
| C1 | C2 | C3 | ...
...
Even though these constructors are more concise, they are quite
unconventional for representing characters.
In any case, writing "pseudo-Haskell" code in this way helps us to see through the special syntax. We see now that Char is just an enumerated type consisting of a large number of nullary constructors. Thinking of Char in this way makes it clear that we can pattern-match against characters in function definitions, just as we would expect to be able to do so for any of a type's constructors.
[This example also demonstrates the use of comments in Haskell; the characters -- and all subsequent characters to the end of the line are ignored. Haskell also permits nested comments which have the form {-...-} and can appear anywhere (§2.2).]
Similarly, we could define Int (fixed precision integers) and
Integer by:
data Int = -65532 | ... | -1 | 0 | 1 | ... | 65532 -- more pseudo-code
data Integer = ... -2 | -1 | 0 | 1 | 2 ...
where -65532 and 65532, say, are the maximum and minimum fixed
precision integers for a given implementation. Int is a much larger
enumeration than Char, but it's still finite! In contrast, the
pseudo-code for Integer
is intended to convey an infinite enumeration.
Tuples are also easy to define playing this game:
data (a,b) = (a,b) -- more pseudo-code
data (a,b,c) = (a,b,c)
data (a,b,c,d) = (a,b,c,d)
. .
. .
. .
Each declaration above defines a tuple type of a particular length,
with (...) playing a role in both the expression syntax (as data
constructor) and type-expression syntax (as type constructor). The
vertical dots after the last declaration are intended to convey an
infinite number of such declarations, reflecting the fact that tuples
of all lengths are allowed in Haskell.
Lists are also easily handled, and more interestingly, they are recursive:
data [a] = [] | a : [a] -- more pseudo-code
We can now see clearly what we described about lists earlier: [] is
the empty list, and : is the infix list constructor; thus [1,2,3]
must be equivalent to the list 1:2:3:[]. (: is right
associative.) The type of [] is [a], and the type of : is
a->[a]->[a].
[The way ":" is defined here is actually legal syntax---infix constructors are permitted in data declarations, and are distinguished from infix operators (for pattern-matching purposes) by the fact that they must begin with a ":" (a property trivially satisfied by ":").]
At this point the reader should note carefully the differences between tuples and lists, which the above definitions make abundantly clear. In particular, note the recursive nature of the list type whose elements are homogeneous and of arbitrary length, and the non-recursive nature of a (particular) tuple type whose elements are heterogeneous and of fixed length. The typing rules for tuples and lists should now also be clear:
For (e1,e2,...,en), n>=2, if ti is the type of ei, then the type of the tuple is (t1,t2,...,tn).
For [e1,e2,...,en], n>=0, each ei must have the same type t, and the type of the list is [t].
As with Lisp dialects, lists are pervasive in Haskell, and as with
other functional languages, there is yet more syntactic sugar to aid
in their creation. Aside from the constructors for lists just
discussed, Haskell provides an expression known as a list
comprehension that is best explained by example:
[ f x | x <- xs ]
This expression can intuitively be read as "the list of all f x
such that x is drawn from xs." The similarity to set notation is
not a coincidence. The phrase x <- xs is called a generator,
of which more than one is allowed, as in:
[ (x,y) | x <- xs, y <- ys ]
This list comprehension forms the cartesian product of the two lists
xs and ys. The elements are selected as if the generators were
"nested" from left to right (with the rightmost generator varying
fastest); thus, if xs is [1,2] and ys is [3,4], the result is
[(1,3),(1,4),(2,3),(2,4)].
Besides generators, boolean expressions called guards are
permitted. Guards place constraints on the elements generated. For
example, here is a concise definition of everybody's favorite sorting
algorithm:
quicksort [] = []
quicksort (x:xs) = quicksort [y | y <- xs, y<x ]
++ [x]
++ quicksort [y | y <- xs, y>=x]
To further support the use of lists, Haskell has special syntax for arithmetic sequences, which are best explained by a series of examples:
| [1..10] | => | [1,2,3,4,5,6,7,8,9,10] |
| [1,3..10] | => | [1,3,5,7,9] |
| [1,3..] | => | [1,3,5,7,9, ... (infinite sequence) |
More will be said about arithmetic sequences in Section 8.2, and "infinite lists" in Section 3.4.
As another example of syntactic sugar for built-in types, we
note that the literal string "hello" is actually shorthand for the
list of characters ['h','e','l','l','o']. Indeed, the type of
"hello" is String, where String is a predefined type synonym
(that we gave as an earlier example):
type String = [Char]
This means we can use predefined polymorphic list functions to operate
on strings. For example:
"hello" ++ " world" => "hello world"


CHAPTER 273
RAILWAY LAW
Section
273-1 Franchise
273-2 Granting public lands, etc.
273-3 Special powers
273-4 Compensation to be made
273-5 Width of land taken
273-6 Superfluous lands to be sold
273-7 Offered to adjoining owners first
273-8 Acceptance of offer
273-9 Arbitration of price
273-10 Nature of motive power allowable
273-11 Right to provide same, subject to rights of others
273-12 Railway to be fenced
273-13 Bylaws, regulations
273-14 Penalty for violating
273-15 Bonds
273-16 Aid to public railroads only


|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Class Summary | |
| DOUBLE_Upper | This class represents the upper half of a DOUBLE variable. |
| IntList | A small utility class representing a set of basic int values. |
| LocalVariableInfo | A utility class holding the information about the name and the type of a local variable in a given slot (== index). |
| LocalVariablesInfo | A utility class holding the information about the names and the types of the local variables in a given method. |
| LONG_Upper | This class represents the upper half of a LONG variable. |
| Pass1Verifier | This PassVerifier verifies a class file according to pass 1 as described in The Java Virtual Machine Specification, 2nd edition. |
| Pass2Verifier | This PassVerifier verifies a class file according to pass 2 as described in The Java Virtual Machine Specification, 2nd edition. |
| Pass3aVerifier | This PassVerifier verifies a class file according to pass 3, static part as described in The Java Virtual Machine Specification, 2nd edition. |
| StringRepresentation | BCEL's Node classes (those from the classfile API that accept() Visitor instances) have toString() methods that were not designed to be robust, this gap is closed by this class. |
Provides PassVerifier classes used internally by JustIce. You don't need to bother with them.
|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


WITNESS LIST Nominations Committee March 27, 2001 - 1:30P Colorado River Authority, Central ON: Scott, Ben J. (Self), Coleman, TX Colorado River Authority, Lower FOR: Lambert, Robert W. (Self), Horseshoe Bay, TX Texas Board of Acupuncture Examiner FOR: Voris, Marshall D. (Self), Corpus Christi, TX ON: Garcia, Jr., Pedro V. (Self), Lubbock, TX Lin, Meng-Sheng Linda (Self), Plano, TX Texas Board of Human Services FOR: Bradley, Jon M. (Self), Dallas, TX Cuellar, John A. (Self), Dallas, TX Johnson, Manson B. (Self), Houston, TX Wilkinson, Teresa (Terry) (Self), Midland, TX Texas Board on Aging FOR: Brandon, Ronald (Self), Georgetown, TX Dickerson, Ben E. (Self), Waco, TX Lund, Nancy L. (Self), Texarkana, TX Tankerson, Richard Earl (Self), San Antonio, TX ON: Wray, Nelda (Self), Houston, TX Texas Department of Housing and Com ON: Bogany, Shadrick (Self), Missouri City, TX Gonzalez, Vidal (Self), Del Rio, TX Texas Health Care Information Counc FOR: Ater, Candus (Self), Salado, TX Foxall, M.D., Lewis E. (Self), Houston, TX Thomas-Melton, Verna (Self), Garland, TX ON: Swann, Karl W. (Self), San Antonio, TX


This is the real bank note or you can use it cash in the old China society. Various of handwriting to indicate the value and multiple stamps from the officials to grant authority to this note.
When I saw this antique in the muzeum it reminds me so much of how our currency have developed. From bank note like this to the fiat currency, then credit cards and here we are in the burst of cryptocurrency.
It is also interesting to see how we moved our trust in the money system. First the people deposit gold or silver into the unincorperated bank and they issue a bank note to act as a bond. And that is a product of trust between the private banks and investor with the value backed by gold inside the vault.
Now we are in the trustless system of cryptocurrency where there is no bank in between the users hence, we don’t have to trust anyone. Absolutely an amazing feeling looking at the old bank note that serve no more purpose than just a antique in a muzeum while realizing I have some Bitcoin in my phone which I can spend everywhere.
In the next 100 years, will the blockchain technology and cryptocurrency like Bitcoin survive? Not sure, but I’m certain that they wouldn’t be able to stick a Bitcoin on the muzeum wall in 2200.
这是古代的银票，是我在参观青州博物馆时看到的。在上面可以看到手写的各种数字和几个盖章表明着这张银票的权威性和价值。当然现在它们不再是银票，随着时代转变已经变成了博物馆上的文物。
古时候人们都是用金银交易，然后钱庄就出现了。人们只需要把金银存放进去代表了权威的钱庄，钱庄发出张债劵，这就算是中国古社会最早最初的现金雏形。从银票开始，人们经历了现金，信用卡，再到现在的虚拟货币。
这过程中可以很有趣的看到货币系统中的信任转换 。银票可以被使用是因为当时人们信任钱庄真的可以保存对应的金银。然后到现代银行也是一样的道理，我们相信存放进去的钱真的是在里面的，需要的时候银行会如数全给回我们，在太平稳定的国家的确如此。
最后就是无需信任的区块链技术上的虚拟货币登场了，我们正在潮流的前端。
看着这张曾经让许多人趋之若鹜的银票，我想起手机里的虚拟货币，心里不禁感概万千，不知一百年后的比特币会是什么下场。但就算它已经成为历史，我想在 2200 年博物馆的墙上也没办法贴上比特币，毕竟不存在啊，呵呵。
This page is synchronized from the post: ‘Old and new money 银票和比特币’


LncATLAS is an easy to use web-based visualization tool to obtain useful information about expression localization of long non-coding class of RNAs. It is easy to use by just searching your lncRNA of interest in the search box. You can also use ENSEMBL gene IDs to select them. There are also some reference genes with a clear nuclear or cytoplasmatic expression profile. In some plots (3 and 4) you could also select the cell line from the dropdown menu to obtain a zoom into the distributions. Although many genes would have a similar profile among cell lines there might exist small changes. In lncATLAS we provide 6 charts that can be divided into 3 sections:
The 2 major alternative usages for lncATLAS are to download raw data for
a single selection of genes that can be done directly on the front page or
to download a specific data set from a list of gene IDs in a batch mode.
This second
feature is in the get raw data tab.
After entering the list a .csv
file with
the expression values from the selected genes will be generated.
In the input, gene IDs must be placed as a column.
In the main page, in the search box, you can enter at least 3 genes by the gene name and for the gene ID input. If more, only the first 3 will be considered.
The data used and displayed in lncATLAS is directly obtained from
GENCODE release (
V24
). and is available through our web site in the
download all data button from get raw data panel.
The RCI or Relative Concentration Index has been calculated as follows:
$$ RCI = \log_{2} (\frac{Fraction_{i} \quad (RPKMs)}{Fraction_{j} \quad (RPKMs)}) $$
Being the fraction i the cytoplasm and j the nuclear one for CN
RCI shown in most plots. This changes for appropiate subnuclear and
subcytoplasmic fractions in the last plot from the K562 cell line.
Our intention in representing the subcellular localisation with the RCI is
to give a value that represents how more concentrated is a particular
gene in one fraction compared to another. It's a flexible approach that
permits to compare individual genes easily.
All the subcellular compartiments available are shown in the
following diagram.
This project has been carried out by
Rory Johnson's Lab
in the Department of Clinical Research (DCR) of the University of Bern and
Roderic Guigo's Lab
in the
Centre for Genomic Regulation
at Barcelona.
If you have questions or need further information please open an issue in our github repository.
If you find lncATLAS useful for your research please cite our paper.
Mas-Ponte D, Carlevaro-Fita J, Palumbo E, Pulido TH, Guigo R, Johnson R. LncATLAS database for subcellular localization of long noncoding RNAs. Rna. 2017 Jul 1;23(7):1080-7.
You are free to use any of the generated outputs from this web-site if
cited appropriately. This site plots are under the
CC BY 4.0 license
.


ROBINSON IN SPACE A film review by Martin Rich Copyright 1997 Martin Rich
'Robinson in Space' is an off-beat, literary, view of England - with a very brief excursion into France and Belgium - through the eyes of two men taking part in a curious, enigmatic, survey. It's hardly mainstream cinema, but is a very perceptive account of England's changing landscape, or what might be termed a post-industrial economy.
Its director Patrick Keiller established the style with the film 'London' three years ago. As with 'London' the two characters are the explorer, Robinson, and an un-named narrator, and as before we see neither of them and only hear the voice of the narrator, played by Paul Schofield. Robinson, formerly an art lecturer, is now teaching in Reading; we are never quite told the reasons but his first survey apparently made him enough enemies to drive him out of London.
Robinson is preoccupied by literary references - especially those to Daniel Defoe: presumably the name Robinson is derived from Robinson Crusoe. Early in the film, the references to writers comme thick and fast - along with a few other topics such as world-war 2 aicraft, and the substance Buckminster-Fullerine.
Robinson has a keen eye for the surreal, and for signs of a country no longer the industrial power that it once was. Early in the film we see customers waiting outside a record shop to meet Adam Ant. Later, the Queen is opening a new plant - built by the Korean company Samsung. Coal, once such an important natural resource, is now imported from South Africa.
True, there are times when the narrator appears too preoccupied with the facts and figures of Britain's industrial decline - and some more literary allusions would lighten the tone. But it's a thought-provoking and very individual film - essentially a documentary but one which gently draws us into its own view of life.
But maybe it's not as literary as it seems, and maybe the name isn't really taken from Daniel Defoe. Robinson and Keiller (the director's name) are both makes of marmalade. Surely this is no coincidence...
-- Martin Rich Phone(0171) 477 8627 Fax(0171) 477 8628 Lecturer in Information Management, City University Business School Frobisher Crescent, Barbican Centre, London EC2Y 8HB, UK<EMAIL_ADDRESS>http://www.city.ac.uk/martin
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Event Location:
Australian Institute of Management
Cnr Boundary Rosa Streets
Spring Hill, QLD, Australia
Abstract:
Within every Data Warehouse project there is always ETL development that is very repetitive in nature, for example, you need to import 20 different flat file exports from the ERP system, you need to load 15 dimensions into the data warehouse and so on. With Microsoft SSIS out-of-the-box, you are forced to create multiple individual packages which is very time consuming due to the lack of easy code reuse. In a typical BI project, the ETL implementation can easily take up 60% of the project time, so it is beneficial if the development time of similar SSIS packages can be cut down. Business Intelligence Markup Language (Biml) is an XML dialect for defining Business Intelligence assets across the Microsoft SQL Server platform In this session Craig will introduce you to Biml BimlScript, providing those new to Biml with a foundational understanding of what BIML is and what the benefits of using Biml are.
Speaker(s): Craig Bryden,
Abstract:
Power BI is a Microsoft's self-service BI platform for both on-premise and cloud-based data. It enables business Power Users to make the most of their data by using the new data discovery, analysis and visualisation features in Excel and Office 365, in an easy to use environment that they are already familiar with. In this session we will go through the new features and capabilities of Power BI. We will also discuss best practices and tips along the way that will enable you to get the best out of this exciting technology. Topics include: Overview, real-life demo, hybrid-cloud scenarios with Data Management Gateway, DMG tips and tricks, custom map demo, QA tips, licensing overview, Power BI roles in an enterprise environment, how this could fit your organisation, lessons learned from our 1.5 year journey, dashboard designer, SSAS connector, etc.
Speaker(s): Iman Eftekhari,
Abstract:
Historically, users have been constrained to consume data in fixed platforms, with one specific dimension for digital viewings and a couple of printed layouts. Nowadays, with the ubiquitous mobile devices available, Management expects to know key business indicators and day-to-day operation performance on the go. Using well-designed data models and visualization techniques, Power View can leverage timely and quick dashboards for analysis on the go. This session will discuss how to design the appropriate data model to enable self-service data exploration and insightful analysis in Power View, and how to create pixel perfect visualization for mobile devices. You will also learn how the techniques differ from traditional platforms. Using live demo, we will walk through ways to channel users focus on actionable analytics.
Speaker(s): Julie Koesmarno,
Abstract:
It’s often the case that your budget doesn’t stretch far enough for all the great third party tools that help manage your SQL Servers. So, how can the in-built components of SQL Server help you with your daily tasks? Policy Management, Data Collector and Extended Events, all included in both Enterprise and Standard Editions, provide a framework to keep your configurations consistent and give you some insights into the performance of your SQL Server instances. In this session, we will see how to make use of these components to formalize your configuration and track some performance attributes. After this session you’ll be able to build out an effective management and monitoring toolkit using only “out-of-the-box” features.
Speaker(s): Martin Cairney,
Abstract:
UNLOCKING THE FIGHTER PILOT IN EVERY DBA – Let’s discuss how piloting tactical jets and flying SQL Servers requires similar psychology, skills and composure, especially during emergencies! DBA performance in production environments matters greatly, even on the easiest of days. But when things go wrong, that’s when you really earn your money and discover the depth of your knowledge and your poise in emergency response. We’ll focus on improving successful handling of critical situations. Content is based upon the collective knowledge gained by many people over many years in high performance aircraft. We’ll investigate examples of how to, and how not to, handle extremely difficult situations. We will look at bullet proof techniques for improving DBA crisis management. We’ll dig into teamwork/crew coordination during critical scenarios. Get ready for takeoff as you’ll see some captivating flight video and, if you have the courage to, participate in a live exercise.
Speaker(s): Nicholas Loghides,
Abstract:
In this double session using a live-typing approach, we will show the overall structure of a Biml file and the core syntax patterns. Then he will demonstrate how the power of BimlScript is amplified by the availability of rich metadata sources to drive the automatic creation of your Data Vault solution. We will demonstrate a flexible and reusable framework for storing and managing the metadata that you will use as an input to your BimlScripts. We will bring it together with a walking through a fully featured production framework and the code it generates. We will add unit test and continuous integration using MSBuild and the BimlCompiler allowing for changes in the source to drive the re-factoring of your Data Vault development.
Speaker(s): Peter Avenant,
Abstract:
As organizations look to lower infrastructure costs and increase worker productivity, two industry trends have emerged: the shift to the cloud and self-service. How will these trends change the way we build BI solutions, without compromising on security, manageability and governance? Join this session and find out! We will explore the following questions: What is Power BI? What do you need to run Power BI? How does Power BI differ to traditional BI? Where does Power BI fit in a broader enterprise BI strategy? And, finally, how can on-premises data sources be used in cloud-based Power BI solutions? In addition to answering these questions, we will build a Power BI solution from scratch using both on-premises and cloud-based data sources. We will use Power Query, Power Pivot, Power View and Power Map, before deploying the solution to a Power BI site in the cloud, and interacting with it using Q A, the new natural language query technology.
Speaker(s): Rod Colledge,
Abstract:
In this session we will discuss Data Warehouse Automation, how it can improve you productivity as a developer and, at the same time, produce a consistent and flexible Data Warehouse that's easy to change. In the session we will build a Data Warehouse using a Data Warehouse Automation tool, so you can see the process in action. We will also look at EzAPI an alternative to BIML, that you can use to generate SSIS packages. Using EzAPI you can save time by starting with a standard SSIS package as a template, and then modify through code. Data Warehouse Automation lets you stay focused on what really matters... producing valuable analytics and reporting for your business users
Speaker(s): Adam Gilmore,
Abstract:
Much of the fanfare for Microsoft SQL Server 2014 has been around the new In-Memory Optimization features. However SQL Server 2014 introduces a number of new Data Platform features for managing SQL Server. These new management features have been designed to assist with diagnosing and resolving common performance issues. This session demonstrates how to troubleshoot various scenarios using the new features in SQL Server 2014. In this session you will learn how to monitor the performance of your severs over time and provide a greater insight into SQL Server.
Speaker(s): Peter Ward,
Abstract:
"A Festivus for the rest of us!". That was how Seinfeld character Frank Costanza described his alternative to the Christmas tradition. In this session, I'll describe an alternative to the traditional approach to Data Science. Armed with nothing but a browser and an internet connection, I'll show you how easy it is to use Azure Machine Learning to build cloud-powered predictive models and deploy them as web services for application integration. After setting the context of where predictive modelling fits in the overall analytics spectrum, we'll dive into the Azure offering, before building and deploying a machine learning model from scratch using Azure Machine Learning Studio.
Speaker(s): Peter Myers,
Abstract:
Well, you can tell by the way I use WAIT STATS, I’m a DBA, and I like the DAC. PERFMON’s on and PAL is warm, I check LOCKS and BLOCKS for not the norm. Whether you’re a brother or whether you’re a mother, this session will have your SQL Servers stayin’ alive. Ah, ha, ha, ha, stayin' alive. All critical features and tools that you must know and use to keep your SQL Servers stayin’ alive.
Speaker(s): Heidi Wilson,
Abstract:
Data Recovery is a major part of a DBA’s job. As a DBA how can we ensure our mission critical data is available and recoverable in a timely manner when disaster strikes. As a production support DBA how can you ensure you’re mission critical data is protected? With the release of SQL Server 2014, changes were made to the AlwaysOn Availability Group feature set. In this session Warwick will introduce you to what Availability Groups are, breaking the confusion of DB Mirroring, FCI’s and AG’s, Introduce the new AG functionality and show you how this feature set can be used to extend your mission critical disaster recovery capabilities to cloud city.
Speaker(s): Warwick Rudd,
Abstract:
Azure SQL Database has been out for a while now, but the limited feature set has proved a barrier for adoption. Well, the latest additions to the TSQL surface area bring the offering more into line with SQL Server 2014 and the gap will only get smaller over time. Come along to this session and fin out more about the new features and how to go about managing Azure SQL Database with your tool of choice, weather that is SSMS, Powershell or Visual Studio.
Speaker(s): Martin Catherall,
Abstract:
Over the last 5 years Powershell has become the “go to” tool for the automation and management of the Windows platform and SQL Server. In this session we will walk through a number of Powershell functions, code snippets and techniques that can help fast track the development of automation and management DBA scripts. The examples in the session will show case Powershell building blocks like logging, exclude/include lists, read/validate INI files, retries, report generation, data load of performance data etc.
Speaker(s): Rob Risetto,
Abstract:
With Azure data centres located in Australia, will your company be looking more at cloud options? The Azure VM approach doesn't change your day to day role much, but Azure SQL Database certainly does. This session will look at the DBA functions for an Azure SQL Database instance and compare that with your regular on-premise approach. We'll demo some of techniques that can be used.
Speaker(s): Martin Cairney,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: http://www.linkedin.com/in/juliekoesmarno
Contact: http://www.mssqlgirl.com
Julie Koesmarno, MCSE Data Platform, and MCSE Business Intelligence, MCT, is a Senior Program Manager at Microsoft, with a Bachelor’s degree in IT. She has over 10 years of experience working with SQL Server for large-scale and multi-million-dollar OLTP and ETL projects as a SQL Server developer and system analyst/designer. Her past projects include delivering a SQL Server 2012 data warehouse and BI solutions in the US and Australia. She now works with hybrid, cloud and on-prem SQL projects.
Contact: http://www.varigence.com.au
Peter Avenant is the Technical Director at Varigence Australia, an SSIS Developer, Trainer and Consultant, and SQL Server data warehouse specialist. His background includes developing a cloud metadata framework that integrates with BimlScript to create both data vault and dimensional data warehouses.
LinkedIn: http://au.linkedin.com/in/petersward/
Contact: http://wardyit.com/blog
Peter Ward is WARDY IT Solutions Chief Technical Architect. Peter's credentials and achievements include being a highly regarded speaker at SQL Server events; a sought after SQL Server consultant and trainer providing solutions for some of the largest SQL Server sites in Australia. Peter has been recognised as a Microsoft Most Valuable Professional for his technical excellence and commitment to the SQL Server Community.
LinkedIn: https://au.linkedin.com/in/ieftekhari
Contact: http://www.agilebi.com.au
Iman Eftekhari (MCSE BI, MCITP, CSP) has been involved in many successful BI implementations mainly with financial services, health and the public sectors. He has presented at number of events such as PASS SQLSaturday Sydney, Brisbane, Melbourne, Copenhagen,Sydney BI User Group, SQL Server User Group, etc. Iman is the co-founder of the Agile BI consulting, co-organiser of the Sydney BI Social group (SYBIS) and Sydney Power BI User Group (PUG).
LinkedIn: http://au.linkedin.com/pub/warwick-rudd/0/956/718
Contact: http://www.sqlmastersconsulting.com.au/Blog
Warwick Rudd is a Microsoft Certified Master – SQL Server 2008 and Principal Consultant at SQL Master Consulting. He is a frequent speaker at local SQL Server User Groups and SQLSaturday events in Australia. When not playing with the SQL stack, Warwick likes to get away to the cold and spend time snowboarding.
Contact: http://dbinsight.com.au
Rob Risetto is founder and technical director of DBInsight, a Queensland based SQL Server consulting company. Rob has over 24 years’ experience in managing and designing database environments with over 15 years’ SQL Server experience. Rob is passionate about the SQL Server Engine, and the techniques to maximise performance, scalability and high availability.
LinkedIn: https://www.linkedin.com/in/loghides
Cross a former Navy tactical jet pilot, Combat Air Medal recipient, Jet flight instructor, adversary pilot, and Certified Airline Transport Pilot with a current MCSE DP, SQL Server DBA and consultant with 15 years of technical experience and the result is … Nick, a seasoned DBA with nerves of steel and a unique perspective who blends the paradigms of aviation with DBA work, bringing lessons learned (some in blood) from both worlds to bear on critical situation handling.
LinkedIn: http://linkedin.com/in/rodcolledge
Contact: http://www.rodcolledge.com
Rod Colledge is the national BI practice lead for DWS, a leading publicly listed Australian IT Services company. With 15+ years of SQL Server experience, Rod#39;s commitment and depth of knowledge was recognized in 2010 with a Microsoft MVP award for SQL Server. This is Rod#39;s 6th consecutive year as an MVP. Rod has authored or contributed to three books, including the “SQL Server MVP Deep Dives” series. He#39;s a sought-after speaker at both local and international SQL Server conferences.
LinkedIn: http://au.linkedin.com/in/martincairney
Martin has 20 years’ experience in SQL Server technologies. His experience spans both the Database Engine and infrastructure requirements, and Data Warehousing and BI implementations. He has worked across many industry sectors including London’s global financial institutions and both State and Federal Government Departments. He is a SQL Server MVP, MCT and an experienced conference presenter, having presented at PASS Summit, SQLBits, and SQLSaturday events and User Groups round the world
LinkedIn: http://www.linkedin.com/pub/adam-gilmore/3/902/576
Contact: http://www.dimodelo.com/blog
Adam Gilmore is a Data Warehousing and Business Intelligence Architect with 10+ years experience using Microsoft technologies to deliver BI and DW Solutions. Adam is the Founder of Dimodelo Solutions, an Agile Data Warehousing and Business Intelligence consultancy. Dimodelo Solutions is the developer of 'Dimodelo Architect' an Agile Data Warehouse development tool built on the Microsoft Visual Studio platform. Adam has presented at a number of SQL Server events in Brisbane including the SQL Server User Group and SQL Server Saturday.
LinkedIn: http://au.linkedin.com/in/martincairney
Martin has 20 years’ experience in SQL Server technologies. His experience spans both the Database Engine and infrastructure requirements, and Data Warehousing and BI implementations. He has worked across many industry sectors including London’s global financial institutions and both State and Federal Government Departments. He is a SQL Server MVP, MCT and an experienced conference presenter, having presented at PASS Summit, SQLBits, and SQLSaturday events and User Groups round the world
LinkedIn: https://www.linkedin.com/in/martincatherall
Contact: http://martincatherall.com
Martin is a data consultant in Melbourne, Australia, a Microsoft Data Platform MVP, and PASS Regional Mentor for the Asia Pacific (APAC) region. Martin founded the Christchurch, New Zealand PASS Local Group and lead the group for a number of years before relocating to Melbourne. He has been using SQL Server in various roles since 2000. In addition to anything data related, he enjoys playing the guitar and having fun with his family.
LinkedIn: http://linkedin.com/in/peterjsmyers
Peter Myers is a consultant, trainer and presenter, and has worked with Microsoft database and development products since 1997. Today he specializes in all Microsoft Business Intelligence products and also authors training course content for Microsoft products and services. He has a broad business background supported by a bachelor’s degree in applied economics and accounting, and he extends this with extensive experience backed by current MCSE certifications. He has been a Data Platform MVP since 2007.
Contact: http://sqlskirt.com
Heidi Wilson is an independent SQL Server Consultant and Microsoft Certified Trainer. Heidi has over 10 years of experience working with SQL Server and specialises in the design and implementation of highly available and disaster recoverable SQL Server solutions. Heidi regularly presents and volunteers at various events including SQLSaturday and SQL Server User Groups across Australia.
LinkedIn: https://www.linkedin.com/in/craigbryden/
Craig has been working with SQL Server for over 20 years and currently holds several SQL Server based certifications. He has also previously held an MCT certification. Craig's contribution to the SQL Server community was recognised in 2018 with a Microsoft MVP award. He was involved with Microsoft Learning to set some of the current SQL server Exams. Craig is the Chief Data Strategist at BiTQ. Craig is an organiser of the QLD Power BI User Group
The following is a list of sponsors that helped fund the event.


ZARS is an online reservation application. Usage of ZARS is subject to invitation only. To use the reservation application you must have been invited by the site operator and a user account must have been created for you. It is not possible to sign up for a user account.
ZARS has been developed and tested with Mozilla Firefox 3.6 on Windows but should work with a recent version of all major Internet Browsers. Javascript must be enabled in order to use ZARS.


Interval Notes
Setting the Baseline Default Reader
Just to ensure that we have the same baseline readtable, we are going to make sure that the cl-postgres:*sql-readtable* is set to the default.
(setf cl-postgres:*sql-readtable* (cl-postgres:copy-sql-readtable cl-postgres::*default-sql-readtable*))
Universal Time and Timestamp Libraries
Absent anything else, a query to postgresql through postmodern will return a universal time. E.g.
(query (:select (:current-timestamp)) :single)<PHONE_NUMBER>
To get a timestamp, you could use the local-time library or the simple-date library. Just for comparison sake, we will use both and get the universal time from both the system and from postgresql.
(local-time:universal-to-timestamp (query (:select (:current-timestamp)) :single)) @2018-08-20T19:23:34.000000-07:00 (local-time:universal-to-timestamp (get-universal-time)) @2018-08-20T19:23:42.000000-07:00 (simple-date:universal-time-to-timestamp (get-universal-time)) #<SIMPLE-DATE:TIMESTAMP 21-08-2018T02:26:00> (simple-date:universal-time-to-timestamp (query (:select (:current-timestamp)) :single)) #<SIMPLE-DATE:TIMESTAMP 21-08-2018T02:26:18>
Notice something interesting about the simple-date timestamp compared to the local-time timestamp? The local-time timestamp is (at least on the machine I am using as I write this and the postgresql server it is connected to) showing a Pacific Daylight time, 7 hours earlier than GMT. The simple-date timestamp is showing the GMT time. If you care about timezones, you will need to pay attention to where your server is, where the clients are and what do you want to be tracking or calculating to.
Intervals - Introduction and Use Cases
For a simple tutorial on the Postgresql interval data type, there are several online articles, see, e.g. the official documentation at https://www.postgresql.org/docs/current/static/datatype-datetime.html, https://www.postgresql.org/docs/current/static/functions-datetime.html http://www.postgresqltutorial.com/postgresql-interval/
Intervals are a way of adding, subtracting, etc a time period with a date.
Sample Interval
Just to see what an interval looks like returned from a query using s-sql. Note that the interval parameter is a string within a form provided to the :interval sql-op.
(query (:select (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second")) :single) ((:MONTHS 77) (:DAYS 4) (:SECONDS 10921) (:USECONDS 0))
Allowable Formats of the parameter to Interval
There are four different formats available for providing the interval parameter. Choose whichever one you like:
SQL Standard Format
(query (:select (:interval "1-2")) :single) ((:MONTHS 14) (:DAYS 0) (:SECONDS 0) (:USECONDS 0))
Traditional Postgresql Format
(query (:select (:interval "3 4:05:06")) :single) ((:MONTHS 0) (:DAYS 3) (:SECONDS 14706) (:USECONDS 0))
Formatting Intervals to String
You can use the :to-char sql-op with a format string to provide a single string version of the date/time. The ISO 8601 interval format allows
| Abbreviation | Description |
| Y | Year |
| M | MOnths |
| W | Weeks |
| D | Days |
| H | Hours |
| M | Minutes |
| S | Seconds |
where hours can be specified to 12 or 24.
(query (:select (:to-char (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second") "YYYY:MM:DD:HH24:MI:SS")) :single) "0006:05:04:03:02:01" (query (:select (:to-char (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second") "HH24:MI:SS")) :single) "03:02:01"
Just to be different, we can add weeks and days instead of years and months. E.g.
(query (:select (:to-char (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second") "WW:DD:HH24:MI:SS")) :single) "331:04:03:02:01"
Math with Intervals
Adding or subtracting intervals from each other will result in an interval.
(query (:select (:+ (:interval "2h 50min") (:interval "10min"))) :single) ((:MONTHS 0) (:DAYS 0) (:SECONDS 10800) (:USECONDS 0))
The difference between two timestamps is always an interval. Note: you cannot add, multiple or divide two timestamps.
(query (:select (:- (:timestamp "1999-12-30") (:timestamp "1999-12-11"))) :single) ((:MONTHS 0) (:DAYS 19) (:SECONDS 0) (:USECONDS 0))
The difference between two dates is an integer number of days, not an interval.
Adding or subtracting an interval from another date will provide a universal time which you can convert into a string using to-char E.g
(query (:select (:- (:now) (:interval ("6 years 5 months 4 days 3 hours 2 minutes 1 second")))) :single)<PHONE_NUMBER> (query (:select (:to-char (:+ (:date "2016-12-31") (:interval "25 hours")) "YYYY-MM-DD")) :single) "2017-01-01" (query (:select (:to-char (:- (:now) (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second")) "YYYY-MM-DD hh24:mm:ss")) :single) "2012-03-19 10:03:53"
They can be cast back to the alist interval style:
(query (:select (:type (:- (:timestamp "2016-12-31 03:00") (:timestamp "2016-12-29 13:00")) interval)) :single) ((:MONTHS 0) (:DAYS 1) (:SECONDS 50400) (:USECONDS
Or you can use local-time or simple-date to convert the result into some type of timestamp.
(local-time:universal-to-timestamp (query (:select (:- (:now) (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second"))) :single)) @2012-03-16T17:35:32.000000-07:00 (simple-date:universal-time-to-timestamp (query (:select (:- (:now) (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second"))) :single)) #<SIMPLE-DATE:TIMESTAMP 17-03-2012T00:36:14>
You can also do the more expected sums and groupings using intervals. In the following example, we sum the total employment days by city of the employees with more than 1 year of service.
(query (:select 'city (:as (:sum (:- (:timestamp "2018-04-10") 'start-date)) 'total-days) :from 'employee :group-by 'city :having (:> (:sum (:- (:timestamp "2018-04-10") 'start-date)) (:interval "1 year")))) (("Vancouver" ((:MONTHS 0) (:DAYS 21746) (:SECONDS 0) (:USECONDS 0))) ("New York" ((:MONTHS 0) (:DAYS 22751) (:SECONDS 0) (:USECONDS 0))) ("Toronto" ((:MONTHS 0) (:DAYS 20374) (:SECONDS 0) (:USECONDS 0))))
Extracting Subparts
You can extract a part of an interval using :extract.
(query (:select (:extract "minute" (:interval "5 hours 21 minutes"))) :single) 21.0d0 (query (:select (:extract "hour" (:interval "35 hours 21 minutes"))) :single) 35.0d0 (query (:select (:extract "day" (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second"))) :single) 4.0d0 (query (:select (:extract "year" (:interval "6 years 5 months 4 days 3 hours 2 minutes 1 second"))) :single) 6.0d0 (query (:select (:extract "year" (:interval "6 years 15 months 4 days 3 hours 2 minutes 1 second"))) :single) 7.0d0 (query (:select (:extract "month" (:interval "6 years 15 months 4 days 3 hours 2 minutes 1 second"))) :single) 3.0d0
Justify Days and Hours
You can adjust a period of days to be 30 day months and adjust a period of hours to be 24 hour days. For example:
(query (:select (:interval "47 days 3 hours 2 minutes 1 second")) :single) ((:MONTHS 0) (:DAYS 47) (:SECONDS 10921) (:USECONDS 0)) (query (:select (:justify-days (:interval "47 days 3 hours 2 minutes 1 second"))) :single) ((:MONTHS 1) (:DAYS 17) (:SECONDS 10921) (:USECONDS 0))


|
Quick Links: |
Provide a mock session, implementing bmqa::AbstractSession
.
More...
Namespaces | |
| namespace | bmqimp |
| namespace | bmqa |
bmqa::AbstractSession
. | bmqa::MockSession | mechanism to mock a bmqa::Session |
| bmqa::MockSessionUtil | utility methods to create bmqa events |
bmqa::AbstractSession
protocol, for mocking a bmqa::Session
and can be used to write a test for an application that uses BMQ. The bmqa::MockSession
provides all the methods that Session
provides, with added methods to specify return codes and emitted events and expected calls. This can be used to test BlazingMQ application code without a connection to the broker. bmqa::MockSessionUtil
is a utility namespace providing useful methods to build bmqa::Event
objects that are typically only emitted from the broker. bmqa::MockSession
object. This macro is used to specify which is the next expected call on the bmqa::MockSession
. If an incorrect call is invoked or incorrect parameters are used, an assert will be invoked. bmqa::MockSession
is invoked. emitted
when the expected call is invoked. The events specified are enqueued to the internal event queue and are delivered to the application when emitEvent
is invoked. BMQA_EXPECT_CALL
macro in the emitting
parameter, or enqueued to the bmqa::MockSession
directly through the enqueueEvent
method. They can then be emitted by invoking the emitEvent
method, which in turn would be processed through the application-provided bmqa::SessionEventHandler
. MockSession
does not check if methods have been invoked in the correct order. The user is responsible for ensuring that the methods are invoked and events enqueued in the correct order. getQueueId
loadMessageEventBuilder
loadConfirmEventBuilder
loadMessageProperties
confirmMessage
confirmMessages
getQueueId
loadMessageEventBuilder
loadConfirmEventBuilder
loadMessageProperties
MockSession
is created in asynchronous mode when a SessionEventHandler
is provided to it. If it is not provided a handler, the MockSession
is started in synchronous mode, requiring the application to call nextEvent
to access enqueued events. A sample handler could look like this: class MyEventHandler : public bmqa::SessionEventHandler { private: // DATA bsl::deque<bmqa::SessionEvent> d_sessionEventsQueue; bsl::deque<bmqa::MessageEvents> d_messageEventsQueue; bsl::deque<bmqa::OpenQueueStatus> d_openQueueResultsQueue; ... public: // MANIPULATORS virtual void onSessionEvent(const bmqa::SessionEvent& event) { bsl::cout << "Received session event " << event << "\n"; // some business logic, typically a switch case on // 'bmqt::SessionEventType' d_sessionEventsQueue.push_back(event); } virtual void onMessageEvent(const bmqa::MessageEvent& event) { bsl::cout << "Received message event " << event << "\n"; // some business logic, typically a switch case on // 'bmqt::MessageEventType' d_messageEventsQueue.push_back(event); } void onOpenQueueStatus(const bmqa::OpenQueueStatus& result) { bsl::cout << "Received open queue result: " << result << "\n"; // Some business logic d_openQueueResultsQueue.push_back(result); } ... bmqa::SessionEvent popSessionEvent() { BSLS_ASSERT(d_sessionEventsQueue.size() > 0); bmqa::SessionEvent ret(d_receivedSessionEvents.front()); d_receivedSessionEvents.pop_front(); return ret; } bmqa::MessageEvent popMessageEvent() { BSLS_ASSERT(d_messageEventsSize.size() > 0); bmqa::MessageEvent ret(d_receivedMessageEvents.front()); d_receivedMessageEvents.erase(d_receivedMessageEvents.begin()); return ret; } bmqa::OpenQueueStatus popOpenQueueStatus() { BSLS_ASSERT(d_openQueueResultsQueue.size() > 0); bmqa::OpenQueueStatus ret(d_openQueueResultsQueue.front()); d_openQueueResultsQueue.erase(d_openQueueResultsQueue.begin()); return ret; } ... };
emitting
on the BMQA_EXPECT_CALL
macro and enqueueEvent
interchangeably, but in practice it is important to note that events from the broker are generated asynchronously, which means that they are not emitted as you call the method. You can control emission of events, however, by delaying the call to emitEvent
. bmqa::Session
, calling nextEvent
is meaningless in asynchronous mode. void unitTest() { // Create an event handler EventHandler eventHandler(d_allocator_p); // The following static initializer method calls all the appropriate // static initializers of the underlying components needed for the // 'MockSession'. The constructor of 'MockSession' will call it in // any case but if events need to be built outside the scope of the // creation of 'MockSession' you will need to explicitly invoke this // static initializer method. // bmqa::MockSession::initialize(s_allocator_p); bslma::ManagedPtr<bmqa::SessionEventHandler> handlerMp; handlerMp.load(&eventHandler, 0, bslma::ManagedPtrUtil::noOpDeleter); bmqa::MockSession mockSession(handlerMp, bmqt::SessionOptions(d_allocator_p), d_allocator_p); bmqa::QueueId queueId(bmqt::CorrelationId(1), d_allocator_p); bmqt::CorrelationId corrId(1); // Expect a call to start and the call emits an 'e_CONNECTED' event. BMQA_EXPECT_CALL(mockSession, startAsync()) .returning(0) .emitting(bmqa::MockSessionUtil::createSessionEvent( bmqt::SessionEventType::e_CONNECTED, 0, // statusCode "", // errorDescription d_allocator_p)); // Make a call to startAsync and emit the event that is enqueued from // that call. ASSERT_EQ(mockSession.startAsync(), 0); // Emit our enqueued event. This fully sets up the session which is // now ready to use. Typically you would have some business logic on // 'e_CONNECTED' that makes your application ready to use. ASSERT_EQ(mockSession.emitEvent(), true); // Our event handler internally just stores the event emitted, so pop // it out and examine. bmqa::SessionEvent startEvent(eventHandler.popSessionEvent()); ASSERT_EQ(startEvent.type(), bmqt::SessionEventType::e_CONNECTED); ASSERT_EQ(startEvent.statusCode(), 0); // Create the uri to your queue as you would in your application. const bmqt::Uri uri("bmq://my.domain/queue"); // Initialize the queue flags for a producer with acks enabled bsls::Types::Uint64 flags = 0; bmqt::QueueFlagsUtil::setWriter(&flags); bmqt::QueueFlagsUtil::setAck(&flags); // We use the macro to expect a call to 'openQueueAsync', binding the // 'uri' and 'queueId' objects as well as the 'flags' that we created. bmqa::MockSession::OpenQueueCallback openQueueCallback = bdlf::BindUtil::bind(&EventHandler::onOpenQueueStatus, &eventHandler, bdlf::PlaceHolders::_1); // result BMQA_EXPECT_CALL(mockSession, openQueueAsync(uri1, flags, openQueueCallback)); BMQA_EXPECT_CALL(mockSession, openQueueAsync(uri, flags, openQueueCallback)); // Now that we have set our expectations we can try to open the queue. mockSession.openQueueAsync(uri1, flags, openQueueCallback); // Since the application may not have direct access to the queue, we // need to get the 'queueId' from the session. We can then bind this // retrieved 'queueId' to the 'e_QUEUE_OPEN_RESULT' session event and // enqueue it to the 'MockSession'. // Note: You can only get the 'queueId' after 'openQueue' or // 'openQueueAsync' has been invoked on the session. bmqa::QueueId queueId1(corrId1); bmqa::OpenQueueStatus openQueueResult = bmqa::MockSessionUtil::createOpenQueueStatus( queueId1, bmqt::OpenQueueResult::e_TIMEOUT, // statusCode "Local Timeout", // errorDescription d_allocator_p); mockSession.enqueueEvent(openQueueResult); // We just enqueued a 'bmqa::OpenQueueStatus' to be emitted. We can // emit it using 'emitEvent'. ASSERT_EQ(mockSession.emitEvent(), true); // Pop out this event from the handler and examine it. bmqa::OpenQueueStatus result = eventHandler.popOpenQueueStatus(); ASSERT_EQ(result, openQueueResult); // On emission of 'bmqa::OpenQueueStatus', the queue is fully open and // we can now post to it. bmqa::MessageEventBuilder builder; mockSession.loadMessageEventBuilder(&builder); BMQA_EXPECT_CALL(mockSession, post(builder.messageEvent())) .returning(0); // Use the builder to build a mesage event and pack it for the queue // that has been opened. If you try to pack the message for an // invalid or closed queue, packing the message will fail. This has // been elided for brevity. // Now that the event has been built we can 'post' it to BMQ. ASSERT_EQ(mockSession.post(builder.messageEvent()), 0); // Simply creating a blob buffer factory on the stack to be used by // 'createAckEvent'. Typically you would have one for the component. bdlbb::PooledBlobBufferFactory bufferFactory(4 * 1024, d_allocator_p); // The method 'createAckEvent' takes a vector of 'AckParams' to // specify multiple acks per event, but here we are only acknowledging // 1 message. Specify a positive ack with 'e_SUCCESS' here but you // can specify any from 'bmqt::AckResult::Enum'. bsl::vector<bmqa::MockSessionUtil::AckParams> acks(d_allocator_p); acks.emplace_back(bmqt::AckResult::e_SUCCESS, bmqt::CorrelationId(1), bmqt::MessageGUID(), // Real GUID needed if you want // to record ack messages. bmqa::QueueId(1)); // Enqueuing ack event to be emitted. We use the helper function // 'createAckEvent' to generate this event. mockSession.enqueueEvent(bmqa::MockSessionUtil::createAckEvent( acks, &bufferFactory, d_allocator_p)); // Emit the enqueued ack event. ASSERT_EQ(mockSession.emitEvent(), true); // As we did earlier, pop it out and examine. bmqa::MessageEvent ackEvent(eventHandler.popMessageEvent()); ASSERT_EQ(ackEvent.type(), bmqt::MessageEventType::e_ACK); bmqa::MessageIterator mIter = ackEvent.messageIterator(); mIter.nextMessage(); ASSERT_EQ(mIter.message().ackStatus(), bmqt::AckResult::e_SUCCESS); // This is a simple test. After posting our message and receiving the // ack, we are now shutting down our application. Therefore we expect // a 'stopAsync' call. BMQA_EXPECT_CALL(mockSession, stopAsync()); // Now make a call to 'stopAsync' to stop our session. mockSession.stopAsync(); // Here we are enqueuing an 'e_DISCONNECTED' event as you would // receive from the broker on a successful shutdown. mockSession.enqueueEvent(bmqa::MockSessionUtil::createSessionEvent( bmqt::SessionEventType::e_DISCONNECTED, 0, // statusCode "", // errorDescription d_allocator_p)); ASSERT_EQ(mockSession.emitEvent(), true); // Our event handler internally just stores the event emitted, so pop // it out and examine. bmqa::SessionEvent stopEvent(eventHandler.popSessionEvent()); ASSERT_EQ(stopEvent.type(), bmqt::SessionEventType::e_DISCONNECTED); ASSERT_EQ(stopEvent.statusCode(), 0); // The corresponding pendant operation of the 'initialize' which would // need to be called only if 'initialize' was explicitly called. // bmqa::MockSession::shutdown(); }
enqueue
or emitEvent
on bmqa::MockSession
or emitting
on the BMQA_EXPECT_CALL
macro in synchronous mode is meaningless. void unitTest() { // MockSession created without an eventHandler. bmqa::MockSession mockSession(bmqt::SessionOptions(d_allocator_p), d_allocator_p); // The following static initializer method calls all the appropriate // static initializers of the underlying components needed for the // 'MockSession'. The constructor of 'MockSession' will call it in // any case but if events need to be built outside the scope of the // creation of 'MockSession' you will need to explicitly invoke this // static initializer method. // bmqa::MockSession::initialize(s_allocator_p); // Create simple queueIds and corrIds bmqa::QueueId queueId(1); bmqt::CorrelationId corrId(1); // Create the uri to your queue as you would in your application. bmqt::Uri uri("bmq://my.domain/queue"); // Expecting that 'startAsync' will be called on the MockSession. BMQA_EXPECT_CALL(mockSession, startAsync()) .returning(0); // Simply creating a blob buffer factory on the stack to be used by // 'createAckEvent'. Typically you would have one for the component. bdlbb::PooledBlobBufferFactory bufferFactory(4 * 1024, d_allocator_p); // We then expect that 'nextEvent' will be called to return the // 'e_CONNECTED' event from the broker BMQA_EXPECT_CALL(mockSession, nextEvent(bsls::TimeInterval())) .returning(bmqa::MockSessionUtil::createSessionEvent( bmqt::SessionEventType::e_CONNECTED, bmqt::CorrelationId::autoValue(), 0, // errorCode "", // errorDescription d_allocator_p)); // Note that we use an 'autoValue' for correlationId because it's // irrelevant for a 'CONNECTED' event. // Initialize the queue flags for a consumer bsls::Types::Uint64 flags = 0; bmqt::QueueFlagsUtil::setReader(&flags); // We use the macro to expect a call to 'openQueueSync', binding the // 'uri' and 'queueId' objects as well as the flags that we created. // Note that the 'queueId' object will be modified as 'openQueueSync' // takes it as an output parameter. bmqa::OpenQueueStatus expectedResult = bmqa::MockSessionUtil::createOpenQueueStatus( queueId, bmqt::OpenQueueResult::e_SUCCESS, // statusCode "", // errorDescription d_allocator_p); BMQA_EXPECT_CALL(mockSession, openQueueSync(&queueId, uri, flags)) .returning(expectedResult); // Build our incoming message event. bsl::vector<bmqa::MockSessionUtil::PushMessageParams> pushMsgs( d_allocator_p); bdlbb::Blob payload(&bufferFactory, d_allocator_p); bdlbb::BlobUtil::append(&payload, "hello", 6); const char guidHex[] = "00000000000000000000000000000001"; bmqt::MessageGUID guid; guid.fromHex(guidHex); bmqa::MessageProperties properties; mockSession.loadMessageProperties(&properties); // For each message that we are supposed to receive from the broker, // we need to specify the payload, the queueId, a guid (the hex is // random but unique within your test driver) and properties which // could be empty. pushMsgs.emplace_back(payload, queueId, guid, properties); bmqa::Event pushMsgEvent = bmqa::MockSessionUtil::createPushEvent( pushMsgs, &bufferFactory, d_allocator_p); BMQA_EXPECT_CALL(mockSession, nextEvent(bsls::TimeInterval())) .returning(pushMsgEvent); // Next we expect a call to 'confirmMessages', to confirm the 1 message // that we received from the broker. bmqa::ConfirmEventBuilder confirmBuilder; mockSession.loadConfirmEventBuilder(&confirmBuilder); BMQA_EXPECT_CALL(mockSession, confirmMessages(&confirmBuilder)) .returning(0); // Expectations have been set up. Now we run the code. // 'startAsync' is the first call. We expect it to return 0 and we // expect 'nextEvent' to return the 'e_CONNECTED' session event. int rc = mockSession.startAsync(); ASSERT_EQ(rc, 0); bmqa::SessionEvent startEvent = mockSession.nextEvent( bsls::TimeInterval()) .sessionEvent(); ASSERT_EQ(startEvent.type(), bmqt::SessionEventType::e_CONNECTED); ASSERT_EQ(startEvent.statusCode(), 0); ASSERT_EQ(startEvent.errorDescription(), ""); // Next we expect a call to 'openQueue' to open the queue. bmqa::OpenQueueStatus result = mockSession.openQueueSync(&queueId, uri, 10); ASSERT_EQ(result, expectedResult); // Now our call to 'nextEvent' will generate a push message from the // broker, which we will then go on to confirm. bmqa::MessageEvent pushMsgEvt(mockSession.nextEvent( bsls::TimeInterval()) .messageEvent()); ASSERT_EQ(pushMsgEvt.type(), bmqt::MessageEventType::e_PUSH); // Now that we have received a push message which has yet to be // confirmed, we can confirm that 1 unconfirmed message exists. ASSERT_EQ(mockSession.unconfirmedMessages(), 1U); // Since there is only 1 message in our message event, we dont have to // iterate over the event but in reality you will want to iterate over // each message and add it to the confirm builder. bmqa::MessageIterator mIter = pushMsgEvt.messageIterator(); mIter.nextMessage(); confirmBuilder.addMessageConfirmation(mIter.message()); ASSERT_EQ(confirmBuilder.messageCount(), 1); // Confirm the messages using the builder that has been populated. rc = mockSession.confirmMessages(&confirmBuilder); ASSERT_EQ(rc, 0); // Voila! We now have no unconfirmed messages. ASSERT_EQ(mockSession.unconfirmedMessages(), 0u); // 'stop' has been elided for brevity and is analogous to 'start' // The corresponding pendant operation of the 'initialize' which would // need to be called only if 'initialize' was explicitly called. // bmqa::MockSession::shutdown(); }


Founded in November of 2000 as the Student Endowment Investment Group, Pioneer Capital Investments (PCI) strives to educate students about financial markets. PCI was established through a $100,000 grant by the college’s endowment and has been student run since its inception. Continuously operating for almost two decades, the group has taught generations of Grinnell students investing skills.
PCI consists of a diverse collection of students. Members include students of all graduating classes and many majors, both domestic and international students, and students of varying levels of expertise in the financial markets. With this distinct blend of students, the group is able to analyze multiple viewpoints before making a decision regarding the portfolio.
The key purpose of PCI is to educate students. We also bring in guest speakers such as professors, alumni, and other people from around the community who have experience in finance, accounting, investment management and mathematics.
For general questions we invite you to send us an email.
E<EMAIL_ADDRESS>website changes, please open a pull request if able. Otherwise, send an email.
GitHub: PCI-WebsiteAccessing the portfolio, which displays all current holdings and their gross returns, requires logging into the PCI Grinnell Yahoo account login.
Reading financial books, papers, and news is the best way to become familiar with investment terminology and opportunities.
Pioneer Capital Investments operates under the supervision of the Grinnell College Office of Investments.
Books
News & Blogs
More


Why Data? - align, common purpose - feedback
Where does data come from? You! contribute data.
How can I use it?


I have been enjoying doing web development using Python with Django and Flask, Ruby on Rails and React.js with Node.js
I also did some mobile development (Swift and exploring React Native). Besides that I find building test frameworks really entertaining.
Web application helping small hotel and B&B owners to manager their properties. Functionality includes availability management, rooms and rates setup, reservations, check-ins and check-outs etc.
My little experiment with iOS development and Swift: an app which uses machine learning module to recognize what is on the photo.
Little clone of Twitter functionality as a project to explore React and Redux


IDL source Global indexinterface ICapeNumericPartitioning : ICapeNumericAnalysis
Performs a Partitioning and Ordering Analysis on a Flowsheet.
Creates and complete an ICapeNumericPartitionGraph interface from a specified partition. The return value is
in accordance with the last calculation of partitioning analysis.
The intermediate streams between partitions become either FEED or PRODUCT streams of the built Partition Graph.
This generated ICapeNumericPartitionGraph is created from the flowsheet factory and is called name.
partitionNb belongs to the interval [1..partition count].
Pre Conditions: A ICapeNumericFlowsheetFactory exists.
Use ICapeNumericPartitioning::GetPartitionCount() method in order to have the number of partitions.
The Perform() method is terminated successfully.
Post Conditions: The generated ICapeNumericPartitionGraph can be used directly as a flowsheet into
the tearing analysis.
Assures to generate a consistent flowsheet for the computation of a tearing analysis.
Sets the external system.
Pre Conditions: Returns the value set by the SetExternalSystemId() method, otherwise the returned value is an implementation dependent default value.
Post Conditions: None.
Gets the number of partitions resulting from the last successful computation (with the ICapeNumericAnalysis::Perform() method).
Pre Conditions: None.
Post Conditions: None.
Gets the list of units for a specified partition resulting from the last successful computation (with the ICapeNumericAnalysis::Perform() method).
partitionNb belongs to the interval [1..partition count].
The order of partitions corresponds to the partition computation list (ordering) e.g.
where partitionNb=1, it indicates the first partition to be computed, where partitionNb=2, it designates the second partition to be computed, and so on ...
The order of units is implementation dependent.
Pre Conditions: Uses ICapeNumericPartitioning::GetPartitionCount method in order to have the number of partitions.
Post Conditions: None.
Sets the external system.
Pre Conditions: None.
Post Conditions: The unitId value will be used by CreateAndCompletePartitionGraph() method in order to characterise the FEED and PRODUCT streams.
ICapeNumericPartitionGraph CreateAndCompletePartitionGraph(in CapeLong partitionNb, in CapeString name, in ICapeNumericFlowsheetFactory factory) raises(CapeBAD_INV_ORDER, CapeBAD_PARAM, CapeIMP_LIMIT, CapeNO_IMPLEMENT, CapeNO_CONVERGE, CapeUNKNOWN);
Creates and complete an ICapeNumericPartitionGraph interface from a specified partition. The return value is
in accordance with the last calculation of partitioning analysis.
The intermediate streams between partitions become either FEED or PRODUCT streams of the built Partition Graph.
This generated ICapeNumericPartitionGraph is created from the flowsheet factory and is called name.
partitionNb belongs to the interval [1..partition count].
Pre Conditions: A ICapeNumericFlowsheetFactory exists.
Use ICapeNumericPartitioning::GetPartitionCount() method in order to have the number of partitions.
The Perform() method is terminated successfully.
Post Conditions: The generated ICapeNumericPartitionGraph can be used directly as a flowsheet into
the tearing analysis.
Assures to generate a consistent flowsheet for the computation of a tearing analysis.
CapeLong GetExternalSystemId() raises(CapeUNKNOWN);
Sets the external system.
Pre Conditions: Returns the value set by the SetExternalSystemId() method, otherwise the returned value is an implementation dependent default value.
Post Conditions: None.
CapeLong GetPartitionCount() raises(CapeBAD_INV_ORDER, CapeUNKNOWN);
Gets the number of partitions resulting from the last successful computation (with the ICapeNumericAnalysis::Perform() method).
Pre Conditions: None.
Post Conditions: None.
CapeLongSequence GetUnitsInPartition(in CapeLong partitionNb) raises(CapeBAD_INV_ORDER, CapeBAD_PARAM, CapeUNKNOWN);
Gets the list of units for a specified partition resulting from the last successful computation (with the ICapeNumericAnalysis::Perform() method).
partitionNb belongs to the interval [1..partition count].
The order of partitions corresponds to the partition computation list (ordering) e.g.
where partitionNb=1, it indicates the first partition to be computed, where partitionNb=2, it designates the second partition to be computed, and so on ...
The order of units is implementation dependent.
Pre Conditions: Uses ICapeNumericPartitioning::GetPartitionCount method in order to have the number of partitions.
Post Conditions: None.
void SetExternalSystemId(in CapeLong unitId) raises(CapeBAD_PARAM, CapeUNKNOWN);
Sets the external system.
Pre Conditions: None.
Post Conditions: The unitId value will be used by CreateAndCompletePartitionGraph() method in order to characterise the FEED and PRODUCT streams.


|
ActiveTcl User Guide
|
||
set - Read and write variables
set varName ?value?
Returns the value of variable varName. If value is specified, then set the value of varName to value, creating a new variable if one doesn't already exist, and return its value. If varName contains an open parenthesis and ends with a close parenthesis, then it refers to an array element: the characters before the first open parenthesis are the name of the array, and the characters between the parentheses are the index within the array. Otherwise varName refers to a scalar variable. Normally, varName is unqualified (does not include the names of any containing namespaces), and the variable of that name in the current namespace is read or written. If varName includes namespace qualifiers (in the array name if it refers to an array element), the variable in the specified namespace is read or written.
If no procedure is active, then varName refers to a namespace variable (global variable if the current namespace is the global namespace). If a procedure is active, then varName refers to a parameter or local variable of the procedure unless the global command was invoked to declare varName to be global, or unless a variable command was invoked to declare varName to be a namespace variable.
Copyright © 1993 The Regents of the University of California. Copyright © 1994-1996 Sun Microsystems, Inc. Copyright © 1995-1997 Roger E. Critchlow Jr.