Copyright © 2014 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
This module describes, in general terms, the basic structure and syntax of CSS stylesheets. It defines, in detail, the syntax and parsing of CSS - how to turn a stream of bytes into a meaningful stylesheet. CSS is a language for describing the rendering of structured documents (such as HTML and XML) on screen, on paper, in speech, etc.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document was produced by the CSS Working Group as a Candidate Recommendation.
A Candidate Recommendation is a document that has been widely reviewed and is ready for implementation. W3C encourages everybody to implement this specification and return comments to the (archived) public mailing list<EMAIL_ADDRESS>(see instructions). When sending e-mail, please put the text “css-syntax-3” in the subject, preferably like this: “[css-syntax-3] …summary of comment…”
Publication as a Candidate Recommendation does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This specification will not progress to Proposed Recommendation before 20 August 2014. See the section “CR exit criteria” for details.
For changes since the last draft, see the Changes section.
This section is not normative.
This module defines the abstract syntax and parsing of CSS stylesheets
and other things which use CSS syntax (such as the HTML style
attribute).
It defines algorithms for converting a stream of Unicode code points (in other words, text) into a stream of CSS tokens, and then further into CSS objects such as stylesheets, rules, and declarations.
This module defines the syntax and parsing of CSS stylesheets. It supersedes the lexical scanner and grammar defined in CSS 2.1.
This section is not normative.
A CSS document is a series of qualified rules, which are usually style rules that apply CSS properties to elements, and at-rules, which define special processing rules or values for the CSS document.
A qualified rule starts with a prelude then has a {}-wrapped block containing a sequence of declarations. The meaning of the prelude varies based on the context that the rule appears in - for style rules, it’s a selector which specifies what elements the declarations will apply to. Each declaration has a name, followed by a colon and the declaration value. Declarations are separated by semicolons.
A typical rule might look something like this:
p > a { color: blue; text-decoration: underline; }
In the above rule, "p > a
" is the selector, which, if
the source document is HTML, selects any
elements
that are children of a

