Contents
Setting font properties will be among the most common uses of style sheets. Unfortunately, there exists no well-defined and universally accepted taxonomy for classifying fonts, and terms that apply to one font family may not be appropriate for others. E.g., 'italic' is commonly used to label slanted text, but slanted text may also be labeled as being Oblique, Slanted, Incline, Cursive or Kursiv. Therefore it is not a simple problem to map typical font selection properties to a specific font.
Because there is no accepted, universal taxonomy of font properties, matching of properties to font faces must be done carefully. The properties are matched in a well-defined order to insure that the results of this matching process are as consistent as possible across UAs (assuming that the same library of font faces is presented to each of them).
(The above algorithm can be optimized to avoid having to revisit the CSS 2.1 properties for each character.)
The per-property matching rules from (2) above are as follows:
| Value: | [[ <family-name> | <generic-family> ] [, <family-name>| <generic-family>]* ] | inherit |
| Initial: | depends on user agent |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | N/A |
| Media: | visual |
| Computed value: | as specified |
The property value is a prioritized list of font family names and/or generic family names. Unlike most other CSS properties, component values are separated by a comma to indicate that they are alternatives:
body { font-family: Gill, Helvetica, sans-serif }
Although many fonts provide the "missing character" glyph, typically an open box, as its name implies this should not be considered a match for characters that cannot be found in the font. (It should, however, be considered a match for U+FFFD, the "missing character" character's code point).
There are two types of font family names:
Style sheet designers are encouraged to offer a generic font family as a last alternative. Generic font family names are keywords and must NOT be quoted.
Font family names must either be given quoted as strings, or unquoted as a sequence of one or more identifiers. This means most punctuation characters and digits at the start of each token must be escaped in unquoted font family names.
For example, the following declarations are invalid:
font-family: Red/Black, sans-serif; font-family: "Lucida" Grande, sans-serif; font-family: Ahem!, sans-serif; font-family: test@foo, sans-serif; font-family: #POUND, sans-serif; font-family: Hawaii 5-0, sans-serif;
If a sequence of identifiers is given as a font family name, the computed value is the name converted to a string by joining all the identifiers in the sequence by single spaces.
To avoid mistakes in escaping, it is recommended to quote font family names that contain white space, digits, or punctuation characters other than hyphens:
body { font-family: "New Century Schoolbook", serif } <BODY STYLE="font-family: '21st Century', fantasy">
Font family names that happen to be the same as a keyword value ('inherit', 'serif', 'sans-serif', 'monospace', 'fantasy', and 'cursive') must be quoted to prevent confusion with the keywords with the same names. The keywords 'initial' and 'default' are reserved for future use and must also be quoted when used as font names. UAs must not consider these keywords as matching the '<family-name>' type.
Generic font families are a fallback mechanism, a means of preserving some of the style sheet author's intent in the worst case when none of the specified fonts can be selected. For optimum typographic control, particular named fonts should be used in style sheets.
All five generic font families are defined to exist in all CSS implementations (they need not necessarily map to five distinct actual fonts). User agents should provide reasonable default choices for the generic font families, which express the characteristics of each family as well as possible within the limits allowed by the underlying technology.
User agents are encouraged to allow users to select alternative choices for the generic fonts.
Glyphs of serif fonts, as the term is used in CSS, tend to have finishing strokes, flared or tapering ends, or have actual serifed endings (including slab serifs). Serif fonts are typically proportionately-spaced. They often display a greater variation between thick and thin strokes than fonts from the 'sans-serif' generic font family. CSS uses the term 'serif' to apply to a font for any script, although other names may be more familiar for particular scripts, such as Mincho (Japanese), Sung or Song (Chinese), Totum or Kodig (Korean). Any font that is so described may be used to represent the generic 'serif' family.
Examples of fonts that fit this description include:
| Latin fonts | Times New Roman, Bodoni, Garamond, Minion Web, ITC Stone Serif, MS Georgia, Bitstream Cyberbit |
| Greek fonts | Bitstream Cyberbit |
| Cyrillic fonts | Adobe Minion Cyrillic, Excelsior Cyrillic Upright, Monotype Albion 70, Bitstream Cyberbit, ER Bukinist |
| Hebrew fonts | New Peninim, Raanana, Bitstream Cyberbit |
| Japanese fonts | Ryumin Light-KL, Kyokasho ICA, Futo Min A101 |
| Arabic fonts | Bitstream Cyberbit |
| Cherokee fonts | Lo Cicero Cherokee |
Glyphs in sans-serif fonts, as the term is used in CSS, tend to have stroke endings that are plain -- with little or no flaring, cross stroke, or other ornamentation. Sans-serif fonts are typically proportionately-spaced. They often have little variation between thick and thin strokes, compared to fonts from the 'serif' family. CSS uses the term 'sans-serif' to apply to a font for any script, although other names may be more familiar for particular scripts, such as Gothic (Japanese), Kai (Chinese), or Pathang (Korean). Any font that is so described may be used to represent the generic 'sans-serif' family.
Examples of fonts that fit this description include:
| Latin fonts | MS Trebuchet, ITC Avant Garde Gothic, MS Arial, MS Verdana, Univers, Futura, ITC Stone Sans, Gill Sans, Akzidenz Grotesk, Helvetica |
| Greek fonts | Attika, Typiko New Era, MS Tahoma, Monotype Gill Sans 571, Helvetica Greek |
| Cyrillic fonts | Helvetica Cyrillic, ER Univers, Lucida Sans Unicode, Bastion |
| Hebrew fonts | Arial Hebrew, MS Tahoma |
| Japanese fonts | Shin Go, Heisei Kaku Gothic W5 |
| Arabic fonts | MS Tahoma |
Glyphs in cursive fonts, as the term is used in CSS, generally have either joining strokes or other cursive characteristics beyond those of italic typefaces. The glyphs are partially or completely connected, and the result looks more like handwritten pen or brush writing than printed letterwork. Fonts for some scripts, such as Arabic, are almost always cursive. CSS uses the term 'cursive' to apply to a font for any script, although other names such as Chancery, Brush, Swing and Script are also used in font names.
Examples of fonts that fit this description include:
| Latin fonts | Caflisch Script, Adobe Poetica, Sanvito, Ex Ponto, Snell Roundhand, Zapf-Chancery |
| Cyrillic fonts | ER Architekt |
| Hebrew fonts | Corsiva |
| Arabic fonts | DecoType Naskh, Monotype Urdu 507 |
Fantasy fonts, as used in CSS, are primarily decorative while still containing representations of characters (as opposed to Pi or Picture fonts, which do not represent characters). Examples include:
| Latin fonts | Alpha Geometrique, Critter, Cottonwood, FB Reactor, Studz |
The sole criterion of a monospace font is that all glyphs have the same fixed width. (This can make some scripts, such as Arabic, look most peculiar.) The effect is similar to a manual typewriter, and is often used to set samples of computer code.
Examples of fonts which fit this description include:
| Latin fonts | Courier, MS Courier New, Prestige, Everson Mono |
| Greek Fonts | MS Courier New, Everson Mono |
| Cyrillic fonts | ER Kurier, Everson Mono |
| Japanese fonts | Osaka Monospaced |
| Cherokee fonts | Everson Mono |
| Value: | normal | italic | oblique | inherit |
| Initial: | normal |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | N/A |
| Media: | visual |
| Computed value: | as specified |
The 'font-style' property selects between normal (sometimes referred to as "roman" or "upright"), italic and oblique faces within a font family.
A value of 'normal' selects a font that is classified as 'normal' in the UA's font database, while 'oblique' selects a font that is labeled 'oblique'. A value of 'italic' selects a font that is labeled 'italic', or, if that is not available, one labeled 'oblique'.
The font that is labeled 'oblique' in the UA's font database may actually have been generated by electronically slanting a normal font.
Fonts with Oblique, Slanted or Incline in their names will typically be labeled 'oblique' in the UA's font database. Fonts with Italic, Cursive or Kursiv in their names will typically be labeled 'italic'.
h1, h2, h3 { font-style: italic } h1 em { font-style: normal }
In the example above, emphasized text within 'H1' will appear in a normal face.
| Value: | normal | small-caps | inherit |
| Initial: | normal |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | N/A |
| Media: | visual |
| Computed value: | as specified |
Another type of variation within a font family is the small-caps. In a small-caps font the lower case letters look similar to the uppercase ones, but in a smaller size and with slightly different proportions. The 'font-variant' property selects that font.
A value of 'normal' selects a font that is not a small-caps font, 'small-caps' selects a small-caps font. It is acceptable (but not required) in CSS 2.1 if the small-caps font is a created by taking a normal font and replacing the lower case letters by scaled uppercase characters. As a last resort, uppercase letters will be used as replacement for a small-caps font.
The following example results in an 'H3' element in small-caps, with any emphasized words in oblique, and any emphasized words within an 'H3' oblique small-caps:
h3 { font-variant: small-caps } em { font-style: oblique }
There may be other variants in the font family as well, such as fonts with old-style numerals, small-caps numerals, condensed or expanded letters, etc. CSS 2.1 has no properties that select those.
Note: insofar as this property causes text to be transformed to uppercase, the same considerations as for 'text-transform' apply.
| Value: | normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit |
| Initial: | normal |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | N/A |
| Media: | visual |
| Computed value: | see text |
The 'font-weight' property selects the weight of the font. The values '100' to '900' form an ordered sequence, where each number indicates a weight that is at least as dark as its predecessor. The keyword 'normal' is synonymous with '400', and 'bold' is synonymous with '700'. Keywords other than 'normal' and 'bold' have been shown to be often confused with font names and a numerical scale was therefore chosen for the 9-value list.
p { font-weight: normal } /* 400 */ h1 { font-weight: 700 } /* bold */
The 'bolder' and 'lighter' values select font weights that are relative to the weight inherited from the parent:
strong { font-weight: bolder }
Fonts (the font data) typically have one or more properties whose values are names that are descriptive of the "weight" of a font. There is no accepted, universal meaning to these weight names. Their primary role is to distinguish faces of differing darkness within a single font family. Usage across font families is quite variant; for example, a font that one might think of as being bold might be described as being Regular, Roman, Book, Medium, Semi- or DemiBold, Bold, or Black, depending on how black the "normal" face of the font is within the design. Because there is no standard usage of names, the weight property values in CSS 2.1 are given on a numerical scale in which the value '400' (or 'normal') corresponds to the "normal" text face for that family. The weight name associated with that face will typically be Book, Regular, Roman, Normal or sometimes Medium.
The association of other weights within a family to the numerical weight values is intended only to preserve the ordering of darkness within that family. However, the following heuristics tell how the assignment is done in this case:
Once the font family's weights are mapped onto the CSS scale, missing weights are selected as follows:
The following two examples show typical mappings.
Assume four weights in the "Rattlesnake" family, from lightest to darkest: Regular, Medium, Bold, Heavy.
| Available faces | Assignments | Filling the holes |
|---|---|---|
| "Rattlesnake Regular" | 400 | 100, 200, 300 |
| "Rattlesnake Medium" | 500 | |
| "Rattlesnake Bold" | 700 | 600 |
| "Rattlesnake Heavy" | 800 | 900 |
Assume six weights in the "Ice Prawn" family: Book, Medium, Bold, Heavy, Black, ExtraBlack. Note that in this instance the user agent has decided not to assign a numeric value to "Ice Prawn ExtraBlack".
| Available faces | Assignments | Filling the holes |
|---|---|---|
| "Ice Prawn Book" | 400 | 100, 200, 300 |
| "Ice Prawn Medium" | 500 | |
| "Ice Prawn Bold" | 700 | 600 |
| "Ice Prawn Heavy" | 800 | |
| "Ice Prawn Black" | 900 | |
| "Ice Prawn ExtraBlack" | (none) |
Values of 'bolder' and 'lighter' indicate values relative to the weight of the parent element. Based on the inherited weight value, the weight used is calculated using the chart below. Child elements inherit the calculated weight, not a value of 'bolder' or 'lighter'.
| Inherited value | bolder | lighter |
|---|---|---|
| 100 | 400 | 100 |
| 200 | 400 | 100 |
| 300 | 400 | 100 |
| 400 | 700 | 100 |
| 500 | 700 | 100 |
| 600 | 900 | 400 |
| 700 | 900 | 400 |
| 800 | 900 | 700 |
| 900 | 900 | 700 |
The table above is equivalent to selecting the next relative bolder or lighter face, given a font family containing normal and bold faces along with a thin and a heavy face. Authors who desire finer control over the exact weight values used for a given element should use numerical values instead of relative weights.
There is no guarantee that there will be a darker face for each of the 'font-weight' values; for example, some fonts may have only a normal and a bold face, while others may have eight face weights. There is no guarantee on how a UA will map font faces within a family to weight values. The only guarantee is that a face of a given value will be no less dark than the faces of lighter values.
| Value: | <absolute-size> | <relative-size> | <length> | <percentage> | inherit |
| Initial: | medium |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | refer to inherited font size |
| Media: | visual |
| Computed value: | absolute length |
The font size corresponds to the em square, a concept used in typography. Note that certain glyphs may bleed outside their em squares. Values have the following meanings:
[ xx-small | x-small | small | medium | large | x-large | xx-large ]
The following table provides user agent guidelines for the absolute-size mapping to HTML heading and absolute font-sizes. The 'medium' value is the user's preferred font size and is used as the reference middle value.
| CSS absolute-size values | xx-small | x-small | small | medium | large | x-large | xx-large | |
|---|---|---|---|---|---|---|---|---|
| HTML font sizes | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
Implementors should build a table of scaling factors for absolute-size keywords relative to the 'medium' font size and the particular device and its characteristics (e.g., the resolution of the device).
Different media may need different scaling factors. Also, the UA should take the quality and availability of fonts into account when computing the table. The table may be different from one font family to another.
Note 1. To preserve readability, a UA applying these guidelines should nevertheless avoid creating font-size resulting in less than 9 pixels per EM unit on a computer display.
Note 2. In CSS1, the suggested scaling factor between adjacent indexes was 1.5, which user experience proved to be too large. In CSS2, the suggested scaling factor for a computer screen between adjacent indexes was 1.2, which still created issues for the small sizes. Implementation experience has demonstrated that a fixed ratio between adjacent absolute-size keywords is problematic, and this specification does not recommend such a fixed ratio.
Length and percentage values should not take the font size table into account when calculating the font size of the element.
Negative values are not allowed.
On all other properties, 'em' and 'ex' length values refer to the computed font size of the current element. On the 'font-size' property, these length units refer to the computed font size of the parent element.
Note that an application may reinterpret an explicit size, depending on the context. E.g., inside a VR scene a font may get a different size because of perspective distortion.
Examples:
p { font-size: 16px; } @media print { p { font-size: 12pt; } } blockquote { font-size: larger } em { font-size: 150% } em { font-size: 1.5em }
| Value: | [ [ <'font-style'> || <'font-variant'> || <'font-weight'> ]? <'font-size'> [ / <'line-height'> ]? <'font-family'> ] | caption | icon | menu | message-box | small-caption | status-bar | inherit |
| Initial: | see individual properties |
| Applies to: | all elements |
| Inherited: | yes |
| Percentages: | see individual properties |
| Media: | visual |
| Computed value: | see individual properties |
The 'font' property is, except as described below, a shorthand property for setting 'font-style', 'font-variant', 'font-weight', 'font-size', 'line-height' and 'font-family' at the same place in the style sheet. The syntax of this property is based on a traditional typographical shorthand notation to set multiple properties related to fonts.
All font-related properties are first reset to their initial values, including those listed in the preceding paragraph. Then, those properties that are given explicit values in the 'font' shorthand are set to those values. For a definition of allowed and initial values, see the previously defined properties.
p { font: 12px/14px sans-serif } p { font: 80% sans-serif } p { font: x-large/110% "New Century Schoolbook", serif } p { font: bold italic large Palatino, serif } p { font: normal small-caps 120%/120% fantasy }
In the second rule, the font size percentage value ('80%') refers to the font size of the parent element. In the third rule, the line height percentage refers to the font size of the element itself.
In the first three rules above, the 'font-style', 'font-variant' and 'font-weight' are not explicitly mentioned, which means they are all three set to their initial value ('normal'). The fourth rule sets the 'font-weight' to 'bold', the 'font-style' to 'italic' and implicitly sets 'font-variant' to 'normal'.
The fifth rule sets the 'font-variant' ('small-caps'), the 'font-size' (120% of the parent's font), the 'line-height' (120% times the font size) and the 'font-family' ('fantasy'). It follows that the keyword 'normal' applies to the two remaining properties: 'font-style' and 'font-weight'.
The following values refer to system fonts:
System fonts may only be set as a whole; that is, the font family, size, weight, style, etc. are all set at the same time. These values may then be altered individually if desired. If no font with the indicated characteristics exists on a given platform, the user agent should either intelligently substitute (e.g., a smaller version of the 'caption' font might be used for the 'small-caption' font), or substitute a user agent default font. As for regular fonts, if, for a system font, any of the individual properties are not part of the operating system's available user preferences, those properties should be set to their initial values.
That is why this property is "almost" a shorthand property: system fonts can only be specified with this property, not with 'font-family' itself, so 'font' allows authors to do more than the sum of its subproperties. However, the individual properties such as 'font-weight' are still given values taken from the system font, which can be independently varied.
button { font: 300 italic 1.3em/1.7em "FB Armada", sans-serif } button p { font: menu } button p em { font-weight: bolder }
If the font used for dropdown menus on a particular system happened to be, for example, 9-point Charcoal, with a weight of 600, then P elements that were descendants of BUTTON would be displayed as if this rule were in effect:
button p { font: 600 9px Charcoal }
Because the 'font' shorthand property resets any property not explicitly given a value to its initial value, this has the same effect as this declaration:
button p { font-family: Charcoal; font-style: normal; font-variant: normal; font-weight: 600; font-size: 9px; line-height: normal; }


Admin Dashboard
Manage Users
(current)
Manage Books
Manage Promotions
Home
Results
Results for
Username
First name
Last name
Email
Type
Status
Action
Admin
Customer
Employee
Inactive
Active
Suspended
Confirm Suspension
Are you sure you want to suspend this user?

Confirm Promotion
Are you sure you want to promote this employee?
Confirm Demotion
Are you sure you want to demote this admin?


Definition
Protective Collar is an option strategy that involves both the underlying stock and two option contracts. The trader buys (or already owns) a stock, then buys an out-the-money put option and sells an out-the-money call option. It is similar to the covered call strategy with the purchase of an additional put option. It is being used if the trader is writing covered calls but wish to protect himself from an unexpected downside sharp move in the price of the underlying security. As a tradeoff, the profit will become limited compared with the covered call strategy.
Payoff
# Protective Collar
price = np.arange(700,950,1)
# assume at time 0, the price of the undelying stock is 830
k_otm_put = 800 # the strike price of OTM put
k_otm_call = 860 # the strike price of OTM call
premium_otm_put = 6 # the premium of OTM put
premium_otm_call = 2 # the premium of OTM call
# payoff for the long put position
payoff_long_put = [max(-premium_otm_put, k_otm_put-i-premium_otm_put) for i in price]
# payoff for the short call position
payoff_short_call = [min(premium_otm_call, -(i-k_otm_call-premium_otm_call)) for i in price]
# payoff for the underlying stock
payoff_stock = price - 830
# payoff for the Protective Collar Strategy
payoff = np.sum([payoff_long_put,payoff_short_call,payoff_stock], axis=0)
plt.figure(figsize=(20,15))
plt.plot(price, payoff_long_put, label = 'Long Put',linestyle='--')
plt.plot(price, payoff_short_call, label = 'Short Call',linestyle='--')
plt.plot(price, payoff_stock, label = 'Underlying Stock',linestyle='--')
plt.plot(price, payoff, label = 'Protective Collar',c='black')
plt.legend(fontsize = 20)
plt.xlabel('Stock Price at Expiry',fontsize = 15)
plt.ylabel('payoff',fontsize = 15)
plt.title('Protective Collar Strategy - Payoff',fontsize = 20)
plt.grid(True)
According to the payoff plot, the maximum profit is the strike price of short call minus the purchase price of the underlying asset add the net credit from the premium. It occurs when the stock price is beyond the strike price of the short call option. The maximum loss is the purchase price of the underlying asset minus the strike price of the long put minus the net credit from the premium. It occurs when the stock price is below the strike price of the long put. It is a strategy with limit risk and limit profit.
Implementation
Step 1: Initialize your algorithm that involves setting the start date and the end date, setting the cash and implement the coarse selection of option contracts.
def Initialize(self):
self.SetStartDate(2016, 1, 01)
self.SetEndDate(2016, 3, 01)
self.SetCash(1000000)
equity = self.AddEquity("GOOG", Resolution.Minute)
option = self.AddOption("GOOG", Resolution.Minute)
self.symbol = option.Symbol
# set our strike/expiry filter for this option chain
option.SetFilter(-10, +10, timedelta(0), timedelta(30))
# use the underlying equity as the benchmark
self.SetBenchmark(equity.Symbol)
Step 2: Choose the expiration date for your options traded and break the options into the call and put contracts. The choice of expiration date depends on the holding period of stocks in your portfolio.
def TradeOptions(self,optionchain):
for i in optionchain:
if i.Key != self.symbol: continue
chain = i.Value
# choose the furthest expiration date within 30 days from now on
expiry = sorted(chain, key = lambda x: x.Expiry)[-1]
# filter the call options contracts
call = [x for x in chain if x.Right == 0 and x.Expiry == expiry]
# filter the put options contracts
put = [x for x in chain if x.Right == 1 and x.Expiry == expiry]
Step 3: Choose the deep in-the-money call and put options in the list and then sell the call options and buy the put options.
self.otm_call = sorted(call, key = lambda x: x.Strike)[-1]
self.otm_put = sorted(put, key = lambda x: x.Strike)[0]
if (self.otm_call is None) or (self.otm_put is None): continue
self.Sell(self.otm_call.Symbol, 1) # sell the OTM call
self.Buy(self.otm_put.Symbol, 1) # buy the OTM put
Step 4: In Ondata, if there is no assets in portfolio, we buy the undelying stocks. After that, we trade the options which equivalent to the amount of your stocks holding. (one option contracts equals 100 undelying shares).
def OnData(self,slice):
optionchain = slice.OptionChains
for i in slice.OptionChains:
if i.Key != self.symbol: continue
chains = i.Value
contract_list = [x for x in chains]
if (slice.OptionChains.Count == 0) or (len(contract_list) == 0): return
# if you don't hold options and stocks, buy the stocks and trade the options
if not self.Portfolio.Invested:
self.Buy("GOOG",100) # buy 100 shares of the underlying stock
self.TradeOptions(optionchain) # sell OTM call and buy OTM put
Summary
In this algorithm, at the beginning 01/04/2016, we purchased 100 GOOG shares. At the same time, we purchased a $715 put at $6 and sells a $772.5 call at $2.45. The share price of GOOG is $739.32, which is between the strike prices of two out-the-money options. At the expiry 01/15/2016, the share price of GOOG drops to $714.32. The call option expire worthless but the put option is exercised. Then we sell 100 GOOG shares at $715. Then we hold neither option positions and stock positions.
Algorithm


James & Anne Ashcroft were both Baptised on 31 July, 1825, by Rev John Cross of St Matthews, Windsor, in the name of ASHCRAFT ?? it said they were born in Minto ?? which is a long way from Windsor ??
James Ashcroft bought Macquarie Fields House, the home of Rev. George Fairfowl Macquarie. I was told he lived with his housekeeper, but he did marry her, he had no decendants.
SMH - ASHCROFT - 9 June 1893, at his residence, Macquarie Fields, JAMES ASHCROFT, in his 70th yr.
SMH - ASHCROFT - 9/6/1893, at his residence, Macquarie Fields, in Consequence of being kicked by a horse, James Ashcroft, formerly of Cannonbar, aged 70 yrs. NO FUNERAL NOTICE.!! I Found his grave at Waverley Cemetery.
Macquarie Fields House was owned by George Fairfowl Macarthur, Anglican clergyman & schoolmaster, born 19 January,1825, at The Vineyard, Parramatta,third son of Hannibal Hawkins Macarthur & Anna Maria King. He married 16/5/1849 St James Anglican Church, Sydney to Margaret Annie Priddle, they had five children. He died 16 June 1890 in Ashfield.
George Fairfowl Macarthur was senior Chaplin to the Volunteer Forces of N.S.W., a minister of St Peters Anglican Church, Campbelltown & of St Mary the Virgin Anglican Church, Denham Court NSW. He operated a Boarding School at Macquarie Fields House at Campbelltown. He was Head Master at Kings School, Parramatta from 1869 to 1896??. ---- by Campbelltown District Family History Society.


Latitude
Plots
Max Temperature
Humidity
Cloudiness
Wind Speed
Comparison
(current)
Data
(current)
Comparison: Latitude vs. X
Click any plot to get an in-depth analysis


--- title: August Blooms date: 2011-08-03 00:00:00 -06:00 categories: - whats-blooming layout: post blog-banner: whats-blooming-now-summer.jpg post-date: August 3, 2011 post-time: 3:36 AM blog-image: wbn-default.jpg ---
The temperatures are beginning to cool down and our roses are still showing off. Come take a walk through our gardens and see how many different cultivars you can count.
Bellflower Campanula incurva
Grecian Foxglove Digitalis lanata
Globe Thistle Echinops ritro
Sunburst St. John's Wort Hypericum frondosum 'Sunburst
Oriental Fountain Grass Pennisetum orientale


Safari IT Books Language Constructs Functional Programming Haskell Safari IT Books Programming Programming Programming Bryan O'Sullivan Donald Bruce Stewart John Goerzen O'Reilly Media, Inc. Real World Haskell, 1st Edition22.4. DownloadingThe next part of our program is a module to download data.
We'll need to download two different types of data: the content of a
podcast and the audio for each episode. In the former case, we'll parse
the data and update our database. For the latter, we'll write the data out
to a file on disk. We'll be downloading from HTTP servers, so we'll use a
Haskell see HTTP
library. For downloading podcast feeds, we'll download the
document, parse it, and update the database. For episode audio, we'll
download the file, write it to disk, and mark it downloaded in the
database. Here's the code: -- file: ch22/PodDownload.hs
module PodDownload where
import PodTypes
import PodDB
import PodParser
import Network.HTTP
import System.IO
import Database.HDBC
import Data.Maybe
import Network.URI
{- | Download a URL. (Left errorMessage) if an error,
(Right doc) if success. -}
downloadURL :: String -> IO (Either String String)
downloadURL url =
do resp <- simpleHTTP request
case resp of
Left x -> return $ Left ("Error connecting: " ++ show x)
Right r ->
case rspCode r of
(2,_,_) -> return $ Right (rspBody r)
(3,_,_) -> -- A HTTP redirect
case findHeader HdrLocation r of
Nothing -> return $ Left (show r)
Just url -> downloadURL url
_ -> return $ Left (show r)
where request = Request {rqURI = uri,
rqMethod = GET,
rqHeaders = [],
rqBody = ""}
uri = fromJust $ parseURI url
{- | Update the podcast in the database. -}
updatePodcastFromFeed :: IConnection conn => conn -> Podcast -> IO ()
updatePodcastFromFeed dbh pc =
do resp <- downloadURL (castURL pc)
case resp of
Left x -> putStrLn x
Right doc -> updateDB doc
where updateDB doc =
do mapM_ (addEpisode dbh) episodes
commit dbh
where feed = parse doc (castURL pc)
episodes = map (item2ep pc) (items feed)
{- | Downloads an episode, returning a String representing
the filename it was placed into, or Nothing on error. -}
getEpisode :: IConnection conn => conn -> Episode -> IO (Maybe String)
getEpisode dbh ep =
do resp <- downloadURL (epURL ep)
case resp of
Left x -> do putStrLn x
return Nothing
Right doc ->
do file <- openBinaryFile filename WriteMode
hPutStr file doc
hClose file
updateEpisode dbh (ep {epDone = True})
commit dbh
return (Just filename)
-- This function ought to apply an extension based on the file type
where filename = "pod." ++ (show . castId . epCast $ ep) ++ "." ++
(show (epId ep)) ++ ".mp3"
This module defines three functions: downloadURL, which simply downloads a URL and
returns it as a String; updatePodcastFromFeed, which downloads an XML
feed file, parses it, and updates the database; and getEpisode, which downloads a given episode and
marks it done in the database. | The HTTP library used here does not read the HTTP result
lazily. As a result, it can result in the consumption of a large amount
of RAM when downloading large files such as podcasts. Other libraries
are available that do not have this limitation. We used this one because
it is stable, easy to install, and reasonably easy to use. We suggest
mini-http, available from Hackage, for serious HTTP needs. |
|
|


Common Pan
Free Access
Premium Plan (Recommended)
Best Deal ₹2500
Deluxe Plan (Unlimited)
Lifetime Deal ₹6000


Being a former point guard on my college basketball team, who's job was to facilitate the game, I have transferred those skills to my project workflow. In addition, the perseverance, determination and discipline it taught me has resulted in me becoming a self-sufficient developer. When I'm not coding I'm either cooking, playing basketball, at an art show or looking for a new book to read.
Using HTML,CSS, Javascript, jQuery, Materialize and frameworks like AngularJS, I strive to create beautiful applications.
Ruby on Rails, MongoDB, PostgreSQL.


SMTP server response on hostname reject
invalid_hostname_reject_code
This parameter specifies the SMTP server response code when a client violates the
reject_invalid_hostname anti-UCE restriction rule that is:
Bad syntax for client HELO hostname (Not RFC compliant)
Note that the postfix default value used for invalid_hostname_reject_code is
code 501, and this code in 'standard RFC 822' should means 'Syntax error in parameters
or arguments'.
So with Postfix, a 501 status code does not reflect exactly the RFC822 explanation.
To avoid confusion, you can change this to 574 for example (another reason is that code 501
is also the postfix default value for other kind of errors), otherwise, do not change
this unless you have a complete understanding of RFC 822.


Tables
Pages
Reports
Xml Ports
Queries
Codeunits
Control Add-Ins
Page Extensions
Table Extensions
Profiles
Page Customizations
Enums
DotNet Packages
All
L
Loading objects, please wait...


Moths
By Daneelium & platy11
Hypothesis
We are attempting to catch moths and gather data about different moths with different traps.
This is the moth trap we made
This is the moth trap Daneel's grandfather made
How do the moth traps work?
- The moths are attracted to the
light/UV light
- The moths fly towards the light and once they hit it they
faint because they do not expect to hit what they thought to be 'the Moon'
- The moths fall down onto the angled sheets of plastic
and they fall through the gap into the body of the trap
- The moths try and fail to find a way out so they rest in
the egg cartons
- We built some moth traps with perspex/corrugated plastic sheets and the lights to
attract the moths
- We put cut-up egg cartons in the traps for the moths to sit on
- We left the traps on overnight and photographed and documented any moths we found
Basic findings
- We were not as succsessful on colder nights below 7-8°
- Our best findings were with the moth trap Daneel's grandfather made
This is one of the moths that we caught
We
caught
many
diferent
types
of
moths
- We only caught moths on warmer nights
- The moths preferred the UV lights
- We caught a wide variety of moths - usually only brown moths but Daneel ended up
catching a green moth that flew away very quckly.
- Many of the moths flew away quickly after the trap was opened in the morning
This is a geometer moth
This is a as-yet unidentified moth
This is also a geometer
Another unidentified moth
Yet another unidentified moth


perf-taint
Enhancing performance modeling with program analysis information.
Performance modeling has had a huge impact on the world of scientific and high-performance computing. It gave us tools to discover scalability bugs, validate performance expectations, and design new systems. In particular, empirical modeling tools made it much easier for users to derive parametric performance models. After the long modeling process, users obtain parametric models estimating the behavior of each function in the program.
Unfortunately, those tools are not a perfect solution - they are not always easy to use,
not each model is perfect, and modeling is expensive: its cost increases exponentially with the number of parameters.
We identified five major issues:
(1) users can usually afford to create models with 2-3 parameters, and selection of important program parameters is far from trivial;
(2) experiment design process is manual and can be difficult as well;
(3) instrumenting all functions adds significant overhead and affects the quality of results;
(4) function models can present false-positive dependencies due to noise and overfitting,
particularly on small and short running functions (see example below);
(5) empirical models can represent effects other than those resulting from the program itself, such as hardware effects.
Our work shows that these issues can be mitigated by turning the black-box empirical modeling process into a white-box one. We include in the modeling process a program analysis step to achieve two goals: identify functions which performance is constant with respect to input parameters, and detect which parameters affect the function’s computational effort. In addition, the analysis must be memory agnostic and inter-procedural, and it must be possible to integrate it into distributed MPI applications.
We selected dynamic taint analysis, a computer security technique used to analyze the dependency of program code on potentially malicious user input. The analysis allows us to annotate program input parameters as a source of taint labels, and the compiler instrumentation introduces propagation of taint labels across data flow and control flow. Furthermore, the user memory region is replicated in the so-called shadow memory to keep track of the labels associated with each program variable. In the end, we can inspect performance-critical code regions, such as loop conditions and determine which program parameters affected their value.
perf-taint extracts the vital program information to simplify the modeling process.
The parameter dependency is used to:
(1) help users select modeling parameters;
(2) simplify modeling experiments;
(3) removing constant functions from instrumentation and modeling;
(4) removing models with false dependencies;
(5) detecting when empirical models differ substantially from the program and can include other effects.
We evaluated perf-taint on two HPC benchmarks and showed that perf-taint makes the performance modeling easier, cheaper, and more robust. In HPC applications, perf-taint helps primarily by identifying that over 85% of functions are constant.
Our work has been recognized at the ACM Student Research Competition at Supercomputing 19, where the poster won first place. In addition, the full research paper has been presented at ACM SIGPLAN PPoPP 2021.


--- layout: post title: Google+ API still due? You can already do stuff ... date: 2011-08-31 21:19:14.000000000 +02:00 type: post published: true status: publish categories: - Coding tags: - APIs - google meta: _syntaxhighlighter_encoded: '1' _thumbnail_id: '1246' _edit_last: '1' dsq_thread_id: '497923246' author: login: bbWebdesign email<EMAIL_ADDRESS>display_name: Bob first_name: Bob last_name: Belderbos ---
After playing with some APIs, especially the Facebook one, I cannot wait till Google+ releases its API. However there are ways you can already import your profile and posts!
In this post I will show you how this is done with Rudimentary GooglePlus API, a very cool Python script that returns the dataset based on the "type" variable you give it (profile or posts). Then I will show you how you can process the obtained output with PHP. I will do the profile data, as it is a bit trickier to find the pieces as it not an associative array.
After experimenting a bit with it, the data seems to be at fixed positions which I tested with some Google+ IDs (by the way, click on your avatar in Google+ : your Google+ ID appears in the URL)
Here are two examples. See Rudimentary GooglePlus API for more details. For both examples, replace the id= number for your own or somebody else.
Here is my script that filters most of the profile information. I did not play much with the posts, but the "prettyposts" array is better structured, so with below code it should be fairly easy to get.
As said, the challenge was to find where the bits were. You can see from the array offsets, that some pieces are quite deep down in this multidimensional array that is obtained with json_decode (one of my favorite functions when dealing with API data processing!).
Funny enough the structure seems persistent testing 10 to 20 Google+ profile IDs. So this is something useful we can do already today. However I guess the Google+ API will blow us away ;)
  <title>Google+ importer</title> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="description" content="This page imports your google+ profile" />   <?php // thanks!! to: // http://point7.wordpress.com/2011/07/10/rudimentary-googleplus-api/ <-- // more php https://github.com/jmstriegel/php.googleplusapi $user = $_GET['u']; $query = "http://my.syyn.cc/gpapi?id={$user}&type=profile"; $out = file_get_contents($query); $response = json_decode($out, true); $g = array(); $g['usr'] = ($response[2])? $response[2]: ''; $g['avatar'] = ($response[3])? $response[3].'?sz=90': ''; $g['name'] = ($response[4][3])? $response[4][3]: ''; $g['title'] = ($response[6][1])? $response[6][1]: ''; $g['location'] = ($response[9][1])? $response[9][1]: ''; echo '
'.$g['name'].'
'; echo '
Personal Data

Avatar:

Title: ' .$g['title'] . '

Location: ' .$g['location'] . '

'; if(!empty($response[14][1])) { echo '
About me

'.$response[14][1].'
'; } if(!empty($response[7][1])) { echo '
Work

Company	Function	'; foreach($response[7][1] as $r) { echo '
'; echo ''.$r[0].'	'; echo ''.$r[1].'	'; echo '
'; } echo '
'; } if(!empty($response[8][1])) { echo '
Education

Institute	Studies	'; foreach($response[8][1] as $r) { echo '
'; echo ''.$r[0].'	'; echo ''.$r[1].'	'; echo '
'; } echo '
'; } if(!empty($response[11][0])) { echo '
Links

Name	URL	'; foreach($response[11][0] as $r) { echo '
'; echo ''.$r[3].'	'; echo ''.$r[1].'	'; echo '
'; } echo '
'; } ?>
You can resize the avatar appending ?sz=size to it:
$g['avatar'] = ($response[3])? $response[3].'?sz=90': '';
You can even put the corresponding social media icons for the link:
foreach($response[11][0] as $r) { .. .. style="padding-left: 20px; background:url('http:'.$r[2].'') top left
My Google+ profile imported (no CSS applied):


IOGroup that uses DBus interface to access geopmd provided signals and controls. This IOGroup is not loaded by a server side PlatformIO object.
More...
#include <ServiceIOGroup.hpp>
|
| | ServiceIOGroup () |
| |
| | ServiceIOGroup (const PlatformTopo &platform_topo, std::shared_ptr< ServiceProxy > service_proxy, std::shared_ptr< BatchClient > batch_client_mock) |
| |
| | ServiceIOGroup (const ServiceIOGroup &other)=delete |
| |
| ServiceIOGroup & | operator= (const ServiceIOGroup &other)=delete |
| |
| virtual | ~ServiceIOGroup () |
| |
| std::set< std::string > | signal_names (void) const override |
| |
| std::set< std::string > | control_names (void) const override |
| |
| bool | is_valid_signal (const std::string &signal_name) const override |
| |
| bool | is_valid_control (const std::string &control_name) const override |
| |
| int | signal_domain_type (const std::string &signal_name) const override |
| |
| int | control_domain_type (const std::string &control_name) const override |
| |
| int | push_signal (const std::string &signal_name, int domain_type, int domain_idx) override |
| |
| int | push_control (const std::string &control_name, int domain_type, int domain_idx) override |
| |
| void | read_batch (void) override |
| |
| void | write_batch (void) override |
| |
| double | sample (int sample_idx) override |
| |
| void | adjust (int control_idx, double setting) override |
| |
| double | read_signal (const std::string &signal_name, int domain_type, int domain_idx) override |
| |
| void | write_control (const std::string &control_name, int domain_type, int domain_idx, double setting) override |
| |
| void | save_control (void) override |
| |
| void | restore_control (void) override |
| |
| std::function< double(const std::vector< double > &)> | agg_function (const std::string &signal_name) const override |
| |
| std::function< std::string(double)> | format_function (const std::string &signal_name) const override |
| |
| std::string | signal_description (const std::string &signal_name) const override |
| |
| std::string | control_description (const std::string &control_name) const override |
| |
| int | signal_behavior (const std::string &signal_name) const override |
| |
| void | save_control (const std::string &save_path) override |
| |
| void | restore_control (const std::string &save_path) override |
| |
| std::string | name (void) const override |
| |
IOGroup that uses DBus interface to access geopmd provided signals and controls. This IOGroup is not loaded by a server side PlatformIO object.
◆ ServiceIOGroup() [1/3]
| geopm::ServiceIOGroup::ServiceIOGroup |
( |
| ) |
|
◆ ServiceIOGroup() [2/3]
| geopm::ServiceIOGroup::ServiceIOGroup |
( |
const PlatformTopo & |
platform_topo, |
|
|
std::shared_ptr< ServiceProxy > |
service_proxy, |
|
|
std::shared_ptr< BatchClient > |
batch_client_mock |
|
) |
| |
◆ ServiceIOGroup() [3/3]
◆ ~ServiceIOGroup()
| geopm::ServiceIOGroup::~ServiceIOGroup |
( |
| ) |
|
|
virtual |
◆ adjust()
| void geopm::ServiceIOGroup::adjust |
( |
int |
control_idx, |
|
|
double |
setting |
|
) |
| |
|
override |
◆ agg_function()
| std::function< double(const std::vector< double > &)> geopm::ServiceIOGroup::agg_function |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ control_description()
| std::string geopm::ServiceIOGroup::control_description |
( |
const std::string & |
control_name | ) |
const |
|
override |
◆ control_domain_type()
| int geopm::ServiceIOGroup::control_domain_type |
( |
const std::string & |
control_name | ) |
const |
|
override |
◆ control_names()
| std::set< std::string > geopm::ServiceIOGroup::control_names |
( |
void |
| ) |
const |
|
override |
◆ format_function()
| std::function< std::string(double)> geopm::ServiceIOGroup::format_function |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ is_valid_control()
| bool geopm::ServiceIOGroup::is_valid_control |
( |
const std::string & |
control_name | ) |
const |
|
override |
◆ is_valid_signal()
| bool geopm::ServiceIOGroup::is_valid_signal |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ make_plugin()
| std::unique_ptr< IOGroup > geopm::ServiceIOGroup::make_plugin |
( |
void |
| ) |
|
|
static |
◆ name()
| std::string geopm::ServiceIOGroup::name |
( |
void |
| ) |
const |
|
override |
◆ operator=()
◆ plugin_name()
| std::string geopm::ServiceIOGroup::plugin_name |
( |
void |
| ) |
|
|
static |
◆ push_control()
| int geopm::ServiceIOGroup::push_control |
( |
const std::string & |
control_name, |
|
|
int |
domain_type, |
|
|
int |
domain_idx |
|
) |
| |
|
override |
◆ push_signal()
| int geopm::ServiceIOGroup::push_signal |
( |
const std::string & |
signal_name, |
|
|
int |
domain_type, |
|
|
int |
domain_idx |
|
) |
| |
|
override |
◆ read_batch()
| void geopm::ServiceIOGroup::read_batch |
( |
void |
| ) |
|
|
override |
◆ read_signal()
| double geopm::ServiceIOGroup::read_signal |
( |
const std::string & |
signal_name, |
|
|
int |
domain_type, |
|
|
int |
domain_idx |
|
) |
| |
|
override |
◆ restore_control() [1/2]
| void geopm::ServiceIOGroup::restore_control |
( |
const std::string & |
save_path | ) |
|
|
override |
◆ restore_control() [2/2]
| void geopm::ServiceIOGroup::restore_control |
( |
void |
| ) |
|
|
override |
◆ sample()
| double geopm::ServiceIOGroup::sample |
( |
int |
sample_idx | ) |
|
|
override |
◆ save_control() [1/2]
| void geopm::ServiceIOGroup::save_control |
( |
const std::string & |
save_path | ) |
|
|
override |
◆ save_control() [2/2]
| void geopm::ServiceIOGroup::save_control |
( |
void |
| ) |
|
|
override |
◆ signal_behavior()
| int geopm::ServiceIOGroup::signal_behavior |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ signal_description()
| std::string geopm::ServiceIOGroup::signal_description |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ signal_domain_type()
| int geopm::ServiceIOGroup::signal_domain_type |
( |
const std::string & |
signal_name | ) |
const |
|
override |
◆ signal_names()
| std::set< std::string > geopm::ServiceIOGroup::signal_names |
( |
void |
| ) |
const |
|
override |
◆ write_batch()
| void geopm::ServiceIOGroup::write_batch |
( |
void |
| ) |
|
|
override |
◆ write_control()
| void geopm::ServiceIOGroup::write_control |
( |
const std::string & |
control_name, |
|
|
int |
domain_type, |
|
|
int |
domain_idx, |
|
|
double |
setting |
|
) |
| |
|
override |
The documentation for this class was generated from the following files:


set_input/1
set_input/1 – set current input stream
set_output/1 – set current output stream
FORMS
set_input(Stream_or_Alias)
set_output(Stream_or_Alias)
DESCRIPTION
For both forms Stream_or_Alias must be either a stream descriptor returned by a call to open/3 or open/4 or an alias created during a successful call to open. For the sake of the
following discussion, let us suppose that Stream is Stream_or_Alias if Stream_or_Alias is a stream descriptor. If Stream_or_Alias is an alias, then let Stream be the stream associated with that alias.
set_input/1 will set the stream associated with the current input stream to Stream. The current input stream is the stream that is read when predicates such as get_char/1 or read/1 are called. The current input stream may be retrieved by calling current_input/1.
set_output/1 will set the stream associated with the current output stream to Stream. The current output stream is the stream which is written to when predicates
such as put_char/1 or write/1 are called. The current output stream may be retrieved by calling current_output/1.
EXAMPLES
Suppose that the file "test" is comprised of the characters "abcdefgh\n".
Open the file "test" and set the current input stream to the stream descriptor
returned from open.
?- open(test,read,S), set_input(S).
S = stream_descriptor('',open,file,test,[input|nooutput],true,
4,0,0,0,0,true,0,wt_opts(78,40000,flat),[],true,
text,eof_code,0,0)
Get two characters from the current input stream.
?- get_char(C1), get_char(C2).
C1 = a
C2 = b
Close the stream associated with "test".
?- current_input(S), close(S).
S = stream_descriptor('',closed,file,test,[input|nooutput],true,
4,0,0,0,0,true,0,wt_opts(78,40000,flat),[],true,
text,eof_code,0,0)
ERRORS
Stream_or_Alias is a variable
––––> instantiation_error.
Stream_or_Alias is not a variable nor a stream descriptor nor an alias
––––> domain_error(stream_or_alias,Stream_or_Alias).
Stream_or_Alias is not associated with an open stream
––––> existence_error(stream,Stream_or_Alias).
Stream_or_Alias is not an input stream (for set_input/1)
––––> permission_error(input,stream,Stream_or_Alias).
Stream_or_Alias is not an output stream (for set_output/1)
––––> permission_error(output,stream,Stream_or_Alias).
NOTES
close/1 may also change the setting of the current input or output streams.
SEE ALSO
current_input/1, open/3, close/1, User Guide (Prolog I/O).


File
Implements
Constructor
constructor(dialogRef: MatDialog)
|
|
|
Parameters :
| Name |
Type |
Optional |
| dialogRef |
MatDialog
|
No
|
|
Methods
|
closePrompt
|
closePrompt()
|
|
|
|
|
|
Public
getQoute
|
getQoute()
|
|
|
|
|
|
period
|
Type : String | any
|
|
|
|
qoute
|
Type : String | any
|
|
|
|
qoutes
|
Type : []
|
Default value : [
"Good Work!!",
"Keep it up!!  You can achieve it!",
"Dont Wish for it, Work for it!",
"Dont let yesterday take too much of today.",
"It might not be easy but it'll be worth it.",
"Believe you can and you are halfway there.",
"Stay hopeful.",
"Make each day your masterpiece.",
"Dont stop. Keep going!",
"Focus.",
"Be a voice not an echo."
]
|
|
|
import { Component, OnInit } from '@angular/core';
import { MatDialog } from '@angular/material/dialog';
@Component({
selector: 'app-prompt',
templateUrl: './prompt.component.html',
styleUrls: ['./prompt.component.scss']
})
export class PromptComponent implements OnInit {
qoute: String | any;
hour: Number | any;
period: String | any;
constructor(private dialogRef: MatDialog) { }
ngOnInit(): void {
this.qoute = this.getQoute();
var currTime = new Date();
this.hour = currTime.getHours();
if(this.hour == 0){
this.period = "AM";
this.hour = 12;
}else if(this.hour < 12){
this.period = "AM";
} else if(this.hour == 12){
this.period = "PM";
} else{
this.period = "PM";
this.hour -= 12;
}
}
// openDialog(){
// this.dialogRef.open(PromptComponent);
// }
qoutes = [
"Good Work!!",
"Keep it up!!  You can achieve it!",
"Dont Wish for it, Work for it!",
"Dont let yesterday take too much of today.",
"It might not be easy but it'll be worth it.",
"Believe you can and you are halfway there.",
"Stay hopeful.",
"Make each day your masterpiece.",
"Dont stop. Keep going!",
"Focus.",
"Be a voice not an echo."
]
public getQoute(){
var randomIndex = Math.floor(Math.random() * this.qoutes.length)
return this.qoutes[randomIndex]
}
closePrompt(){
this.dialogRef.closeAll();
}
}

{{this.hour}} {{this.period}} Checkpoint

Mark completed tasks in the ToDo List.

{{this.qoute}}

Okay

Legend
Html element with directive


After spending a few amazing months as a 'Fellow', I'm now full-time with the team at B12, envisioning a future where creative, talented experts can focus on the interesting parts of their work, letting technology like Orchestra take care of the rest.
I recently completed my dissertation on the design of computer systems that coordinate crowdsourced human workers to analyze large datasets quickly enough to fit into automated data analysis workflows. I was advised by Prof. Michael Franklin in the AMPLab at UC Berkeley. Before that, I worked in the Children's Hospital Informatics Program at Boston Children's Hospital designing storage systems, dataflows, and applications for managing patient information. I completed my undergraduate education in the School of Engineering and Applied Sciences at Harvard University in 2010.
Outside of the knowledge playground, I've been lucky enough to find Aleksandra Kuczmarska-Haas, an amazing wife and a resident in radiation oncology at the University of Wisconsin-Madison. We own a little blue home in Middleton, WI, and in my spare time I play frisbee, soccer, and mediocre online chess, and enjoy cooking the odd risotto or traveling the world (recent trips include Poland/Budapest, the Galapagos, and Indonesia/Singapore/Malaysia).


End Event
Ending the event will erase all currently entered data including players, pairings, and results. Are you sure you want to end the event?
I'm done with this event Not yet


{% extends "accounts/panel/base.html" %} {% block c %}
Please wait for admin to view your application.


open fun getPIDSourceType(): Type
Overrides PIDSource.getPIDSourceType
Get which parameter of the device you are using as a process control variable.
Return the currently selected PID source parameter


Hangman
The Dead Composer Edition
Guess the Composer
Letters Used
Guesses Left
?
Rounds Won
0
Rounds Lost
0
Composer's Bio
TODO: Placeholder Picture of Composer
TODO: Placeholder Bio Text


Seton Hall handles Saint Louis for bounce back win
by Associated PressST. LOUIS — Myles Powell scored 26 points and Sandro Mamukelashvili added 17 in No. 12 Seton Hall’s 83-66 victory over Saint Louis on Sunday.
Quincy McKnight added 12 points to help the Pirates (3-1) rebound from a 76-73 loss to No.3 Michigan State on Thursday night.
Hasahn Frnech led Saint Louis with 14 points and 10 rebounds.
Seton Hall scored the first 10 points and led 18-3 after 7:09. The Pirates made seven straight shots during the early blitz.
Saint Louis got no closer than eight points the rest of the way.
Powell, who scored 37 points in the loss to Michigan State, added six rebounds
Mamukelashvili hit a 3-pointer to start the game. Romaro Gill put down a slam off a pass from Powell for a 7-0 lead. Myles Cale followed with a 3-pointer.
Seton Hall led 46-31 at the break and scored the first seven points of the second half.
Saint Louis (3-1) had won the previous three games between the teams.


Recent versions of OpenStack nova have added support for real-time instances, that is, instances that provide the determinism and performance guarantees required by real-time applications. While this work was finally marked complete in the OpenStack Ocata release, it built upon lots of features added in previously releases.
The below is a guide that covers a basic, single-node deployment of OpenStack suitable for evaluating basic real-time instance functionality. We use CentOS 7, but the same instructions can be modified for RHEL 7 or Fedora, and any CentOS-specific aspects are called out. Also note that we’re using DevStack: you obviously shouldn’t be using this in production (I hear Red Hat OpenStack Platform is pretty swell!).
Host BIOS configuration
Configure your BIOS as recommended in the rt-wiki page. The most important steps are:
- Disable power management, including CPU sleep states
- Disable hyper-threading or any option related to logical processors
These are standard steps used in benchmarking as both sets of features can result in non-deterministic behavior.
Host OS configuration
-
Download and install CentOS 7.
-
Log in as
root
.Most of the following steps require root privileges. While you can do this with
sudo
, it’s generally easier to log in as theroot
user. Do this now.$ su -
-
Enable the
rt
repo.$ cat << EOF > /etc/yum.repos.d/CentOS-RT.repo # CentOS-RT.repo # # The Real Time (RT) repository. # [rt] name=CentOS-$releasever - rt baseurl=http://mirror.centos.org/centos/$releasever/rt/$basearch/ gpgcheck=1 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7 enabled=1 EOF $ sudo yum update -y
Most online guides will point you to a CERN repo for these packages. I had no success with this as some packages were missing. However, the steps to do this are below, just in case they’re helpful.
$ wget http://linuxsoft.cern.ch/cern/centos/7/rt/CentOS-RT.repo /etc/yum.repos.d/CentOS-RT.repo $ wget http://linuxsoft.cern.ch/cern/centos/7/os/x86_64/RPM-GPG-KEY-cern /etc/pki/rpm-gpg/RPM-GPG-KEY-cern $ sudo yum groupinstall RT
-
Install dependencies.
The most critical of these are
kernel-rt
andkernel-rt-kvm
, but these have dependencies of their own. When I was installing this, there was a conflict between the version installed by default (@anaconda
) and the one provided by thert
repo. To resolve this, I simply removed the conflicting version and installed the one provided by thert
repo.$ yum remove tuned $ yum install -y tuned-2.7.1-5.el7
After this, install the aforementioned dependencies along with some required by CentOS specifically.
$ yum install -y centos-release-qemu-ev $ yum install -y tuned-profiles-realtime tuned-profiles-nfv $ yum install -y kernel-rt.x86_64 kernel-rt-kvm.x86_64
-
Configure the realtime profile.
We want to isolate some cores from the kernel and will use the
tuned
application with the profiles installed above to do this.First, dump info about your NUMA topology.
$ lscpu | grep ^NUMA NUMA node(s): 2 NUMA node0 CPU(s): 0,2,4,6,8,10 NUMA node1 CPU(s): 1,3,5,7,9,11
This processor, an Intel Xeon E5-2609-v3, has six cores and we’ve got two of them. We want to isolate some of these cores. CPU0 should be excluded from the possible cores as it handles console interrupts while a second core should be kept free for other host overhead processes. Let’s take a highly scientific approach and isolate four of the six cores from each socket because why not?
$ echo "isolated_cores=4-11" >> /etc/tuned/realtime-virtual-host-variables.conf
-
Load the realtime profile.
$ systemctl enable tuned $ systemctl start tuned $ tuned-adm profile realtime-virtual-host
You should confirm that the profile has been applied.
$ grep tuned_params= /boot/grub2/grub.cfg set tuned_params="isolcpus=4-11 nohz=on nohz_full=4-11 intel_pstate=disable nosoftlockup"
-
Configure huge pages.
First, add the following to
GRUB_CMDLINE_LINUX
in/etc/default/grub
.default_hugepagesz=1G
Save this configuration.
$ grub2-mkconfig -o /boot/grub2/grub.cfg Generating grub configuration file ... Found linux image: /boot/vmlinuz-3.10.0-327.13.1.el7.x86_64 done
Because we’re using a number of CPUs from each NUMA node, we want to assign a number hugepages to each node. We’re going to assign four per node.
$ echo 4 > /sys/devices/system/node/node0/hugepages/hugepages-1048576kB/nr_hugepages $ echo 4 > /sys/devices/system/node/node1/hugepages/hugepages-1048576kB/nr_hugepages
We want to make this persistent. While you can configure persistent hugepages via the
GRUB_CMDLINE_LINUX
option, you cannot do this on a per-NUMA node basis. We’re going to use our ownsystemd
unit files to solve this problem until such a time as bug #1232350 is resolved. This solution is taken from that bug.$ cat << EOF > /usr/lib/systemd/system/hugetlb-gigantic-pages.service [Unit] Description=HugeTLB Gigantic Pages Reservation DefaultDependencies=no Before=dev-hugepages.mount ConditionPathExists=/sys/devices/system/node ConditionKernelCommandLine=hugepagesz=1G [Service] Type=oneshot RemainAfterExit=yes ExecStart=/usr/lib/systemd/hugetlb-reserve-pages [Install] WantedBy=sysinit.target EOF $ cat << EOF > /usr/lib/systemd/hugetlb-reserve-pages #!/bin/bash nodes_path=/sys/devices/system/node/ if [ ! -d $nodes_path ]; then echo "ERROR: $nodes_path does not exist" exit 1 fi reserve_pages() { echo $1 > $nodes_path/$2/hugepages/hugepages-1048576kB/nr_hugepages } reserve_pages 4 node0 reserve_pages 4 node1 EOF $ chmod +x /usr/lib/systemd/hugetlb-reserve-pages $ systemctl enable hugetlb-gigantic-pages
-
Reboot the host to apply changes.
-
Verify that changes have been applied.
You want to ensure the
tuned
profile is loaded and the changes it has made have taken effect, such as addingisolcpus
and related parameters to the boot command. In addition, you want to make sure your own hugepage configuration has been applied.$ tuned-adm active Current active profile: realtime-virtual-host $ cat /proc/cmdline BOOT_IMAGE=/vmlinuz-3.10.0-327.18.2.rt56.223.el7_2.x86_64 root=/dev/mapper/rhel_virtlab502-root ro crashkernel=auto rd.lvm.lv=rhel_virtlab502/root rd.lvm.lv=rhel_virtlab502/swap console=ttyS1,115200 default_hugepagesz=1G isolcpus=3,5,7 nohz=on nohz_full=3,5,7 intel_pstate=disable nosoftlockup $ cat /sys/module/kvm/parameters/lapic_timer_advance_ns 1000 # this should be a non-0 value $ cat /sys/devices/system/node/node0/hugepages/hugepages-1048576kB/nr_hugepages 4 $ cat /sys/devices/system/node/node1/hugepages/hugepages-1048576kB/nr_hugepages 4
-
Verify that system interrupts are disabled.
You should install the
rt-tests
package, then run thehwlatdetect
utility it provides to validate correct behavior.$ yum install -y rt-tests $ hwlatdetect hwlatdetect: test duration 120 seconds parameters: Latency threshold: 10us Sample window: 1000000us Sample width: 500000us Non-sampling period: 500000us Output File: None Starting test test finished Max Latency: 0us Samples recorded: 0 Samples exceeding threshold: 0
If this shows any samples exceeding threshold, something is wrong and you should retrace your steps.
-
Verify “real-time readiness”.
The
rteval
utility can be used to evaluate system suitability for RT Linux. It must be run for a long duration, so you should put this running and come back to it later.$ yum install rteval $ rteval --onlyload --duration=4h --verbose
Guest image configuration
We’re going to need a real-time image for the guest too. I did this manually on
another machine using virt-install
. Much of the configuration is duplicated
from the host.
-
Boot the guest and configure it using a
root
user.We don’t actually care about most of the configuration here wrt to RAM and CPU count since we’ll be changing this later. The only things to note are that we’re using the same OS as the host (CentOS) for ease-of-use and we have both network connectivity (so we can install packages) and a serial connection (so we can interact with the guest).
$ sudo virt-install \ --name centos7 \ --ram 4096 \ --disk path=./centos7.qcow2,size=8 \ --vcpus 4 \ --os-type linux \ --os-variant centos7.0 \ --network bridge=virbr0 \ --graphics none \ --console pty,target_type=serial \ --location 'http://isoredirect.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-Minimal-1708.iso' \ --extra-args 'console=ttyS0,115200n8 serial' # ... follow prompts
-
Enable the
rt
repo.$ echo << EOF > /etc/yum.repos.d/CentOS-RT.repo # CentOS-RT.repo # # The Real Time (RT) repository. # [rt] name=CentOS-$releasever - rt baseurl=http://mirror.centos.org/centos/$releasever/rt/$basearch/ gpgcheck=1 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7 enabled=1 EOF $ sudo yum update -y
-
Install dependencies.
We naturally don’t need the
kernel-rt-kvm
module, but we do need thekernel-rt
package and some other dependencies. Seeing as we’re using CentOS for the guest too, we have to deal with the sametuned
dependency conflict.$ yum remove tuned $ yum install -y tuned-2.7.1-5.el7
After this, install the aforementioned dependencies along with some required by CentOS specifically.
$ yum install -y centos-release-qemu-ev $ yum install -y tuned-profiles-realtime tuned-profiles-nfv $ yum install -y kernel-rt.x86_64
-
Configure the realtime profile.
Configure the
tuned
profile toisolate the two CPUs we reserved for real-time in the flavour (i.e.^0-1
, so2
and3
)$ echo "isolated_cores=2,3" >> /etc/tuned/realtime-virtual-guest-variables.conf
-
Load the realtime profile.
$ systemctl enable tuned $ systemctl start tuned $ tuned-adm profile realtime-virtual-guest
Note that we’re using the guest profile here - not the host one.
You should confirm that the profile has been applied.
$ grep tuned_params= /boot/grub2/grub.cfg set tuned_params="isolcpus=2,3 nohz=on nohz_full=2,3 rcu_nocbs=2,3 intel_pstate=disable nosoftlockup"
-
Configure hugepages.
First, add the following to
GRUB_CMDLINE_LINUX
in/etc/default/grub
.default_hugepagesz=1G
Save this configuration.
$ grub2-mkconfig -o /boot/grub2/grub.cfg Generating grub configuration file ... Found linux image: /boot/vmlinuz-3.10.0-327.13.1.el7.x86_64 done
We don’t need to enable these as this will be done from the OpenStack side.
-
Install testing dependencies.
We’re going to be doing some testing later. Best to install these dependencies now.
$ yum install -y epel-release $ yum install -y rt-tests stress
-
Reboot the guest to apply changes.
-
Verify the changes have been applied.
Once again, you want to ensure the
tuned
profile is loaded and applied, and that the hugepages have been configured.$ tuned-adm active Current active profile: realtime-virtual-guest $ uname -a Linux guest.localdomain 3.10.0-693.2.2.rt56.623.el7.x86_64 #1 SMP PREEMPT RT Sun Jan 01 00:00:00 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux $ cat /proc/cmdline BOOT_IMAGE=/vmlinuz-3.10.0-693.2.2.rt56.623.el7.x86_64 root=/dev/mapper/centos-root ro rd.lvm.lv=centos/root rd.lvm.lv=centos/swap console=ttyS0,115200n8 default_hugepagesz=1G isolcpus=2,3 nohz=on nohz_full=2,3 rcu_nocbs=2,3 intel_pstate=disable nosoftlockup
-
Install OpenStack-specific dependencies.
We want to use
cloud-init
to configure stuff in OpenStack, so let’s install the various dependencies required. This is taken from the OpenStack docs.$ yum install -y acpid $ systemctl enable acpid $ yum install -y cloud-init cloud-utils-growpart $ echo "NOZEROCONF=yes" >> /etc/sysconfig/network
We don’t need to configure a console interface as
virt-install
has already done this for us.Once this is done, you can shutdown the guest.
$ poweroff
-
Clean up the image.
We want to strip stuff like MAC addresses from the guest. This should be done wherever you ran
virt-install
.$ sudo virt-sysprep -d centos7
If this is successful, you can undefine and shrink the image. It’s now ready for use later.
$ sudo virsh undefine centos7 $ sudo qemu-img convert -O qcow2 -c centos7.qcow2 centos7-small.qcow2
Nova configuration
-
Log back into your standard user.
We no longer need to run as root and DevStack, which I’m using here, will refuse to run this way.
-
Install and configure OpenStack.
I used DevStack for this, though you can use anything you want. This feature relies on features first included in the Pike release so you should deploy a suitable version. Given that I’m using DevStack, I’m simply going to use the
stable/pike
variant of DevStack and all dependencies.$ git clone https://github.com/openstack-dev/devstack/ $ cd devstack $ git checkout stable/pike $ echo << EOF > local.conf [[local|localrc]] GLANCE_V1_ENABLED=False CINDER_BRANCH=stable/pike GLANCE_BRANCH=stable/pike HORIZON_BRANCH=stable/pike KEYSTONE_BRANCH=stable/pike NEUTRON_BRANCH=stable/pike NEUTRON_FWAAS_BRANCH=stable/pike NOVA_BRANCH=stable/pike SWIFT_BRANCH=stable/pike ADMIN_PASSWORD=password DATABASE_PASSWORD=$ADMIN_PASSWORD RABBIT_PASSWORD=$ADMIN_PASSWORD HORIZON_PASSWORD=$ADMIN_PASSWORD SERVICE_PASSWORD=$ADMIN_PASSWORD [[post-config|$NOVA_CONF]] [DEFAULT] firewall_driver=nova.virt.firewall.NoopFirewallDriver scheduler_default_filters=RamFilter,ComputeFilter,AvailabilityZoneFilter,ComputeCapabilitiesFilter,ImagePropertiesFilter,PciPassthroughFilter,NUMATopologyFilter vcpu_pin_set=4-11 EOF $ ./stack.sh # wait for successful deployment $ . openrc admin
You can use a mostly stock configuration with the exception of one configuration option:
[DEFAULT] vcpu_pin_set
. This should be configured for thenova-compute
service and should be set to the mask configured bytuned
earlier. -
Validate deployment.
Once this has deployed, you can check the logs of the
nova-compute
service to make sure thevcpu_pin_set
configuration has been successful. If deploying usingstable/pike
DevStack, you can do this usingjournalctl
.$ sudo journalctl -u<EMAIL_ADDRESS>| grep 'vcpu_pin_set' | tail -1 vcpu_pin_set = 4-11 $ sudo journalctl -u<EMAIL_ADDRESS>| grep 'Total usable vcpus' | tail -1 Total usable vcpus: 8, total allocated vcpus: 0
This is as expected, given that we we were using a
4-11
mask and have not yet deployed any instances.I’m sure there’s a better way to do this filtering with
journalctl
. -
Configure flavor.
Once you’ve verified everything, you can create your custom real-time flavor. To do this, first configure your environment variables.
$ openstack flavor create --vcpus 4 --ram 4096 --disk 20 rt1.small $ openstack flavor set rt1.small \ --property 'hw:cpu_policy=dedicated' \ --property 'hw:cpu_realtime=yes' \ --property 'hw:cpu_realtime_mask=^0-1' \ --property 'hw:mem_page_size=1GB'
By way of an explanation, these various properties correspond to the following.
hw:cpu_policy=dedicated
: This indicates that instances must have exclusive pCPUs assigned to them.hw:cpu_realtime=yes
: This indicates that instances will have a real-time policy.hw:cpu_realtime_mask="^0-1"
: This indicates that all instance vCPUs except vCPUs 0 and 1 will have a real-time policy.hw:mem_page_size=1GB
: This indicates that instances will have a sole 1 GB huge page assigned to them.For more information, refer to the nova docs.
-
Configure image.
We’re going to use the
centos7-small.qcow2
created previously. Upload this toglance
.$ openstack image create --disk-format qcow2 --container-format bare \ --public --file ./centos-small.qcow2 centos-rt
-
(Optional) Configure security groups and keypairs.
We want to ensure we can both ping the instance and SSH into it. This requires ICMP and TCP port 22 rules in the security group for the project. This is necessary because I installed using DevStack but may not be necessary using other deployment tools.
$ echo OS_PROJECT_NAME demo $ openstack project list | grep -w demo | f5a2496e6edf4ef4b5ffe62b01a8bf4b | demo | $ openstack security group list | grep -w f5a2496e6edf4ef4b5ffe62b01a8bf4b | 466ffc5e-114d-43a4-8854-db490c6b4571 | default | Default security group | f5a2496e6edf4ef4b5ffe62b01a8bf4b | $ openstack security group rule create --proto icmp \ 466ffc5e-114d-43a4-8854-db490c6b4571 $ openstack security group rule create --proto tcp --dst-port 22 \ 466ffc5e-114d-43a4-8854-db490c6b4571
In addition, we want to create a keypair so we can ssh into the instance.
$ openstack keypair create --public-key .ssh/id_rsa.pub default-key
Testing
Now we have everything configured, we’re going to create an instance and run our tests.
-
Boot instance
$ openstack server create --flavor rt1.small --image centos-rt \ --key-name default-key rt-server
This initially failed for me with the following error message:
Could not access KVM kernel module: Permission denied failed to initialize KVM: Permission denied
I was able to resolve this with the following commands, taken from a related bugzilla.
$ sudo rmmod kvm_intel $ sudo rmmod kvm $ sudo modprobe kvm $ sudo modprobe kvm_intel
-
Connect floating IP.
This is necessary so we can SSH into the instance.
$ openstack floating ip create public +---------------------+--------------------------------------+ | Field | Value | +---------------------+--------------------------------------+ | created_at | 2017-01-01T00:00:00Z | | description | | | fixed_ip_address | None | | floating_ip_address | <IP_ADDRESS> | | floating_network_id | 5e123439-bbe8-479b-ab32-cc66d1a34ae2 | | id | cb62400c-983f-4468-949c-a64fb6b47827 | | name | <IP_ADDRESS> | | port_id | None | | project_id | f5a2496e6edf4ef4b5ffe62b01a8bf4b | | revision_number | 0 | | router_id | None | | status | DOWN | | updated_at | 2017-01-01T00:00:00Z | +---------------------+--------------------------------------+ $ openstack server add floating ip rt-server <IP_ADDRESS>
-
SSH to guest.
$ openstack server ssh rt-server --login centos
-
Run
cyclictest
to confirm expected latencies.We’re going to run a intensive process,
stress
, and then usecyclictest
to confirm that guest latencies are within expected limits.$ taskset -c 2 stress --cpu 4
This will result in four processes running on vCPU 2. Once this is running, start
cyclictest
in another tab.$ taskset -c 2 cyclictest -m -n -q -p95 -D 24h -h100 -i 200 > cyclictest.out
This will run for 24 hours (
-D 24h
). Once done, you can check the output (incyclictest.out
) to see if it’s within expected tolerances. The RT Wiki lists some example latencies so you can get an idea of what you can expect.


The Star Tribune annually looks at the compensation of the highest paid CEOs of Minnesota public companies. Last year the 50 executives had total compensation of $433.9 million an increase of 25 percent over the amount they took home the previous year.
Good corporate performance helped 42 of the CEOs earn annual bonuses and a strong stock market in 2017 helped increase the value of long-term equity awards: 17 executives exercised stock options during the past year worth a collective $163.9 million, and 39 of the CEOs realized $138.2 million from the value of restricted stock that vested during the year.


The ApplicationRegistry
service
Method ApplicationRegistry.Create
Create a new application. This also sets the given organization or user as first collaborator with all possible rights.
Request: CreateApplicationRequest
Response: Application
POST
/users/{collaborator.user_ids.user_id}/applications
POST
/organizations/{collaborator.organization_ids.organization_id}/applications
Method ApplicationRegistry.Get
Get the application with the given identifiers, selecting the fields given by the field mask. The method may return more or less fields, depending on the rights of the caller.
Request: GetApplicationRequest
Response: Application
GET
/applications/{application_ids.application_id}
Method ApplicationRegistry.List
List applications. See request message for details.
 To generate an API key, the CreateAPIKey should be used. To delete an API key, update it with zero rights. It is required for the caller to have all assigned or/and removed rights.
Request: UpdateApplicationAPIKeyRequest
Response: APIKey
PUT
/applications/{application_ids.application_id}/api-keys/{api_key.id}
Method ApplicationAccess.GetCollaborator
Get the rights of a collaborator (member) of the application. Pseudo-rights in the response (such as the “_ALL” right) are not expanded.
Request: GetApplicationCollaboratorRequest
Response: GetCollaboratorResponse
GET
/applications/{application_ids.application_id}/collaborator
GET
/applications/{application_ids.application_id}/collaborator/user/{collaborator.user_ids.user_id}
GET
/applications/{application_ids.application_id}/collaborator/organization/{collaborator.organization_ids.organization_id}
Method ApplicationAccess.SetCollaborator
Set the rights of a collaborator (member) on the application. It is required for the caller to have all assigned or/and removed rights. Setting a collaborator without rights, removes them.
Request: SetApplicationCollaboratorRequest
Response: google.protobuf.Empty
PUT
/applications/{application_ids.application_id}/collaborators
Method ApplicationAccess.ListCollaborators
Request: ListApplicationCollaboratorsRequest
Response: Collaborators
GET
/applications/{application_ids.application_id}/collaborators
Messages
Message APIKey
-
id
(string
) -
Immutable and unique public identifier for the API key. Generated by the Access Server.
-
key
(string
) -
Immutable and unique secret value of the API key. Generated by the Access Server.
-
name
(string
) -
max_len
:50
User-defined (friendly) name for the API key.
-
rights
(repeatedRight
) -
defined_only
Rights that are granted to this API key.
Show object example
{
"id": "",
"key": "",
"name": "",
"rights": [],
}
Message APIKeys
-
api_keys
(repeatedAPIKey
)
Show object example
{
"api_keys": [],
}
Message Application
Application is the message that defines an Application in the network.
-
ids
(ApplicationIdentifiers
) -
required
-
created_at
(google.protobuf.Timestamp
) -
updated_at
(google.protobuf.Timestamp
) -
name
(string
) -
max_len
:50
-
description
(string
) -
max_len
:2000
-
attributes
(map ofstring
tostring
) -
contact_info
(repeatedContactInfo
)
Show object example
{
"ids": {},
"created_at": "0001-01-01T00:00:00Z",
"updated_at": "0001-01-01T00:00:00Z",
"name": "",
"description": "",
"attributes": {},
"contact_info": [],
}
Message ApplicationIdentifiers
-
application_id
(string
) -
max_len
:36
pattern
:^[a-z0-9](?:[-]?[a-z0-9]){2,}$
Show object example
{
"application_id": "",
}
Message Applications
-
applications
(repeatedApplication
)
Show object example
{
"applications": [],
}
Message Collaborator
-
ids
(OrganizationOrUserIdentifiers
) -
required
-
rights
(repeatedRight
) -
defined_only
Show object example
{
"ids": {},
"rights": [],
}
Message Collaborators
-
collaborators
(repeatedCollaborator
)
Show object example
{
"collaborators": [],
}
Message CreateApplicationAPIKeyRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
name
(string
) -
max_len
:50
-
rights
(repeatedRight
) -
defined_only
Show object example
{
"application_ids": {},
"name": "",
"rights": [],
}
Message CreateApplicationRequest
-
application
(Application
) -
required
-
collaborator
(OrganizationOrUserIdentifiers
) -
required
Collaborator to grant all rights on the newly created application.
Show object example
{
"application": {},
"collaborator": {},
}
Message GetApplicationAPIKeyRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
key_id
(string
) -
Unique public identifier for the API key.
Show object example
{
"application_ids": {},
"key_id": "",
}
Message GetApplicationCollaboratorRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
collaborator
(OrganizationOrUserIdentifiers
) -
required
Show object example
{
"application_ids": {},
"collaborator": {},
}
Message GetApplicationRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
field_mask
(google.protobuf.FieldMask
)
Show object example
{
"application_ids": {},
"field_mask": {},
}
Message GetCollaboratorResponse
-
ids
(OrganizationOrUserIdentifiers
) -
rights
(repeatedRight
)
Show object example
{
"ids": {},
"rights": [],
}
Message ListApplicationAPIKeysRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
limit
(uint32
) -
lte
:1000
Limit the number of results per page.
-
page
(uint32
) -
Page number for pagination. 0 is interpreted as 1.
Show object example
{
"application_ids": {},
"limit": 0,
"page": 0,
}
Message ListApplicationCollaboratorsRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
limit
(uint32
) -
lte
:1000
Limit the number of results per page.
-
page
(uint32
) -
Page number for pagination. 0 is interpreted as 1.
Show object example
{
"application_ids": {},
"limit": 0,
"page": 0,
}
Message ListApplicationsRequest
-
collaborator
(OrganizationOrUserIdentifiers
) -
field_mask
(google.protobuf.FieldMask
) -
order
(string
) -
Order the results by this field path (must be present in the field mask). Default ordering is by ID. Prepend with a minus (-) to reverse the order.
-
limit
(uint32
) -
lte
:1000
Limit the number of results per page.
-
page
(uint32
) -
Page number for pagination. 0 is interpreted as 1.
Show object example
{
"collaborator": {},
"field_mask": {},
"order": "",
"limit": 0,
"page": 0,
}
Message OrganizationOrUserIdentifiers
OrganizationOrUserIdentifiers contains either organization or user identifiers.
-
organization_ids
(OrganizationIdentifiers
) -
user_ids
(UserIdentifiers
)
ids
: only one of organization_ids
, user_ids
can be set.
Show object example
{
"organization_ids": {},
"user_ids": {},
}
Message Rights
-
rights
(repeatedRight
) -
defined_only
Show object example
{
"rights": [],
}
Message SetApplicationCollaboratorRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
collaborator
(Collaborator
) -
required
Show object example
{
"application_ids": {},
"collaborator": {},
}
Message UpdateApplicationAPIKeyRequest
-
application_ids
(ApplicationIdentifiers
) -
required
-
api_key
(APIKey
) -
required
Show object example
{
"application_ids": {},
"api_key": {},
}
Message UpdateApplicationRequest
-
application
(Application
) -
required
-
field_mask
(google.protobuf.FieldMask
)
Show object example
{
"application": {},
"field_mask": {},
}
Message UserIdentifiers
-
user_id
(string
) -
max_len
:36
pattern
:^[a-z0-9](?:[-]?[a-z0-9]){2,}$
This ID shares namespace with organization IDs.
-
email
(string
) -
Secondary identifier, which can only be used in specific requests.
Show object example
{
"user_id": "",
"email": "",
}


Duplicated arguments may be misspelling in input/output/params/resources/ log/wildcard_constraints sections.


The objective of this article is to provide the reader with a basic instructions on how to customize the dock panel on the default Gnome Ubuntu 18.04 Bionic Beaver desktop.
wfierbfierf ebfuerbfueb uhebfuerb fuyebf uebff ueb fu bfrb fyr furb fuqrbiqh fiq fu buqrbue bfouerb
The objective of this article is to provide the reader with a basic instructions on how to customize the dock panel on the default Gnome Ubuntu 18.04 Bionic Beaver desktop.


NOTE
This page introduces the prototype and allows prototyping of service, to raise and process handovers
Version
Design exploration v5
For user research in June 2018
Launch prototype
Changes made
- Refinded caseheader
- Edit screen, with new placement of description
- Edit screen, Added DWP preferered tabs pattern
- Create customer postcode jobcentre look up
- New user flow for search and then create customer record
Design exploration v4
Version
Design exploration v4
For user research In Halifax and Burnley April 2018
Launch prototype
Changes made
- Added caseheader
- Search
- Create Customer
- Create Handover
Design exploration v3
Version
Design exploration v3
For user research in Sheffield on 11th April 2018
This prototype was produced as direct action from the following user testing
User testing
- Birmingham five ways(05/04/2018)
Launch prototype
Changes made
- Re worked tabs to give them more visual hierarchy on the page
- More detailed history
Design exploration v2
Version
Design exploration v2
For user research in Birmingham on 5 April 2018
This prototype was produced as direct action from the following design review and user testing
Design review
Review screens and comments
Design review images
User testing
- St Helen's(27/02/2018) Am
- Birkenhead(27/02/2018) Pm
- Wrexham(11/03/2018)
- Hyde(12/03/2018)
Launch prototype
Changes made
Allocator screen
Moved time remaining to first column
Added a description column
Added status indicator with the word escalation to the time remaining column to repace salmon pink hi-light row status
Added link to agents queue and number indication of how many handovers an agent has in there queue, also added an availabilty indicator to
the agent column
Edit screen
Added status bar to highlight key information to help the agent deal with the handover
Added tabs to split out the two main functions of the edit screen update/reallocate
Added history to the right hand column which will amalgamate timeline/notes and callback status
Removed redundant information
{% set allocatorScreens = [{
workTitle : 'View agent queue',
links: [{
link : '/queue/agent', title : 'View agent queue - select user'
}]
}] %}
{{ sprintLinks( 'Allocator functions', allocatorScreens) }}
{% set allocatorScreens = [{
workTitle : 'Bulk allocate users to handovers - allocator view',
links: [{
link : '/allocation/esa', title : 'ESA Maintenance Queue - allocate user'
}]
}] %}
{{ sprintLinks( '', allocatorScreens) }}
{% set allocatorScreens = [{
workTitle : 'Bulk allocate users to handovers - user view',
links: [{
link : '/allocation/user', title : 'User queue - before allocation'
},{
link : '/allocationFlow/userQAfter.html', title : 'User queue - after allocation'
}]
}] %}
{{ sprintLinks( '', allocatorScreens) }}
{% set initialScreens = [{
workTitle : 'Customers',
links: [{
link : '/customer/find', title : 'Find customer'
},{
link : '/customer/view', title : 'View customer details'
},{
link : '/customer/summary', title : 'View summary details'
},{
link : '/customer/create?nino=MN121212P', title : 'Create new customer'
},{
link : '/customer/edit?nino=AA123456B', title : 'Edit customer details'
}]
}] %}
{{ sprintLinks( 'Initial Prototype', initialScreens) }}
{% set initialScreens = [{
workTitle : 'Queues',
links: [{
link : '/queue/view?queueType=office', title : 'View office queue'
},{
link : '/queue/view?agentId=' + data.user.staffId, title : 'View my queue'
}]
}] %}
{{ sprintLinks( '', initialScreens) }}
{% set initialScreens = [{
workTitle : 'Handovers',
links: [{
link : '/handover/create?nino=AA123456B', title : 'Create handover'
},{
link : '/handover/view?id=1', title : 'View handover'
},{
link : '/handover/edit?id=1', title : 'Edit handover'
}]
}] %}
{{ sprintLinks( '', initialScreens) }}
{% set initialScreens = [{
workTitle : 'Teams',
links: [{
link : '/team_menu.html', title : 'Team management menu'
},{
link : '/team/user/add', title : 'Add agents to team'
},{
link : '/team/skillset/add', title : 'Add skillsets to team'
},{
link : '', title : 'Create new team [ Function not yet available ]'
},{
link : '', title : 'Edit team details [ Function not yet available ]'
}]
}] %}
{{ sprintLinks( '', initialScreens) }}