element.
"color: blue;
" is a declaration specifying that, for the
elements that match the selector, their color property should have the value blue. Similarly, their text-decoration property should have the value
underline.
At-rules are all different, but they have a basic structure in common. They start with an "@" code point followed by their name. Some at-rules are simple statements, with their name followed by more CSS values to specify their behavior, and finally ended by a semicolon. Others are blocks; they can have CSS values following their name, but they end with a {}-wrapped block, similar to a qualified rule. Even the contents of these blocks are specific to the given at-rule: sometimes they contain a sequence of declarations, like a qualified rule; other times, they may contain additional blocks, or at-rules, or other structures altogether.
Here are several examples of at-rules that illustrate the varied syntax they may contain.
@import "my-styles.css";
The @import at-rule is a simple statement. After its name, it takes a single string or url() function to indicate the stylesheet that it should import.
@page :left { margin-left: 4cm; margin-right: 3cm; }
The @page at-rule consists of an optional page selector (the :left pseudoclass), followed by a block of properties that apply to the page when printed. In this way, it’s very similar to a normal style rule, except that its properties don’t apply to any "element", but rather the page itself.
@media print { body { font-size: 10pt } }
The @media at-rule begins with a media type and a list of optional media queries. Its block contains entire rules, which are only applied when the @medias conditions are fulfilled.
Property names and at-rule names are always identifiers, which have to start with a letter or a hyphen followed by a letter, and then can contain letters, numbers, hyphens, or underscores. You can include any code point at all, even ones that CSS uses in its syntax, by escaping it.
The syntax of selectors is defined in the Selectors spec. Similarly, the syntax of the wide variety of CSS values is defined in the Values & Units spec. The special syntaxes of individual at-rules can be found in the specs that define them.
This section is not normative.
Any Unicode code point can be included in an identifier or quoted string by escaping it. CSS escape sequences start with a backslash (\), and continue with:
An identifier with the value "&B" could be written as \26 B or \000026B.
A "real" space after the escape sequence must be doubled.
This section is not normative.
When errors occur in CSS, the parser attempts to recover gracefully, throwing away only the minimum amount of content before returning to parsing as normal. This is because errors aren’t always mistakes - new syntax looks like an error to an old parser, and it’s useful to be able to add new syntax to the language without worrying about stylesheets that include it being completely broken in older UAs.
The precise error-recovery behavior is detailed in the parser itself, but it’s simple enough that a short description is fairly accurate:
User agents must use the parsing rules described in this specification to generate the CSSOM trees from text/css resources. Together, these rules define what is referred to as the CSS parser.
This specification defines the parsing rules for CSS documents, whether they are syntactically correct or not. Certain points in the parsing algorithm are said to be a parse errors. The error handling for parse errors is well-defined: user agents must either act as described below when encountering such problems, or must abort processing at the first error that they encounter for which they do not wish to apply the rules described below.
Conformance checkers must report at least one parse error condition to the user if one or more parse error conditions exist in the document and must not report parse error conditions if none exist in the document. Conformance checkers may report more than one parse error condition if more than one parse error condition exists in the document. Conformance checkers are not required to recover from parse errors, but if they do, they must recover in the same way as user agents.
The input to the CSS parsing process consists of a stream of Unicode code points, which is passed through a tokenization stage followed by a tree construction stage. The output is a CSSStyleSheet object.
Note: Implementations that do not support scripting do not have to actually create a CSSOM CSSStyleSheet object, but the CSSOM tree in such cases is still used as the model for the rest of the specification.
When parsing a stylesheet, the stream of Unicode code points that comprises the input to the tokenization stage might be initially seen by the user agent as a stream of bytes (typically coming over the network or from the local file system). If so, the user agent must decode these bytes into code points according to a particular character encoding.
To decode the stream of bytes into a stream of code points, UAs must use the decode algorithm defined in [ENCODING], with the fallback encoding determined as follows.
Note: The decode algorithm gives precedence to a byte order mark (BOM), and only uses the fallback when none is found.
To determine the fallback encoding:
40 63 68 61 72 73 65 74 20 22 XX* 22 3B
where each The byte sequence above, when decoded as ASCII, is the string "XX
byte is a value between 016 and
2116 inclusive or a value between 2316 and
7F16 inclusive, then get an encoding for
the sequence of XX
bytes, interpreted as
ASCII
.
What does that byte sequence mean?
@charset "…";
", where the
"…" is the sequence of bytes corresponding to the encoding’s label.
If the return value was The bytes of the encoding declaration spell out “ Either way, defaulting to UTF-8 is a decent answer.
As well, this mimics the behavior of HTML’s utf-16be
or
utf-16le
, use utf-8
as the fallback encoding;
if it was anything else except failure, use the return value as the
fallback encoding.
Why use utf-8 when the declaration says
utf-16?
@charset "…";
” in ASCII,
but UTF-16 is not ASCII-compatible. Either you’ve typed in complete
gibberish (like 䁣桡牳整•utf-16be∻
) to get the
right bytes in the document, which we don’t want to encourage, or your
document is actually in an ASCII-compatible encoding and your encoding
declaration is lying.
<meta
charset>
attribute.
Note: Note that the syntax of an encoding declaration looks like the syntax of an @charset rule, but it’s actually much more restrictive. A number of things you can do in CSS that would produce a valid @charset rule, such as using multiple spaces, comments, or single quotes, will cause the encoding declaration to not be recognized. This behavior keeps the encoding declaration as simple as possible, and thus maximizes the likelihood of it being implemented correctly.
utf-8
as the fallback encoding.
Though UTF-8 is the default encoding for the web, and many newer web-based file formats assume or require UTF-8 encoding, CSS was created before it was clear which encoding would win, and thus can’t automatically assume the stylesheet is UTF-8.
Stylesheet authors should author their stylesheets in UTF-8,
and ensure that either an HTTP header (or equivalent method) declares the
encoding of the stylesheet to be UTF-8, or that the referring document
declares its encoding to be UTF-8. (In HTML, this is done by adding a
<meta charset=utf-8>
element to the head of the
document.)
If neither of these options are available, authors should begin the stylesheet with a UTF-8 BOM or the exact characters
@charset "utf-8";
Document languages that refer to CSS stylesheets that are decoded from bytes may define an environment encoding for each such stylesheet, which is used as a fallback when other encoding hints are not available or can not be used.
The concept of environment encoding only exists for compatibility with legacy content. New formats and new linking mechanisms should not provide an environment encoding, so the stylesheet defaults to UTF-8 instead in the absence of more explicit information.
Note: [HTML] defines the
environment encoding for <link rel=stylesheet>
.
Note: [CSSOM] defines the
environment encoding for <xml-stylesheet?>
.
Note: [CSS3CASCADE] defines the
environment encoding for @import
.
The input stream consists of the code points pushed into it as the input byte stream is decoded.
Before sending the input stream to the tokenizer, implementations must make the following code point substitutions:
Implementations must act as if they used the following algorithms to tokenize CSS. To transform a stream of code points into a stream of tokens, repeatedly consume a token until an <EOF-token> is reached, collecting the returned tokens into a stream. Each call to the consume a token algorithm returns a single token, so it can also be used "on-demand" to tokenize a stream of code points during parsing, if so desired.
The output of the tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <unicode-range-token>, <include-match-token>, <dash-match-token>, <prefix-match-token>, <suffix-match-token>, <substring-match-token>, <column-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>.
Note: The type flag of hash tokens is used in the Selectors syntax [SELECT]. Only hash tokens with the "id" type are valid ID selectors.
Note: As a technical note, the tokenizer defined here requires only three code points of look-ahead. The tokens it produces are designed to allow Selectors to be parsed with one token of look-ahead, and additional tokens may be added in the future to maintain this invariant.
This section is non-normative.
This section presents an informative view of the tokenizer, in the form of railroad diagrams. Railroad diagrams are more compact than an explicit parser, but often easier to read than an regular expression.
These diagrams are informative and incomplete; they describe the grammar of "correct" tokens, but do not describe error-handling at all. They are provided solely to make it easier to get an intuitive grasp of the syntax of each token.
Diagrams with names such as <foo-token> represent tokens. The rest are productions referred to by other diagrams.
This section defines several terms used during the tokenization phase.
The algorithms defined in this section transform a stream of code points into a stream of tokens.
This section describes how to consume a token from a stream of code points. It will return a single token of any type.
Consume the next input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, emit a <delim-token> with its value set to the current input code point.
)
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, if the input stream starts with an identifier, reconsume the current input code point, consume an ident-like token, and return it.
Otherwise, if the next 2 input code points are U+002D HYPHEN-MINUS U+003E GREATER-THAN SIGN (->), consume them and return a <CDC-token>.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, this is a parse error. Return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, reconsume the current input code point, consume an ident-like token, and return it.
Otherwise, if the next input code point is U+0073 VERTICAL LINE (|), consume it and return a <column-token>.
Otherwise, return a <delim-token> with its value set to the current input code point.
Otherwise, return a <delim-token> with its value set to the current input code point.
This section describes how to consume a numeric token from a stream of code points. It returns either a <number-token>, <percentage-token>, or <dimension-token>.
If the next 3 input code points would start an identifier, then:
Otherwise, if the next input code point is U+0025 PERCENTAGE SIGN (%), consume it. Create a <percentage-token> with the same representation and value as the returned number, and return it.
Otherwise, create a <number-token> with the same representation, value, and type flag as the returned number, and return it.
This section describes how to consume an ident-like token from a stream of code points. It returns an <ident-token>, <function-token>, <url-token>, or <bad-url-token>.
If the returned string’s value is an ASCII case-insensitive match for "url", and the next input code point is U+0028 LEFT PARENTHESIS ((), consume it. Consume a url token, and return it.
Otherwise, if the next input code point is U+0028 LEFT PARENTHESIS ((), consume it. Create a <function-token> with its value set to the returned string and return it.
Otherwise, create an <ident-token> with its value set to the returned string and return it.
This section describes how to consume a string token from a stream of code points. It returns either a <string-token> or <bad-string-token>.
This algorithm must be called with an ending code point, which denotes the code point that ends the string.
Initially create a <string-token> with its value set to the empty string.
Repeatedly consume the next input code point from the stream:
Otherwise, if the next input code point is a newline, consume it.
Otherwise, if the stream starts with a valid escape, consume an escaped code point and append the returned code point to the <string-token>’s value.
This section describes how to consume a url token from a stream of code points. It returns either a <url-token> or a <bad-url-token>.
Note: This algorithm assumes that the initial "url(" has already been consumed.
Execute the following steps in order:
), then:
Otherwise, this is a parse error. Consume the remnants of a bad url, create a <bad-url-token>, and return it.
This section describes how to consume a unicode-range token. It returns a <unicode-range-token>.
Note: This algorithm assumes that the initial "u+" has been consumed, and the next code point verified to be a hex digit or a "?".
Execute the following steps in order:
If any U+003F QUESTION MARK (?) code points were consumed, then:
Otherwise, interpret the digits as a hexadecimal number. This is the start of the range.
This section describes how to consume an escaped code point. It assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed and that the next input code point has already been verified to not be a newline. It will return a code point.
Consume the next input code point.
This section describes how to check if two code points are a valid escape. The algorithm described here can be called explicitly with two code points, or can be called with the input stream itself. In the latter case, the two code points in question are the current input code point and the next input code point, in that order.
Note: This algorithm will not consume any additional code point.
If the first code point is not U+005D REVERSE SOLIDUS (\), return false.
Otherwise, if the second code point is a newline, return false.
Otherwise, return true.
This section describes how to check if three code points would start an identifier. The algorithm described here can be called explicitly with three code points, or can be called with the input stream itself. In the latter case, the three code points in question are the current input code point and the next two input code points, in that order.
Note: This algorithm will not consume any additional code points.
Look at the first code point:
This section describes how to check if three code points would start a number. The algorithm described here can be called explicitly with three code points, or can be called with the input stream itself. In the latter case, the three code points in question are the current input code point and the next two input code points, in that order.
Note: This algorithm will not consume any additional code points.
Look at the first code point:
Otherwise, if the second code point is a U+002E FULL STOP (.) and the third code point is a digit, return true.
Otherwise, return false.
This section describes how to consume a name from a stream of code points. It returns a string containing the largest name that can be formed from adjacent code points in the stream, starting from the first.
Note: This algorithm does not do the verification of the first few code points that are necessary to ensure the returned code points would constitute an <ident-token>. If that is the intended use, ensure that the stream starts with an identifier before calling this algorithm.
Let result initially be an empty string.
Repeatedly consume the next input code point from the stream:
This section describes how to consume a number from a stream of code points. It returns a 3-tuple of a string representation, a numeric value, and a type flag which is either "integer" or "number".
Note: This algorithm does not do the verification of the first few code points that are necessary to ensure a number can be obtained from the stream. Ensure that the stream starts with a number before calling this algorithm.
Execute the following steps in order:
This section describes how to convert a string to a number. It returns a number.
Note: This algorithm does not do any verification to ensure that the string contains only a number. Ensure that the string contains only a valid CSS number before calling this algorithm.
Divide the string into seven components, in order from left to right:
Return the number s·(i +
f·10-d)·10te
.
This section describes how to consume the remnants of a bad url from a stream of code points, "cleaning up" after the tokenizer realizes that it’s in the middle of a <bad-url-token> rather than a <url-token>. It returns nothing; its sole use is to consume enough of the input stream to reach a recovery point where normal tokenizing can resume.
Repeatedly consume the next input code point from the stream:
The input to the parsing stage is a stream or list of tokens from the tokenization stage. The output depends on how the parser is invoked, as defined by the entry points listed later in this section. The parser output can consist of at-rules, qualified rules, and/or declarations.
The parser’s output is constructed according to the fundamental syntax of CSS, without regards for the validity of any specific item. Implementations may check the validity of items as they are returned by the various parser algorithms and treat the algorithm as returning nothing if the item was invalid according to the implementation’s own grammar knowledge, or may construct a full tree as specified and "clean up" afterwards by removing any invalid items.
The items that can appear in the tree are:
Note: This specification places no limits on what an at-rule’s block may contain. Individual at-rules must define whether they accept a block, and if so, how to parse it (preferably using one of the parser algorithms or entry points defined in this specification).
Note: Most qualified rules will be style rules, where the prelude is a selector [SELECT] and the block a list of declarations.
Declarations are further categorized as "properties" or "descriptors", with the former typically appearing in qualified rules and the latter appearing in at-rules. (This categorization does not occur at the Syntax level; instead, it is a product of where the declaration appears, and is defined by the respective specifications defining the given rule.)
Note: The non-preserved tokens listed above are always consumed into higher-level objects, either functions or simple blocks, and so never appear in any parser output themselves.
Note: The tokens <}-token>s, <)-token>s, <]-token>, <bad-string-token>, and <bad-url-token> are always parse errors, but they are preserved in the token stream by this specification to allow other specs, such as Media Queries, to define more fine-grainted error-handling than just dropping an entire declaration or block.
This section is non-normative.
This section presents an informative view of the parser, in the form of railroad diagrams. Railroad diagrams are more compact than a state-machine, but often easier to read than a regular expression.
These diagrams are informative and incomplete; they describe the grammar of "correct" stylesheets, but do not describe error-handling at all. They are provided solely to make it easier to get an intuitive grasp of the syntax.
The algorithms defined in this section produce high-level CSS objects from lower-level objects. They assume that they are invoked on a token stream, but they may also be invoked on a string; if so, first perform input preprocessing to produce a code point stream, then perform tokenization to produce a token stream.
"Parse a stylesheet" can also be invoked on a byte stream, in which case The input byte stream defines how to decode it into Unicode.
Note: This specification does not define how a byte stream is decoded for other entry points.
Note: Other specs can define additional entry points for their own purposes.
CSSStyleSheet#insertRule
method, and similar functions
which might exist, which parse text into a single rule.
style
attribute, which parses text
into the contents of a single style rule.
media
HTML attribute.
All of the algorithms defined in this spec may be called with either a list of tokens or of component values. Either way produces an identical result.
To parse a stylesheet from a stream of tokens:
To parse a list of rules from a stream of tokens:
To parse a rule from a stream of tokens:
Otherwise, if the current input token is an <at-keyword-token>, consume an at-rule and let rule be the return value.
Otherwise, consume a qualified rule and let rule be the return value. If nothing was returned, return a syntax error.
Note: Unlike "Parse a list of declarations", this parses only a declaration and not an at-rule.
Note: Despite the name, this actually parses a mixed list of declarations and at-rules, as CSS 2.1 does for @page. Unexpected at-rules (which could be all of them, in a given context) are invalid and should be ignored by the consumer.
To parse a list of declarations:
To parse a list of component values:
The following algorithms comprise the parser. They are called by the parser entry points above.
These algorithms may be called with a list of either tokens or of component values. (The difference being that some tokens are replaced by functions and simple blocks in a list of component values.) Similar to how the input stream returned EOF code points to represent when it was empty during the tokenization stage, the lists in this stage must return an <EOF-token> when the next token is requested but they are empty.
An algorithm may be invoked with a specific list, in which case it consumes only that list (and when that list is exhausted, it begins returning <EOF-token>s). Otherwise, it is implicitly invoked with the same list as the invoking algorithm.
Create an initially empty list of rules.
Repeatedly consume the next input token:
Otherwise, reconsume the current input token. Consume a qualified rule. If anything is returned, append it to the list of rules.
Create a new at-rule with its name set to the value of the current input token, its prelude initially set to an empty list, and its value initially set to nothing.
Repeatedly consume the next input token:
Create a new qualified rule with its prelude initially set to an empty list, and its value initially set to nothing.
Repeatedly consume the next input token:
To consume a list of declarations:
Create an initially empty list of declarations.
Repeatedly consume the next input token:
Create a new declaration with its name set to the value of the current input token and its value initially set to the empty list.
Otherwise, consume the next input token.
If the current input token is a <{-token>, <[-token>, or <(-token>, consume a simple block and return it.
Otherwise, if the current input token is a <function-token>, consume a function and return it.
Otherwise, return the current input token.
The ending token is the mirror variant of the current input token. (E.g. if it was called with <[-token>, the ending token is <]-token>.)
Create a simple block with its associated token set to the current input token and with a value with is initially an empty list.
Repeatedly consume the next input token and process it as follows:
Create a function with a name equal to the value of the current input token, and with a value which is initially an empty list.
Repeatedly consume the next input token and process it as follows:
Several things in CSS, such as the :nth-child() pseudoclass, need to indicate indexes in a list. The An+B microsyntax is useful for this, allowing an author to easily indicate single elements or all elements at regularly-spaced intervals in a list.
The An+B notation defines an integer step (A) and offset (B), and represents the An+Bth elements in a list, for every positive integer or zero value of n, with the first element in the list having index 1 (not 0).
For values of A and B greater than 0, this effectively divides the list into groups of A elements (the last group taking the remainder), and selecting the Bth element of each group.
The An+B notation also accepts the even and odd keywords, which have the same meaning as 2n and 2n+1, respectively.
Examples:
2n+0 /* represents all of the even elements in the list */ even /* same */ 4n+1 /* represents the 1st, 5th, 9th, 13th, etc. elements in the list */
The values of A and B can be negative, but only the positive results of An+B, for n ≥ 0, are used.
Example:
-n+6 /* represents the first 6 elements of the list */
If both A and B are 0, the pseudo-class represents no element in the list.
This section is non-normative.
When A is 0, the An part may be omitted (unless the B part is already omitted). When An is not included and B is non-negative, the + sign before B (when allowed) may also be omitted. In this case the syntax simplifies to just B.
Examples:
0n+5 /* represents the 5th element in the list */ 5 /* same */
When A is 1 or -1, the 1
may
be omitted from the rule.
Examples:
The following notations are therefore equivalent:
1n+0 /* represents all elements in the list */ n+0 /* same */ n /* same */
If B is 0, then every Ath element is picked. In such a case, the +B (or -B) part may be omitted unless the A part is already omitted.
Examples:
2n+0 /* represents every even element in the list */ 2n /* same */
Whitespace is permitted on either side of the + or - that separates the An and B parts when both are present.
Valid Examples with white space:
3n + 1 +3n - 2 -n+ 6 +6
Invalid Examples with white space:
3 n + 2n + 2
<an+b>
typeThe An+B notation was originally defined using a slightly different tokenizer than the rest of CSS, resulting in a somewhat odd definition when expressed in terms of CSS tokens. This section describes how to recognize the An+B notation in terms of CSS tokens (thus defining the <an+b> type for CSS grammar purposes), and how to interpret the CSS tokens to obtain values for A and B.
The <an+b> type is defined (using the Value Definition Syntax in the Values & Units spec) as:
<an+b> = odd | even | <integer> | <n-dimension> | '+'?
† n | -n | <ndashdigit-dimension>
| ‘+
’?† <ndashdigit-ident> |
<dashndashdigit-ident>
| <n-dimension> <signed-integer> |
‘+
’?† n <signed-integer> | -n
<signed-integer> |
<ndash-dimension>
<signless-integer> |
‘+
’?† n-
<signless-integer> |
-n- <signless-integer> |
<n-dimension>
[‘+
’ | ‘-
’] <signless-integer>
‘+
’?† n
[‘+
’ | ‘-
’] <signless-integer> |
-n [‘+
’ | ‘-
’]
<signless-integer>
where:
<n-dimension>
is a <dimension-token> with its type flag
set to "integer", and a unit that is an ASCII
case-insensitive match for "n"
<ndash-dimension>
is a <dimension-token> with its type flag
set to "integer", and a unit that is an ASCII
case-insensitive match for "n-"
<ndashdigit-dimension>
is a <dimension-token> with its type flag
set to "integer", and a unit that is an ASCII
case-insensitive match for "n-*", where "*" is a series of one or
more digits
<ndashdigit-ident>
is an <ident-token>
whose value is an ASCII case-insensitive match for
"n-*", where "*" is a series of one or more digits
<dashndashdigit-ident>
is an <ident-token>
whose value is an ASCII case-insensitive match for
"-n-*", where "*" is a series of one or more digits
<integer>
is a <number-token> with its type flag set to
"integer"
<signed-integer>
is a <number-token> with its type flag set to
"integer", and whose representation starts with "+" or "-"
<signless-integer>
is a <number-token> with its type flag set to
"integer", and whose representation start with a digit
†: When a plus sign (+) precedes an ident starting with "n", as in the cases marked above, there must be no whitespace between the two tokens, or else the tokens do not match the above grammar.
The clauses of the production are interpreted as follows:
<integer>
<n-dimension>
'+'? n
-n
<ndashdigit-dimension>
'+'? <ndashdigit-ident>
<dashndashdigit-ident>
<n-dimension> <signed-integer>
'+'? n <signed-integer>
-n <signed-integer>
<ndash-dimension> <signless-integer>
'+'? n- <signless-integer>
-n- <signless-integer>
<n-dimension> ['+' |
'-'] <signless-integer>
'+'? n ['+' | '-'] <signless-integer>
-n ['+' | '-'] <signless-integer>
The Values spec defines how to specify a grammar for properties. This section does the same, but for rules.
Just like in property grammars, the notation <foo>
refers to the "foo" grammar term, assumed to be defined elsewhere.
Substituting the <foo>
for its definition results in a
semantically identical grammar.
Several types of tokens are written literally, without quotes:
:
), <comma-token> (written as
,
), <semicolon-token> (written as
;
), <(-token>, <)-token>, <{-token>, and <}-token>s.
Tokens match if their value is an ASCII case-insensitive match for the value defined in the grammar.
Although it is possible, with escaping, to construct an <ident-token>
whose value ends with (
or starts with @
, such a
tokens is not a <function-token> or an <at-keyword-token> and does not match
corresponding grammar definitions. <delim-token>s are written with their
value enclosed in single quotes. For example, a <delim-token>
containing the "+" code point is written as '+'
.
Similarly, the <[-token> and <]-token>s must be written in
single quotes, as they’re used by the syntax of the grammar itself to
group clauses. <whitespace-token> is never indicated
in the grammar; <whitespace-token>s are allowed
before, after, and between any two tokens, unless explicitly specified
otherwise in prose definitions. (For example, if the prelude of a rule is
a selector, whitespace is significant.)
When defining a function or a block, the ending token must be specified in the grammar, but if it’s not present in the eventual token stream, it still matches.
translateX( <translation-value> )
However, the stylesheet may end with the function unclosed, like:
.foo { transform: translate(50px
The CSS parser parses this as a style rule containing one declaration, whose value is a function named "translate".
The CSS parser is agnostic as to the contents of blocks, such as those that come at the end of some at-rules. Defining the generic grammar of the blocks in terms of tokens is non-trivial, but there are dedicated and unambiguous algorithms defined for parsing this.
The <declaration-list> production represents a list of declarations. It may only be used in grammars as the sole value in a block, and represents that the contents of the block must be parsed using the consume a list of declarations algorithm.
Similarly, the <rule-list> production represents a list of rules, and may only be used in grammars as the sole value in a block. It represents that the contents of the block must be parsed using the consume a list of rules algorithm.
Finally, the


There's no difference between websockets pipes and the regular pipes.
The only thing you should be aware of is that instead of throwing HttpException
, you should use the WsException
.
Hint TheWsException
class is available within the@nestjs/websockets
package.


--- layout: post title: What are the different ways to run PHP on Web Server? date: 2016-01-08 09:00:00.000000000 +08:00 permalink: different-ways-to-run-php-on-webserver/ header-img: "img/21182965596_7020848dac_k.jpg" subtitle: "Web Servers themselves cannot understand and parse PHP files, the external programs to do it for them. There are many ways how you can do this, both with its pros and cons." categories: - php - devops ---
For developers, there is not much difference whatever PHP handler is executing their application in the web server. It simply works!. But for System Administrator view, there are wide array of options to choose from. Depending on the nature of the site, you might pick one over the other. Here is my opinionated view of what I think is the different strength and weakness of each PHP handlers:
| Web Server | PHP Handler | Memory | CPU | Security | Speed | Run as Owner |
|---|---|---|---|---|---|---|
| Apache Only | mod_php | Low | Low | Low | Fast | No |
| CGI | Low | High | Low | Slow | No | |
| SuPHP | Low | High | High | Slow | Yes | |
| Nginx / Apache | FastCGI | High | Low | High | Fast | Yes |
| PHP-FPM | High | High | High | Fast | Yes | |
| HHVM | Very High | Very High | High | Very Fast | Yes |
Before we even go further, lets mention this very important issue that haunts down every developers on earth:
The file permission hell: Have you ever been into situation wherein you cannot access your files via FTP/SSH because its somewhat "owned" by the web server itself. For example, files uploaded through the website. This is because Web servers usually runs on another user other than yours. For example, usually Apache user is "www-data", while your FTP account might be "bob". Two different users accessing same set of files causes a lot of headaches when you are using for example CMS like WordPress, which writes files into the server.
On the following section, I'll try to elaborate the table above by mentioning special points like Pros, Cons and Bottomlines.
mod_php is ideal for situations where resources is very limited and security is not much of concern. For example running a web server for LAN connection in a very old computer with limited memory.
While it is able to solve the file permission issues associated with mod_php, it does that though by sacrificing some speed.
since the PHP scripts is being run as a different user. Any vulnerability in the site can be restricted to only the files of your website thereby providing substantial security benefits particularly on servers that run multiple websites. This is great for multi-tenant hosting wherein you need to isolate each customers from each other.
FastCGI speed comes with large memory usage. This might be significant when speed is important given that you had the money to feed it with memory.
PHP-FPM might be ideal if you have a VPS or a dedicated server. In the shared hosting though, you can quickly ran out your quota, due to the large memory and cpu consumption it would take compared to just plain apache+mod_php.
HHVM is good for very high volume traffic wherein every millisecond matters. But unless you have some really good experience with rolling your own server, finding hosting provider that has enough experience with this technology might be a tough one.
There it is, its crazy to think that behind the seemingly simple LAMP stack, there is tons of fuzzy things going on at the back. Depending on many factors, you might choose to shuffle any combination of this, given the use-case and situation you are currently in.


Creating SQL Statements from form definitions
I had an iteresting discussion with a customer this week. They use Domino and dotNet for their web applications. Their decission criteria when to use what: if the data of the application needs to be fed into their data warehouse at a later point of time, they use dotNet since storage there typically ends up in an RDBMS. The biggest problem they face, in their own voice: " Our users are pretty spoiled from Domino. They expect days as turnaround time for applications. Using dotNet it takes at least three times longer."
So I asked why they don't use DECS to connect to the RDBMS. They could develop the application in Notes/Domino and once the app does what the user wants just add the tables in the RDBMS and link them up using DECS. They asked back if there is a way to generate the table or at least the create table statement from Domino directly. The short answer: Yes, you can, however you need to make decissions on datatypes and field length. The long answer: you need Domino Designer (for the Tools - DXL Utilities - Transformer ... menu) and a little XSLT stylesheet.
So I asked why they don't use DECS to connect to the RDBMS. They could develop the application in Notes/Domino and once the app does what the user wants just add the tables in the RDBMS and link them up using DECS. They asked back if there is a way to generate the table or at least the create table statement from Domino directly. The short answer: Yes, you can, however you need to make decissions on datatypes and field length. The long answer: you need Domino Designer (for the Tools - DXL Utilities - Transformer ... menu) and a little XSLT stylesheet.
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
</xsl:stylesheet>
<xsl:output xmlns:xml="http://www.w3.org/XML/1998/namespace" method="text" version="1.0" encoding="UTF-8" xml:space="preserve" omit-xml-declaration="yes"> </xsl:output>
<xsl:template match="/">
</xsl:template>
<!-- We only look at forms for the time being, when I have enough time I add basic support for subforms, at least the fixed ones -->
<xsl:apply-templates select="//d:form"> </xsl:apply-templates>
<xsl:template match="d:form">
CREATE TABLE
</xsl:template>
<xsl:value-of select="$formName"> </xsl:value-of>
( DocID CHAR(32) NOT NULL,
<xsl:apply-templates select="//d:field[@kind!='computedfordisplay']"> </xsl:apply-templates>
PRIMARY KEY (DocID));
<!-- Here we do map the various field types. You want to revisit the form -->
<xsl:template match="d:field">
</xsl:template>
<xsl:value-of select="@name"> </xsl:value-of>
<!-- Sample of a specia case consideration for number fields -->
<xsl:template match="d:field[@type='number']">
</xsl:template>
<xsl:value-of select="@name"> </xsl:value-of>
<xsl:choose>
</xsl:choose>
<xsl:when test="d:numberformat/@format='fixed'">
DECIMAL(31,
</xsl:when>
<xsl:value-of select="d:numberformat/@digits"> </xsl:value-of>
),
<!-- Generated with xml2html.xslt, Linkwerk.com -->
Posted by Stephan H Wissel on 10 April 2008 | Comments (7) | categories: Blog Show-N-Tell Thursday


|
JMovies.IMDb
|
Data provider interface that Scraper implements. This interface can be safely used for Dependency Injection. More...
Public Member Functions | |
| Production | GetProduction (long id) |
| Gets Production Information iresspective of type using the default settings. | |
| Task< Production > | GetProductionAsync (long id) |
| Gets Production Information iresspective of type using the default settings. | |
| Movie | GetMovie (long id) |
| Gets Movie information using the default settings. | |
| Task< Movie > | GetMovieAsync (long id) |
| Gets Movie information using the default settings. | |
| TVSeries | GetTvSeries (long id) |
| Gets TV Series information using the default settings. | |
| Task< TVSeries > | GetTvSeriesAsync (long id) |
| Gets TV Series information using the default settings. | |
| Production | GetProduction (long id, ProductionDataFetchSettings settings) |
| Gets Production Information iresspective of type. | |
| Task< Production > | GetProductionAsync (long id, ProductionDataFetchSettings settings) |
| Gets Production Information iresspective of type. | |
| Movie | GetMovie (long id, ProductionDataFetchSettings settings) |
| Gets Movie information. | |
| Task< Movie > | GetMovieAsync (long id, ProductionDataFetchSettings settings) |
| Gets Movie information. | |
| TVSeries | GetTvSeries (long id, ProductionDataFetchSettings settings) |
| Gets TV Series information. | |
| Task< TVSeries > | GetTvSeriesAsync (long id, ProductionDataFetchSettings settings) |
| Gets TV Series information. | |
| Person | GetPerson (long id, PersonDataFetchSettings settings) |
| Gets Person information. | |
| Task< Person > | GetPersonAsync (long id, PersonDataFetchSettings settings) |
| Gets Person information. | |
| Person | GetPerson (long id) |
| Gets Person information using the default settings. | |
| Task< Person > | GetPersonAsync (long id) |
| Gets Person information using the default settings. | |
Data provider interface that Scraper implements. This interface can be safely used for Dependency Injection.
| Movie JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetMovie | ( | long | id | ) |
Gets Movie information using the default settings.
| id | ID of the movie |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Movie JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetMovie | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets Movie information.
| id | ID of the movie |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Movie > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetMovieAsync | ( | long | id | ) |
Gets Movie information using the default settings.
| id | ID of the movie |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Movie > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetMovieAsync | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets Movie information.
| id | ID of the movie |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Person JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetPerson | ( | long | id | ) |
Gets Person information using the default settings.
| id | ID of the Person |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Person JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetPerson | ( | long | id, |
| PersonDataFetchSettings | settings | ||
| ) |
Gets Person information.
| id | ID of the Person |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Person > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetPersonAsync | ( | long | id | ) |
Gets Person information using the default settings.
| id | ID of the Person |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Person > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetPersonAsync | ( | long | id, |
| PersonDataFetchSettings | settings | ||
| ) |
Gets Person information.
| id | ID of the Person |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Production JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetProduction | ( | long | id | ) |
Gets Production Information iresspective of type using the default settings.
| id | ID of the production |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Production JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetProduction | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets Production Information iresspective of type.
| id | ID of the production |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Production > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetProductionAsync | ( | long | id | ) |
Gets Production Information iresspective of type using the default settings.
| id | ID of the production |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< Production > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetProductionAsync | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets Production Information iresspective of type.
| id | ID of the production |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| TVSeries JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetTvSeries | ( | long | id | ) |
Gets TV Series information using the default settings.
| id | ID of the TV Series |
| TVSeries JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetTvSeries | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets TV Series information.
| id | ID of the TV Series |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< TVSeries > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetTvSeriesAsync | ( | long | id | ) |
Gets TV Series information using the default settings.
| id | ID of the TV Series |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.
| Task< TVSeries > JMovies.IMDb.Entities.Interfaces.IIMDbDataProvider.GetTvSeriesAsync | ( | long | id, |
| ProductionDataFetchSettings | settings | ||
| ) |
Gets TV Series information.
| id | ID of the TV Series |
| settings | Object containing Data Fetch settings |
Implemented in JMovies.IMDb.Providers.IMDbScraperDataProvider.


ORFK wrote:there is an other plugin wich allowed you more possibilities... http://getbblog.com/viewtopic.php?f=22&t=566" target="_blank" rel="nofollow" target="_blank" rel="nofollow


NINJA SCROLL
Review by John Beachem
* * * * *
Directed by: Yoshiaki Kawajiri Written by: Yoshiaki Kawajiri
On a storm filled night in feudal Japan, the eight devils of Kimon ride into a small village, apparently bringing a plague with them. The devils are elite mercenaries, each with a special and unique power (one controls bees, one electricity, etc.). When all the villagers are killed, the local lord sends twenty ninja to investigate the event. They are all wiped out by one of the devils, save Kagero, the poison tester. She alone survives and is saved by Jubei, a wandering Ninja for hire. Now Jubei and Kagero have called the wrath of the devils down upon them, and the only way to survive will be to team up with a government spy named Dakuan. The three must travel to the plague filled village, find out who is behind the deaths, and stop them. Along the way they will be challenged by the eight devils and a legion of ninja, all led by an enemy from Jubei's past.
I know that's a short plot summary, but I don't want to give anything else away. It wouldn't take much to convince me that Yoshiaki Kawajiri's ("Wicked City") "Ninja Scroll" is the greatest anime (Japanese animation) ever created. Granted, I haven't seen a great many anime; I haven't even seen the much discussed "Princess Monoke"; but of the two dozen or so I've seen, nothing has even come close to the magnificence of "Ninja Scroll". A lot of what makes the film so great is that Kawajiri puts more effort and detail into his animated characters than most Hollywood directors put into their live ones. This effort, combined with incredible animation, an intriguing story, and some of the best action scenes ever (animated or otherwise) make "Ninja Scroll" one of, if not the best action movie of the past decade. Yet despite all the praise I heap on this wonderful movie, the sad fact of the matter is I can't do it justice. You'll have to see it for yourself to fully appreciate the film. However, be forewarned, this isn't a movie for everyone. "Ninja Scroll" is graphic in both sexual matters and carnage. If you don't feel you can handle these elements, steer clear.
Normally I'd devote this paragraph to a critique of the acting, but there obviously is none in "Ninja Scroll". Instead, I'm going to briefly discuss a few of the characters, and what makes them so interesting. I'll start with Jubei, one of the most carefully crafted and interesting action heroes ever to grace the screen. Jubei is made so interesting because he isn't exactly your classic hero. He's a mercenary ninja, working for the highest bidder. Does that mean he has no honor? Quite the opposite actually.  He's good, but he's not indestructible. He gets pasted in a few fights, knocked around, bloodied, bruised, and occasionally only winning through luck or the intervention of someone else. Does this make him less of a hero? No, it makes him more of one because it makes him more human. Jubei feels pain and anguish, and he's so eloquently crafted that we start to believe he's really feeling these emotions and isn't just some animated character. Take, for example, a scene in which Jubei is recovering from fighting one of the devils. He is in a pond, cleaning his wounds. He pulls a tooth out, washes blood out of his mouth, and generally looks a mess. In your typical action film the hero takes a beating and is ready to go in five minutes. You never see Hollywood action heroes nursing their wounds, because they're invincible.
Kagero, the proud female ninja could easily have been nothing more than a caricature, but Kawajiri never allows this to happen. She's brash, head-strong, and always seems to have something to prove, but these attributes never feel like cliches. They feel more like a shield she puts up, and it occasionally breaks down.  After the rescue, Kagero acts like nothing happened, brushes Jubei off, and leaves to continue her mission. Yet once Jubei's back is turned she suddenly snaps as the full force of what just happened hits her like a ton of bricks. It's a great, moving scene; made even better by the fact that even though we've just met her, we already care about Kagero. Finally we have Dakuan, the old spy. Dakuan is mainly used for comic relief, but what a great comic character he is. I particularly loved a scene where he displays his own special ability, and one where Jubei leaves him to search for Kagero. He gets a great little speech in the latter about becoming a monster to fight one.
Obviously one of the most important elements to a movie like "Ninja Scroll" is the animation quality, and I assure you this movie possesses the very best. The animation is so crisp, so realistic, that you'll want to re-watch it once with the sound off so you can focus entirely on the film's beauty. I'm not just talking about how well the characters are drawn either. There are scenes where the backgrounds are so well drawn you'd swear this was real life. Scenes that stand out in my mind are one where Jubei climbs a cliff to get a better look at the area; an early fight on a wooden bridge right before a storm; and two characters talking in a marsh, surrounded by fireflies. It's too bad animated films can't win awards for cinematography. The fights are just as perfectly constructed. There's one at the start of the film, between a group of ninja and one of the devil of Kimon where they spot him, and fling a horde of throwing stars at him. Kawajiri actually shows each individual star slamming into the trees, and each star's strike looks different from the others (I know, I sat there and examined them).
So, now that I've raved about it for some time, you're no doubt wondering if "Ninja Scroll" is perfect. I'm afraid not, but the only flaw I can think of is that it's just a little too short. This causes a few of the scenes to feel a bit rushed. For example, a brilliant sword fight in a bamboo forest between Jubei and a blind warrior would have been even better if it hadn't been only a minute long. Despite that, there are two things which elevate "Ninja Scroll" above almost every other animated film I've ever seen. One is Kawajiri's attention to detail, the other is his labyrinth of a story. I never really took notice of his attention to detail till the last time I saw the film and noticed something interesting. In one scene, Jubei's shirt gets cut on the sleeve by one of the devils of Kimon. In all future scenes, Kawajiri makes certain that cut is always present on the same sleeve, and that it's the same size cut. His script is full of surprises, including characters dying when you don't expect them to and people turning out not to be who you thought they were. The movie runs a quick 94 minutes, and I do wish it had been made longer. Oh well, can't have everything. I'd recommend "Ninja Scroll" to any fan of anime, but make sure you get an uncut, subtitled version (the dubbed version is terrible; Jubei sounds like Captain America). I give it a full five out of five stars.
Comments? Send to<EMAIL_ADDRESS>Past reviews can be found at: http://www.epinions.com/user-elerad or http://us.imdb.com/ReviewsBy?John+Beachem
* * * * * - One of the best movies of the year. * * * * - Great flick, try and catch this one. * * * - Okay movie, hits and misses. * * - Pretty bad, see it at your own risk. * - See this one only if you enjoy pain.
Share information about yourself, create your own public profile at http://profiles.msn.com.
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


Dear {0},
our system generated new password for you:
Your password:
{1}
Please log into Kickshare and
change your password
Kickshare


LEGISLATIVE ASSEMBLY OF ONTARIO
ASSEMBLÉE LÉGISLATIVE DE L’ONTARIO
Monday 12 September 2016 Lundi 12 septembre 2016
Speech from the throne / Discours du trône
Resignation of member for Ottawa–Vanier
The first day of the second session of the 41st Parliament of the province of Ontario commenced at 1200 pursuant to a proclamation of Her Honour Elizabeth Dowdeswell, Lieutenant Governor of the province.
Her Honour the Lieutenant Governor was pleased to open the session by reading the speech from the throne.
Hon. Elizabeth Dowdeswell (Lieutenant Governor): Mr. Speaker, honourable members, ladies and gentlemen, people of Ontario:
As the representative of Her Majesty the Queen, it is my honour to open the second session of the 41st Parliament by delivering the speech from the throne.
En ma qualité de représentante de Sa Majesté la Reine, j’ai l’honneur d’ouvrir la deuxième session de la 41e législature de l’Ontario en présentant le discours du trône.
I begin by acknowledging the rich and enduring history of indigenous peoples in Ontario.
At this sacred gathering place for many peoples of Turtle Island, the elected representatives of Ontarians assemble to help guide and shape the future of the province we share.
To show our respect for the history and contributions of indigenous peoples in Ontario, I give acknowledgment to the fact that we come together today on the traditional territory of many indigenous nations with special recognition to the Mississaugas of the New Credit First Nation.

Your government remains committed to building Ontario up in a way that helps you in your everyday lives.
Votre gouvernement maintient son engagement à faire progresser l’Ontario d’une manière qui vous aide dans la vie quotidienne.
By choosing to invest in better infrastructure, stronger pensions, improved skills training and a competitive business climate, your government has made meaningful progress.
Over the last two years, Ontario’s economy has grown by 6.1%.
Last year, growth was double the national average.
In the first quarter of this year, our growth was faster than that of the United States and the G7.
Almost 600,000 net new jobs have been created since the depths of the last recession.
Unemployment this year has reached an eight-year low.
These statistics are heartening. But they don’t tell the whole story.
Our economy remains in transition. The world grows ever more competitive. While many across our province are benefiting from growth, challenges remain.
Some have yet to share in Ontario’s resurgence.
Your government’s top priority will therefore remain job creation and economic growth—and to make sure that everyone shares in the prosperity we are building together.
Because good jobs and economic growth mean you can support your family and our communities can thrive.
Your government is committed to its balanced plan, which has helped to grow Ontario’s economy.
It is a plan to strengthen our economic foundation in a way that benefits everyone.
It is a plan to build Ontario up in a way that is responsible and sustainable—both financially and environmentally.
Three years ago, your government recommitted to eliminating the deficit by 2017-18.
It will make good on this commitment.
Next year’s budget will be a balanced budget.
Le budget de l’an prochain sera un budget équilibré.
Your government made a choice to not cut its way to balance.
It did not sacrifice the public services on which so many rely.
Nor did it increase the HST or increase personal income taxes for the middle class.
Instead, your government chose a balanced approach to eliminate the deficit.
Ontario’s debt-to-GDP ratio is levelling and will start to decline—a sign of economic strength and fiscal responsibility.
This will give businesses further confidence that the province’s economic plan is working—and that Ontario is a good place to invest and create jobs.
With economic growth and a balanced budget, your government will continue to build Ontario up, investing in the things that matter most to you and that help you in your everyday life.
It will do this, first, by enhancing child care.
Every child deserves to have the best start in life.
Over the past three years, the government has helped to create 56,000 new licensed child care spaces.
Within the next five years, it will help to create another 100,000 spaces, so that working families can find quality, affordable care.
Au cours des cinq prochaines années, votre gouvernement contribuera à la création de 100 000 places en service de garde agréé, aidant ainsi les parents qui travaillent à profiter de services abordables et de qualité.
Your government will also make it easier for parents to find and use the services their children need, whether they are before-and-after-school programs, drop-in centres or more licensed child care spaces.
Community hubs are creating spaces for expanded child care and child and family support services, as well as helping to make it easier to access health, social, education, cultural and recreational programs and services that nurture community life.
Second, your government will continue to invest in education to help students achieve their full potential and successfully compete in a global economy.
Every person in Ontario deserves an excellent education, from kindergarten through to postsecondary.
Your government is strengthening what is already one of the best education systems in the world, working collaboratively with our partners across the education sector.
It will continue to invest to make the classroom and school experience a positive one for all students, teachers and staff.
It is building and renovating schools.
Today, more students are graduating from high school in our province than ever before.
Your government is committed to making sure students have the excellent literacy and numeracy skills they need to succeed.
To help students improve their mathematics skills, your government is implementing a renewed math strategy, including having up to three math lead teachers in all elementary schools.
It is also setting a goal for every young person to have at least one opportunity for experiential learning.
At the postsecondary level, your government is building new campuses and modernizing old labs—helping Ontario students to get the best possible start in their adult lives.
Your government believes that for the next generation to have more opportunities in life than their parents, an advanced education should be attainable for all who qualify, regardless of family income.
That’s why it chose to create the new Ontario Student Grant.
It will help thousands of students obtain greater access to advanced education and have lower levels of student debt upon graduation.
For students from lower-income and many middle-income families, it would make the tuition portion of the average postsecondary experience absolutely free.
Dans le cas des étudiantes et des étudiants issus de familles à revenu faible ou moyen, la Subvention ontarienne d’études rendra absolument gratuits les frais de scolarité pour la majorité des programmes d’études postsecondaires.
Your government will also continue to help young people find their way in the working world.
In the last three years, Ontario’s Youth Jobs Strategy has created thousands of job opportunities.
Your government is also helping more young people to transform their good ideas into promising start-ups—through campus-linked accelerators, incubators and a range of support for entrepreneurs.
Third, your government will invest in skills training that aligns with the job market of today and tomorrow.
People who want to upgrade their skills should expect help from their employer and from government.
Your government will work with industry, unions and educators to develop new skills training projects, guided by the recommendations of the Highly Skilled Workforce Expert Panel.
These projects will help people gain the skills they need to get a good job and will ensure Ontario retains the competitive advantage of having a workforce with the skills employers want and need.
Fourth, your government will strengthen our health care system.
Every person in our province deserves high-quality public health care.
Ninety-four per cent of Ontarians now have a primary health care provider, such as a family doctor or nurse practitioner.
Since 2013, seven new hospitals have been built in five communities. Over the next five years, 18 more hospitals across Ontario will complete major renovations or rebuilds, and approximately 20 more major projects will get under way.
In 2014-15, there were over 2,200 more nurses employed in Ontario, thanks in large part to investments from your government.
Today, 170,000 more seniors can benefit from a program that reduces their out-of-pocket costs for prescription drugs. And 30,000 more will qualify for this program every year.
These investments will make a real difference in the lives of the people you love who require care.
Through its indigenous health action plan, your government will ensure that no segment of Ontario’s population is left behind.
It believes that additional resources for health care should be directed where they will help patients most: at the front line—not only to the highest-billing physicians or highly paid administrators.
Your government recognizes that many of you are caring for parents and other family members who want to stay home as they grow older.
So it is helping families by adding an estimated 350,000 hours of nursing care and 1.3 million hours of personal support, enhancing home care for those who need it.
The wait times to see a specialist will be reduced further.
Personal support workers are getting the pay hike your government committed to and that they deserve.
And your government will deliver on its primary care guarantee—connecting a family doctor or nurse practitioner to everyone who wants one.
Fifth, your government will invest in roads, transit and modern infrastructure, as part of the largest infrastructure investment in the province’s history—about $160 billion over 12 years.
New and upgraded transportation infrastructure is essential to improve the quality of our communities and your quality of life, every day.
Il est crucial de bâtir et d’améliorer l’infrastructure du transport afin d’assurer une meilleure qualité de vie dans nos communautés ainsi que la qualité de votre vie quotidienne.
Over the next five years, about 5,000 kilometres of highways will be built or repaved—and more than 750 bridges will be built, repaired or rebuilt.
About 2,400 kilometres of these highways and 200 of these bridges will be in northern Ontario.
Your government will continue to work with First Nations and other partners to move forward with greater access to the Ring of Fire and remote First Nation communities.
In urban areas, your government is investing in more than 350 kilometres of new rapid transit over the next decade.
Light rapid transit systems will be built in Waterloo, Hamilton, Mississauga, Ottawa and Toronto.
The GO system will be transformed with regional express rail, which will quadruple the number of weekly trips from about 1,500 to nearly 6,000.
This means fewer emissions and a better commuter experience, even as Ontario’s population increases.
Sixth, your government will continue building a competitive business environment, driven increasingly by innovative, low-carbon industries that support growing the economy and creating good jobs—your government’s number-one priority.
La plus haute priorité de votre gouvernement est de promouvoir la croissance économique et la création de bons emplois.
So it will work to attract new businesses and the good jobs they bring.
The Premier and ministers will continue leading trade missions to priority markets around the world.
And build on the Ontario advantage with the Business Growth Initiative.
The Red Tape Challenge will continue to help businesses save time and money.
Your government will work with businesses that have the greatest growth prospects, helping them develop the tools they need to win new business at home or overseas.
It will help farmers meet the Premier’s agri-food challenge with dedicated trade missions and new measures to reduce their energy costs.
With the Jobs and Prosperity Fund, the province is building important strategic partnerships with job-creating businesses.
With farmers and processors. Foresters and programmers. Entrepreneurs and manufacturers.
These partnerships mean good, well-paying jobs here in Ontario.
The Jobs and Prosperity Fund has helped strengthen Ontario’s key sectors, including the automotive industry—which employs tens of thousands of highly skilled Ontario workers.
And now, these workers have the opportunity to help invent the cars of the future—connected, autonomous cars and electric vehicles.
Your government will partner with manufacturers and automakers to attract new mandates and the next generation of advanced manufacturing and engineering talent.
By building an innovative, low-carbon and low-tax business environment, Ontario is attracting new investments from around the world.
Ontario has established itself as a leader in reducing greenhouse gas emissions and embracing the opportunities of a low-carbon economy.
Closing Ontario’s coal-fired electricity plants remains North America’s single-largest and most effective climate-change initiative—ever.
Important investments have made Ontario’s electricity system clean and reliable, and have created good jobs.
Ontario’s leadership helped support the agreement the world reached this past December at the Paris climate conference.
In Paris and here at home, your government worked in partnership with Canada’s new Prime Minister and his team to make real progress on measures to combat climate change.
Ontario recently signed a joint declaration with Quebec and Mexico, committing to working together to fight climate change and drive progress on carbon markets as Mexico pilots a cap and trade system.
Next year, Ontario’s new cap and trade program will begin delivering benefits.
Cap and trade proceeds will be transparently invested in greenhouse gas reduction projects and incentives that will help Ontario households and businesses further reduce emissions.
Le produit du régime de plafonnement et d’échange sera investi de façon transparente dans des projets et des mesures d’encouragement qui aideront les ménages et les entreprises de l’Ontario à réduire davantage leurs émissions de gaz à effet de serre.
Through the choices your government is making, Ontario will continue to fight climate change and grow the economy.
Seventh, your government will continue to play a leadership role to improve your retirement income security.
You deserve to look forward to the future with confidence, knowing you can retire with dignity.
For years, Ontario has been fighting for a solution to the coming crisis in retirement security.
Without action, many of today’s workers would be facing a retirement defined by financial insecurity and worry.
Your government made a choice to take a national leadership role on this issue.
Then it worked to achieve consensus.
And Canada’s finance ministers reached an agreement to bolster the Canada Pension Plan—to pay out more in benefits as a reward for a lifetime of hard work.
Your government will continue to work with its federal and provincial partners to ensure the CPP delivers a better retirement for the people of Ontario.
Votre gouvernement continuera de travailler avec ses partenaires provinciaux afin que le Régime de pensions du Canada offre une retraite plus confortable aux Ontariennes et aux Ontariens.
Eighth, your government will deliver additional relief on electricity bills.
Over the course of the past decade, Ontario electricity ratepayers have helped cover the costs associated with removing dirty coal-fired generation from our electricity system.
And while these investments have resulted in increased costs associated with generation, they have also created savings of more than $4 billion a year in health and other costs associated with smog and pollution from coal-fired generation.
Your government has been dedicated to reducing electricity costs wherever possible, while maintaining reliability for all consumers.
It renegotiated the green energy investment agreement, reducing contract costs by $3.7 billion.
Plans to extend the operation of the Pickering nuclear generating stations are expected to save customers as much as $600 million.
The introduction of the large renewable procurement process, annual renewable energy price reviews and revised procurement schedules are expected to reduce costs by a further $4.1 billion as compared to previous forecasts.
Your government has removed the debt retirement charge from residential electricity bills, made electricity more affordable for low-income families through the Ontario Electricity Support Program and is investing over $2.6 billion between 2015 and 2020 to help homeowners and businesses reduce energy use to save money.
Despite these efforts, you continue to face electricity cost increases above the level of inflation.
Whether in Kenora, Sudbury, Belleville, London or Barrie, your government has listened to and has heard your concerns. It recognizes that the cost of electricity is now stretching family budgets.
It will therefore act on an idea it has heard from many individuals and groups.
Your government will introduce legislation that would rebate—directly on consumers’ residential electricity bills—an amount equal to the provincial portion of the harmonized sales tax, an 8% savings.
The rebate would go into effect on January 1, 2017.
Votre gouvernement déposera un projet de loi visant à rembourser—directement à partir de la facture mensuelle d’électricité des consommateurs résidentiels—la portion provinciale de la taxe de vente harmonisée, qui est de 8 %. Cette remise entrerait en vigueur le 1er janvier 2017.
Small businesses would also receive the rebate.
Additionally, in recognition of the unique and special circumstances associated with the electricity cost-of-service for rural ratepayers, the existing rural support program would be significantly enhanced to provide even more on-bill savings for Ontario’s eligible rural customers.
Eligible rural customers would receive these additional savings, which would result in an on-bill monthly saving of about 20%—approximately $45 a month.
Your government also intends to implement new measures to ensure that Ontario commercial and industrial ratepayers can also benefit from lower electricity costs.
Since 2011, the industrial conservation initiative has encouraged large electricity users—primarily large industrial customers—to take on-site steps to shift consumption away from peak periods and lower their electricity costs by up to one third.
To benefit more businesses, your government will expand eligibility for the industrial conservation initiative by lowering the threshold for participation and broadening participation to all sectors.
At the same time, conservation programs delivered by local distribution companies, supported by the Independent Electricity System Operator, will continue to provide significant programs tailored to specific business classes and needs.
When fully implemented, participating industrial customers will be able to find cost savings of up to 34%, depending on their ability to reduce peak electricity consumption.
With these proposed measures, your government will deliver significant on-bill savings for all electricity customers.
In addition to introducing legislation to provide relief on electricity bills, your government will move forward this session with other legislative priorities.
This week, your government intends to reintroduce election finance reform legislation, with all the amendments agreed to at the committee stage prior to the prorogation of the Legislature. It also intends to move amendments during the committee stage of the bill to prohibit MPPs in all parties from attending fundraising events.
Your government will also reintroduce, this fall, all other government bills that were before the Legislature prior to prorogation, so that debate on them can continue.
New legislation your government intends to introduce includes measures to strengthen Ontario’s health care and education systems, ensure parental recognition and regulate home inspectors.
As this new session begins, Ontario stands strong within the Canadian federation.
Our next provincial budget will be in balance.
Your government is actively working with the new federal government to deliver real benefits for Ontarians, such as stronger pensions and renewed infrastructure for our communities.
It will continue to work in partnership with indigenous peoples—to develop economic projects, to connect more reserves to the electricity grid, to provide access to clean drinking water and to create culturally appropriate education systems and public services.
It will invest in all regions of our province, including to help unlock the tremendous mineral potential of northern Ontario.
The choices your government has made to develop its balanced plan are working.
Meaningful progress is being made.
A renewed sense of energy and confidence can be felt in our cities and towns, in all parts of our province.
Many Ontario families are already seeing the benefits.
As your government continues to build Ontario up, more will feel an increased sense of security.
Your government believes that government exists to do the things we cannot do alone.
Votre gouvernement considère que les gouvernements existent pour faire ce que nous ne pouvons pas faire individuellement.
It exists to be a force for good in all our lives—every day and in every corner of this beautiful province we call home.
Together, we will achieve the promise of an even brighter future for all.
Her Honour was then pleased to retire.
The Speaker (Hon. Dave Levac): Pray be seated.
The Speaker (Hon. Dave Levac): I beg to inform the House that during the adjournment, a vacancy has occurred in the membership of the House by reason of the resignation of Madame Madeleine Meilleur as the member for the electoral district of Ottawa–Vanier, effective June 30, 2016.
Accordingly, I have issued my warrant to the Chief Electoral Officer for the issue of a writ for a by-election.
The Speaker (Hon. Dave Levac): I also beg to inform the House that the Clerk has received from the Chief Electoral Officer and laid upon the table a certificate of the by-election in the electoral district of Scarborough–Rouge River.
The Clerk of the Assembly (Ms. Deborah Deller): The certificate of the by-election is dated September 12, 2016, and reads as follows:
“A writ of election dated the 3rd day of August 2016 was issued by the Honourable Lieutenant Governor of the province of Ontario, and was addressed to Kim England, returning officer for the electoral district of Scarborough–Rouge River, for the election of a member to represent the said electoral district of Scarborough–Rouge River in the Legislative Assembly of this province in the room of Bas Balkissoon who, since his election as representative of the said electoral district of Scarborough–Rouge River, has resigned his seat. This is to certify that, a poll having been granted and held in Scarborough–Rouge River on the 1st day of September, 2016, Raymond Cho has been returned as duly elected as appears by the return of the said writ of election dated the 8th day of September, 2016, which is now lodged of record in my office.”
It is signed “Greg Essensa, Chief Electoral Officer.”
Mr. Cho was escorted into the House by Mr. Brown and Mr. Wilson.
Mr. Patrick Brown: Mr. Speaker, I have the honour to present to you and to the House Raymond Cho, member-elect for the electoral district of Scarborough–Rouge River, who has taken the oath and has signed the roll and now claims the right to take his seat.
The Speaker (Hon. Dave Levac): Let the honourable member take his seat.
The Speaker (Hon. Dave Levac): Pray be seated.
I beg to inform the House that to prevent mistakes, I have obtained a copy of the throne speech, which I will now read.
The Speaker (Hon. Dave Levac): Dispense? I heard agreement.
Ms. Wynne moved first reading of the following bill:
Bill 1, An Act to perpetuate an ancient parliamentary right / Projet de loi 1, Loi visant à perpétuer un ancien droit parlementaire.
The Speaker (Hon. Dave Levac): Is it the pleasure of the House that the motion carry? Carried.
The Speaker (Hon. Dave Levac): The Premier for a short statement.
Hon. Kathleen O. Wynne: Thank you very much, Mr. Speaker. Following long-standing tradition, the first bill introduced in the Legislature involves an initiative not mentioned in the speech from the throne. I am pleased to introduce this bill here today. This practice signifies the assembly’s independence from the crown and the collective right of members to address the Legislature’s priorities before attending to other business.
Hon. Yasir Naqvi: Good afternoon, Speaker. I move that the speech of Her Honour the Lieutenant Governor to this House be taken into consideration on Tuesday, September 13, 2016.
The Speaker (Hon. Dave Levac): Mr. Naqvi moves that the speech of Her Honour the Lieutenant Governor to this House be taken into consideration on Tuesday, September 13, 2016. Is it the pleasure of the House that the motion carry? Carried.
The Speaker (Hon. Dave Levac): Government House leader.
Hon. Yasir Naqvi: Speaker, I move adjournment of the House.
The Speaker (Hon. Dave Levac): One small piece of housekeeping, if I might beg the indulgence of the House and guests. Just before we adjourn, I would like to invite you to cast your eyes skyward.
This summer, in conjunction with a project to reinforce the acoustic board that has covered much of the artwork of this chamber since 1912, our previous assumption that the paintings on the ceiling are in quite good condition was confirmed. The Board of Internal Economy gave us the authority to expand the scope of the project to uncover the four central panels, thus exposing more of the work of the artist Gustav Hahn. This further step in the restoration of this chamber back to its original state is something that is of significance and of interest to myself and, I know, to many of you here, and I hope that we can continue this great work. Thank you to all those who worked so tirelessly to expose such wonderful art.
The Speaker (Hon. Dave Levac): Mr. Naqvi has moved adjournment of the House. Is it the pleasure of the House that the motion carry? Carried. This House stands adjourned until 9 a.m. on Tuesday, September 13, 2016.


InterPro Domain Architecture
InterPro Entry |
Signatures |
Graphical Match |
Method Name |
|
IPR000873 |
PF00501 |
|
AMP-binding |
|
IPR000873 |
PR00154 |
|
AMPBINDING |
|
IPR000873 |
PS00455 |
AMP_BINDING |
|
|
Structural Features |
|
|
|
|
1lci |
1lci |
|
|
|
<IP_ADDRESS>.2 |
1lci03 |
|
|
|
3.30.300.30.2 |
1lci04 |
|
|
|
<IP_ADDRESS>0.3 |
1lci01 |
|
|
|
<IP_ADDRESS>0.4 |
1lci02 |
|
|
|
<IP_ADDRESS>.1 |
1ba305 |
|
|
|
e.23.1.1 |
d1lci__ |
|
From the graphical match above, you can see that the signatures are all grouped into one InterPro entry for firefly luciferase. IPR000873 represents the AMP-binding domain, which contains a Ser/Thr/Gly (STG) rich region that is further characterised by a conserved Pro-Lys-Gly (PKG) triplet. This domain is found in various AMP-dependent enzymes, including various closely related synthases and ligases. IPR000873 is represented by three signatures: PF00501 from the PFAM database (covers almost the entire domain), PR00154 from the PRINTS database (2-motif fingerprint spanning the STG-rich region, where motif 2 contains the PKG triplet), and PS00455 from the PROSITE database.
The remaining seven entries in
the table above give information on the structure of this protein, presenting
known structural data from the structural database PDB (green stripe) and the
structural classification databases CATH (pink stripe) and SCOP (black stripe)
(the names such as 1lci03
are derived from the PDB entry upon which they are based, here PDB entry 1lci, fragment 3). The graphical match for the PDB entry 1lci displays the full length of
the original PDB entry, here covering the entire protein. The CATH
and SCOP entries breakdown the PDB data into its constituent domains based on
structure, and provide a structural classification for each domain. SCOP classifies the protein as one functional
entity with multiple domains, while CATH divides the protein into five
structurally distinct domains: an
N-terminal domain {1ba305} with
irregular structure; the next two domains {1lci01 and 1lci02} with an aba 3-layer sandwich structure (Rossmann fold); the next domain
{1lci03} with a
mainly b-roll fold; and the C-terminal
domain {1lci04} with
an ab 2-layer sandwich fold. In several papers, the first 4 CATH domains
are often described together as one large N-terminal region, consisting of a b-barrel and 2 b-sheets
flanked by a-helices to form a ababa 5-layer structure; the C-terminal
domain (5th CATH domain) is considered separately, physically divided
from the N-terminal region by a wide cleft.
Structures
associated with firefly luciferase can be viewed using AstexViewer®, which is linked
from the Match Table via the logo on the
InterPro page (please note, there is no link directly from this page to the
AstexViewer®, therefore you need to go to the link on the InterPro page for P08659). The AstexViewer® displays the PDB structure with the specific
CATH or SCOP domain highlighted.
There are
structures available for various luciferases (firefly and bacterial) in the
Protein Data Bank (PDB). A detailed
description and visualisation of the structural features of firefly luciferase
can be found at the PDB ‘Molecule of the Month’.
The crystallographic structures of luciferase enzymes have provided
insight into the mechanism of action of this important enzyme.


min and max of length of title
Number of holidays
stats on descriptions, conditionals, fakes, and images
Analytics for number of views
min and max of length of title
Number of holidays
stats on descriptions, conditionals, fakes, and images
Analytics for number of views


Tamás Benke
Full-Stack Developer - Software Architect Senior Software Architect and Catalyst at Lufthansa Systems Hungária Kft.
I’m passionate about learning new things,
scouting for new technologies,
finding adequate solutions for challenging problems,
and share what I learned with other people.
Nothing is more fulfilling than being part of a team with similar interests,
and an organization that values its employees.


Once pat convinced his friends to try a strange new cookie featuring real salmon, they just couldn't get enough! Since then Pats salmon cookies have been a staple of the Seattle experience and a local favorite.


--- layout: archive title: Zulip Chat Archive permalink: /stream/116395-maths/topic/is_ring_hom.2Eker.html ---
There is no occurrence of ker
in algebra/ring.lean
. Do we not have the defintion of the kernel of a ring homomorphism, and the fact that it is an ideal, in mathlib?
We do...
I think
Hmmm... but only in a very convoluted way
Every ring hom gives a linear map... and we have kernels of linear maps
I couldn't find any occurrence of ker
in ring_theory/ideals.lean
either.
This would involve making my target ring a module over my source ring in some sort of "once and for all" way, which is not what I want in this situation.
Or is that not the case?
Hmm... ideals are bundled. Ring homs aren't... That might hint at why it's not there. It's just how history went.
You really need an ideal? Or is a subgroup enough?
If you need an ideal, the best way is to upgrade your ring hom to a linear map. You can do this locally in the proof with letI
I don't need anything -- I am currently ignoring this completely and just working with the stuff which gets sent to zero.
Ooh, not letI
of course.
I was just expecting my proof to look different.
I know that feeling (-;
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


I’d never really thought about what it meant to be Singaporean. This was where I had been born and raised, sure, and I knew all our stories and founding myths.
But I didn’t think of it as being a part of my identity. After all, this landscape of HDB flats and skyscrapers and air-conditioned shopping malls was the only world I’d ever known.
In the last year, I’ve had the opportunity to study abroad, to travel and live and meet people in a host of different places. Invariably, I’d be asked the questions, “Where are you from?” and “What is it like there?”
What could be my answer? What could I tell people who had either never heard of Singapore, or only knew about our tough drug laws, chewing gum ban, and Michael Fay’s caning?
To be honest, I didn’t really have a good answer at the beginning. I would speak of the things you’d read in a travel guide – how modern and clean Singapore was, our busy air and sea ports, our self-given moniker of “garden city”. All these things are true, yes, but none of them really get down to the heart of being Singaporean.
But as I learned to adopt new ways of life and saw how other people lived, I began to understand what a special place Singapore is, and by extension, what it means to be Singaporean.
I think one of the interviews screened at the National Day Parade said it best – “I don’t judge other Singaporeans for being kiasu anymore, because I realised how kiasu I really am”. It’s only when you’re away that you learn that the things that seemed so natural in this environment are actually the things that make us instantly recognizable to each other anywhere else in the world.
To be Singaporean is to listen to announcements being made in four languages - English, Chinese, Malay, and Tamil, but to speak in a fifth: Singlish.
To be Singaporean is to complain about everything while still waving the Singapore flag above your head with pride.
To be Singaporean is to look at the dancers at the parade wearing traditional batik dress, or white singlets with coolie hats, or three-piece suits, and be able to say, all of that is us, all of that is Singapore.
To be Singaporean is to have queuing be a way of life – whether at the MRT or at the newly-opened H&M store on Orchard Road.
And of course, to be Singaporean is to love your food, to always be on the lookout for the best chicken rice and nasi lemak, to argue over the best place for Katong laksa, and to closely follow the harvest season of Mao shan wang durian.
Singapore isn’t perfect. Going overseas has made me even more aware of the problems Singapore still faces: lack of political and social freedoms, institutionalized discrimination, and an increasing stratification of society, amongst other things. But on the whole, I’d say we’re doing pretty well.
Last year, I couldn’t wait to get out, to leave this stuffy city-state behind with its stringent rules and draconian laws, to start a new life in the land of freedom. But more than ever, I’ve realized that it’s important to know where you’ve come from. The experiences I’ve had over the past year, travelling the world, culminating in attending the National Day celebrations back home, helped me figure out what I really mean when I introduce myself as being from Singapore.
Happy 50th National Day!
Singapore


JavaScript makes HTML pages more dynamic and interactive.
<!DOCTYPE html>

My First JavaScript

<button type="button"
onclick="document.getElementById('demo').innerHTML = Date()">
Click me to display Date and Time.</button>

The HTML
A Taste of JavaScript
Here are some examples of what JavaScript can do:
document.getElementById("demo").innerHTML = "Hello JavaScript!";
The HTML  Tag
The HTML  tag defines an alternate content to be displayed to users that have disabled scripts in their browser or have a browser that doesn't support scripts:

Sorry, your browser does not support JavaScript!


A guide to the automated creation and hosting of virtual machine images.
Infrastructure as code purposes to automate virtual machine creation and provide high availability for custom boxes to be downloaded.
This is done with several tools:
- packer
- vagrant
- VirtualBox
- Apache
Check out the git-repo here


rotten > Library > History > Index by Country > Nicaragua
Nicaragua
- Anastasio Somoza.
- Iran-Contra.
- William Walker and Manifest Destiny.
- The U.S. used planes marked with Red Cross insignia both to fly National Guard generals out of the country (the very same generals responsible for 40,000 deaths), and to smuggle arms into the country for the Contras. Either of these acts are war crimes.
- The International Court of Justice found the U.S. guilty of the illegal mining of Nicaraguan harbors.
Pornopolis |
Rotten |
Faces of Death |
Famous Nudes
|