|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object codeblocks.BlockShape
public class BlockShape
This class separates block shape from the RenderableBlock class. BlockShape uses information from RenderableBlock to determine shape and dimensions of the block being drawn. BlockShape does not know where it is in the world -- all coords are local.
| Field Summary | |
|---|---|
protected static BlockConnectorShape |
BCS
Draws the individual connectors. |
protected Block |
block
The Block associated to this BlockShape |
protected java.awt.Rectangle |
blockBody
Body of the block |
protected float |
blockCornerRadius
|
protected long |
blockID
The blockID associated to this BlockShape |
protected java.awt.geom.Point2D |
botLeftCorner
|
protected java.awt.geom.Point2D |
botRightCorner
|
static float |
BOTTOM_SOCKET_MIDDLE_SPACER
spacer for in between bottom sockets |
static float |
BOTTOM_SOCKET_SIDE_SPACER
spacer for bottom sockets to block sides and other bottom sockets |
static float |
BOTTOM_SOCKET_UPPER_SPACER
spacer on top of bottom sockets to give continuous top |
protected static BlockShapeUtil |
BSU
Tools to draw block shape. |
static float |
COMMAND_PORT_OFFSET
left alignment buffer for command ports |
static float |
CORNER_RADIUS
radius of rounded corners |
protected java.awt.geom.GeneralPath |
gpBottom
Outline of bottom-left conrner, bottom edge, and bottom-right corner (Counter-Clockwise) |
protected boolean |
hasCurvedCorners
block properties determining shape |
protected RenderableBlock |
rb
The RenderableBlock associated to this BlockShape |
protected java.awt.geom.Point2D |
topLeftCorner
|
protected java.awt.geom.Point2D |
topRightCorner
|
static float |
VARIABLE_DECLARATION_SPACER
variable declaration spacer |
| Constructor Summary | |
|---|---|
BlockShape(RenderableBlock rb)
BlockShape constructor |
| Method Summary | |
|---|---|
static void |
addCustomShapes(CustomBlockShapeSet cbs)
Add a new set of custom shapes |
protected int |
determineBlockHeight()
Determines the height of a block by summing it's socket heights OR plug height if no sockets TODO: this contains a lot of starlogo specific checks - should be refactored into slcodeblocks? |
protected int |
determineBlockWidth()
Determines the width of the block by checking for numerous block characteristics TODO: this contains a lot of starlogo specific checks - should be refactored into slcodeblocks? |
protected java.awt.geom.GeneralPath |
getBottomSide()
Returns the GeneralPath of the bottom side of this block shape. |
protected java.awt.geom.GeneralPath |
getLeftSide()
Returns the GeneralPath of the left side of this block shape. |
protected java.awt.geom.GeneralPath |
getRightSide()
Returns the GeneralPath of the right side of this block shape. |
protected int |
getSocketSpacerHeight(BlockConnector socket,
float defaultHeight)
Returns the height of the spacer associated with a socket if it exists, else it returns the given default height. |
protected java.awt.geom.GeneralPath |
getTopSide()
Returns the GeneralPath of the top side of this block shape. |
protected int |
getTotalHeightOfSockets()
Returns the total height of this blocks sockets based on connector shape and position type; 0 if this block has no sockets |
protected void |
makeBottomSide()
|
protected void |
makeLeftSide()
|
protected void |
makeRightSide()
|
protected void |
makeTopSide()
|
java.awt.geom.Area |
reformArea()
Reform the BlockShape area. |
protected void |
setEndPoint(java.awt.geom.GeneralPath gp,
java.awt.geom.Point2D currentCorner,
java.awt.geom.Point2D otherCorner,
boolean firstPointOnSide)
Sets the end point for a particular side of a block. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
protected static BlockConnectorShape BCS
protected static BlockShapeUtil BSU
protected RenderableBlock rb
protected long blockID
protected Block block
public static final float COMMAND_PORT_OFFSET
public static final float CORNER_RADIUS
public static final float VARIABLE_DECLARATION_SPACER
public static final float BOTTOM_SOCKET_SIDE_SPACER
public static final float BOTTOM_SOCKET_MIDDLE_SPACER
public static final float BOTTOM_SOCKET_UPPER_SPACER
protected java.awt.geom.GeneralPath gpBottom
protected java.awt.Rectangle blockBody
protected java.awt.geom.Point2D topLeftCorner
protected java.awt.geom.Point2D topRightCorner
protected java.awt.geom.Point2D botLeftCorner
protected java.awt.geom.Point2D botRightCorner
protected boolean hasCurvedCorners
protected float blockCornerRadius
| Constructor Detail |
|---|
public BlockShape(RenderableBlock rb)
rb
- | Method Detail |
|---|
protected int determineBlockWidth()
protected int getTotalHeightOfSockets()
protected int determineBlockHeight()
protected void makeTopSide()
protected void makeRightSide()
protected void makeLeftSide()
protected void makeBottomSide()
protected void setEndPoint(java.awt.geom.GeneralPath gp, java.awt.geom.Point2D currentCorner, java.awt.geom.Point2D otherCorner, boolean firstPointOnSide)
protected int getSocketSpacerHeight(BlockConnector socket, float defaultHeight)
protected java.awt.geom.GeneralPath getBottomSide()
protected java.awt.geom.GeneralPath getLeftSide()
protected java.awt.geom.GeneralPath getTopSide()
protected java.awt.geom.GeneralPath getRightSide()
public java.awt.geom.Area reformArea()
public static void addCustomShapes(CustomBlockShapeSet cbs)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


|
See also the following language extensions: first-class modules, attributes and extension nodes.
The table below shows the relative precedences and associativity of operators and non-closed pattern constructions. The constructions with higher precedences come first.
| Operator | Associativity |
| .. | – |
| lazy (see section 11.6) | – |
| Constructor application, Tag application | right |
| :: | right |
| , | – |
| | | left |
| as | – |
Patterns are templates that allow selecting data structures of a given shape, and binding identifiers to components of the data structure. This selection operation is called pattern matching; its outcome is either “this value does not match this pattern”, or “this value matches this pattern, resulting in the following bindings of names to values”.
A pattern that consists in a value name matches any value, binding the name to the value. The pattern _ also matches any value, but does not bind any name.
Patterns are linear: a variable cannot be bound several times by a given pattern. In particular, there is no way to test for equality between two parts of a data structure using only a pattern:
However, we can use a when guard for this purpose:
A pattern consisting in a constant matches the values that are equal to this constant.
The pattern pattern1 as value-name matches the same values as pattern1. If the matching against pattern1 is successful, the name value-name is bound to the matched value, in addition to the bindings performed by the matching against pattern1.
The pattern ( pattern1 ) matches the same values as pattern1. A type constraint can appear in a parenthesized pattern, as in ( pattern1 : typexpr ). This constraint forces the type of pattern1 to be compatible with typexpr.
The pattern pattern1 | pattern2 represents the logical “or” of the two patterns pattern1 and pattern2. A value matches pattern1 | pattern2 if it matches pattern1 or pattern2. The two sub-patterns pattern1 and pattern2 must bind exactly the same identifiers to values having the same types. Matching is performed from left to right. More precisely, in case some value v matches pattern1 | pattern2, the bindings performed are those of pattern1 when v matches pattern1. Otherwise, value v matches pattern2 whose bindings are performed.
The pattern constr ( pattern1 , … , patternn ) matches all variants whose constructor is equal to constr, and whose arguments match pattern1 … patternn. It is a type error if n is not the number of arguments expected by the constructor.
The pattern constr _ matches all variants whose constructor is constr.
The pattern pattern1 :: pattern2 matches non-empty lists whose heads match pattern1, and whose tails match pattern2.
The pattern [ pattern1 ; … ; patternn ] matches lists of length n whose elements match pattern1 …patternn, respectively. This pattern behaves like pattern1 :: … :: patternn :: [].
The pattern `tag-name pattern1 matches all polymorphic variants whose tag is equal to tag-name, and whose argument matches pattern1.
If the type [('a,'b,…)] typeconstr = [ `tag-name1 typexpr1 | … | `tag-namen typexprn] is defined, then the pattern #typeconstr is a shorthand for the following or-pattern: ( `tag-name1(_ : typexpr1) | … | `tag-namen(_ : typexprn)). It matches all values of type [< typeconstr ].
The pattern pattern1 , … , patternn matches n-tuples whose components match the patterns pattern1 through patternn. That is, the pattern matches the tuple values (v1, …, vn) such that patterni matches vi for i = 1,… , n.
The pattern { field1 [= pattern1] ; … ; fieldn [= patternn] } matches records that define at least the fields field1 through fieldn, and such that the value associated to fieldi matches the pattern patterni, for i = 1,… , n. A single identifier fieldk stands for fieldk = fieldk , and a single qualified identifier module-path . fieldk stands for module-path . fieldk = fieldk . The record value can define more fields than field1 …fieldn; the values associated to these extra fields are not taken into account for matching. Optionally, a record pattern can be terminated by ; _ to convey the fact that not all fields of the record type are listed in the record pattern and that it is intentional. Optional type constraints can be added field by field with { field1 : typexpr1 = pattern1 ;… ;fieldn : typexprn = patternn } to force the type of fieldk to be compatible with typexprk.
The pattern [| pattern1 ; … ; patternn |] matches arrays of length n such that the i-th array element matches the pattern patterni, for i = 1,… , n.
The pattern ' c ' .. ' d ' is a shorthand for the pattern
where c1, c2, …, cn are the characters that occur between c and d in the ASCII character set. For instance, the pattern '0'..'9' matches all characters that are digits.
(Introduced in Objective Caml 3.11)
|
The pattern lazy pattern matches a value v of type Lazy.t, provided pattern matches the result of forcing v with Lazy.force.  Matching a value with a pattern-matching where some patterns contain lazy sub-patterns may imply forcing parts of the value, even when the pattern selected in the end has no lazy sub-pattern.
For more information, see the description of module Lazy in the standard library (module Lazy).
(Introduced in OCaml 4.02)
A new form of exception pattern, exception pattern , is allowed only as a toplevel pattern or inside a toplevel or-pattern under a match...with pattern-matching (other occurrences are rejected by the type-checker).
Cases with such a toplevel pattern are called “exception cases”, as opposed to regular “value cases”. Exception cases are applied when the evaluation of the matched expression raises an exception. The exception value is then matched against all the exception cases and re-raised if none of them accept the exception (as with a try...with block). Since the bodies of all exception and value cases are outside the scope of the exception handler, they are all considered to be in tail-position: if the match...with block itself is in tail position in the current function, any function call in tail position in one of the case bodies results in an actual tail call.
A pattern match must contain at least one value case. It is an error if all cases are exceptions, because there would be no code to handle the return of a value.
For patterns, local opens are limited to the module-path.(pattern) construction. This construction locally opens the module referred to by the module path module-path in the scope of the pattern pattern.
When the body of a local open pattern is delimited by [ ], [| |], or { }, the parentheses can be omitted. For example, module-path.[pattern] is equivalent to module-path.([pattern]), and module-path.[| pattern |] is equivalent to module-path.([| pattern |]).


--- layout: page title: About header-img: "img/about-bg.png" ---
HI, my name is Olesya and I am very excited to be a part of the Flatiron School community!


Update
Sven Coop
Team Fortress 2
Team Fortress Classic
Half-Life Deathmatch
Half-Life Deathmatch: Source
Half-Life: Opposing Force


##Team Name Goes Here##
Easter egg text goes here
Your Chase Vehicle
Wait for the Chase Breifing
They will tell you when to continue


In total there are 12 rules, 3 outbound rules and 11 conditions in the configuration file.
A test rule to show a simple redirect.
URL's matching /test/status/
will be redirected
to /rewrite-status
.
This rule and it's conditions will use the regex
matching engine.
URL's matching logo.gif
will permanent-redirect
to http://<IP_ADDRESS>:8080/urlrewrite/artifact_type.gif
.
This rule and it's conditions will use the regex
matching engine.
Allows users to type product id's into urls.
ID's published in magazine.
URL's matching /products/*/*/
will be forwarded
to /products.jsp
.
This rule and it's conditions will use the regex
matching engine.
This rule will set:
request
object called categoryId
to the value null
request
object called usingFilter
to the value yes
URL's matching /chairs/*/
will be forwarded
to /products/chairs.jsp
.
This rule and it's conditions will use the regex
matching engine.
This rule will set:
session
object called chairShopper
to the value true
URL's matching /test/disabled/
will be redirected
to /rewrite-status
.
This rule and it's conditions will use the regex
matching engine.
Given that the following conditions are met.
user-agent
HTTP header does NOT match the value mac
and
dayofmonth
is equal to
the value 14
and
charset
HTTP header matches the value utf
and
user-in-role
is equal to
the value admin
URL's matching /test/disabled/
.
This rule and it's conditions will use the regex
matching engine.

URL's matching /test-set/([0-9]+)
will be forwarded
to /test-set.jsp
.
This rule and it's conditions will use the regex
matching engine.
Given that the following condition is met.
user-agent
HTTP header does NOT match the value mac
This rule will set:
request
object called num
to the value num
This rule will run:
run
on an instance of org.tuckey.web.filters.urlrewrite.test.TestRunObj
run
on an instance of org.tuckey.web.filters.urlrewrite.test.TestRunObj
nonDefaultRun
on an instance of org.tuckey.web.filters.urlrewrite.test.TestRunObj
nonDefaultRun
on an instance of org.tuckey.web.filters.urlrewrite.test.TestRunObj
(a new instance will be created for each rule match)
nonDefaultRun
on an instance of org.tuckey.web.filters.urlrewrite.test.TestRunObj
(a new instance will be created for each rule match)
init(ServletConfig)
or destroy()
is found on the above objects they will be run at when creating or destroying an instance.
URL's matching /content/([a-zA-Z]+)
.
This rule and it's conditions will use the regex
matching engine.
This rule will set:
request
object called contentItem
to the value $1
This rule will run:
doGet
on an instance of org.tuckey.web.filters.urlrewrite.TestServlet
init(ServletConfig)
or destroy()
is found on the above object they will be run at when creating or destroying an instance.
Note, other rules will be processed after this rule.
URL's matching /pref/([a-zA-Z]+)
.
This rule and it's conditions will use the regex
matching engine.
Given that the following condition is met.
method
is equal to
the value POST
This rule will run:
doPost
on an instance of org.tuckey.web.filters.urlrewrite.TestServlet
init(ServletConfig)
or destroy()
is found on the above object they will be run at when creating or destroying an instance.
Note, other rules will be processed after this rule.
URL's matching /test-redirect-301
will permanent-redirect
to /is-this-301
.
This rule and it's conditions will use the regex
matching engine.
URL's matching /test-redirect-302
will temporary-redirect
to is-this-302
.
This rule and it's conditions will use the regex
matching engine.
URL's matching /test-redirect-302
will temporary-redirect
to is-this-302
.
This rule and it's conditions will use the regex
matching engine.
Given that the following condition is met.
user-in-role
is equal to
the value devil
Outbound URL's matching /page-not-for-devils(0-9)?
will be rewritten to /devils-page
, after response.encodeURL()
has been called.
Given that the following condition is met.
user-in-role
is equal to
the value devil
Outbound URL's matching ^(.*);jsessionid=.*$
will be rewritten to $1
.
Given that the following condition is met.
user-agent
HTTP header matches the value googlebot.*
Outbound URL's matching *;jsessionid=*
will be rewritten to $1
, after response.encodeURL()
has been called.
Given that the following condition is met.
user-agent
HTTP header matches the value googlebot*


cmake-developer(7)¶
Contents
Introduction¶
This manual is intended for reference by developers modifying the CMake source tree itself.
Permitted C++ Subset¶
CMake is required to build with ancient C++ compilers and standard library implementations. Some common C++ constructs may not be used in CMake in order to build with such toolchains.
std::auto_ptr¶
Some implementations have a std::auto_ptr
which can not be used as a
return value from a function. std::auto_ptr
may not be used. Use
cmsys::auto_ptr
instead.
Adding Compile Features¶
CMake reports an error if a compiler whose features are known does not report support for a particular requested feature. A compiler is considered to have known features if it reports support for at least one feature.
When adding a new compile feature to CMake, it is therefore necessary to list support for the feature for all CompilerIds which already have one or more feature supported, if the new feature is available for any version of the compiler.
When adding the first supported feature to a particular CompilerId, it is
necessary to list support for all features known to cmake (See
CMAKE_C_COMPILE_FEATURES
and
CMAKE_CXX_COMPILE_FEATURES
as appropriate), where available for
the compiler. Furthermore, set CMAKE_<LANG>_STANDARD_DEFAULT
to the
default language standard level the compiler uses, or to the empty string
if the compiler has no notion of standard levels (such as MSVC
).
It is sensible to record the features for the most recent version of a particular CompilerId first, and then work backwards. It is sensible to try to create a continuous range of versions of feature releases of the compiler. Gaps in the range indicate incorrect features recorded for intermediate releases.
Generally, features are made available for a particular version if the
compiler vendor documents availability of the feature with that
version. Note that sometimes partially implemented features appear to
be functional in previous releases (such as cxx_constexpr
in GNU 4.6,
though availability is documented in GNU 4.7), and sometimes compiler vendors
document availability of features, though supporting infrastructure is
not available (such as __has_feature(cxx_generic_lambdas)
indicating
non-availability in Clang 3.4, though it is documented as available, and
fixed in Clang 3.5). Similar cases for other compilers and versions
need to be investigated when extending CMake to support them.
When a vendor releases a new version of a known compiler which supports a previously unsupported feature, and there are already known features for that compiler, the feature should be listed as supported in CMake for that version of the compiler as soon as reasonably possible.
Standard-specific/compiler-specific variables such
CMAKE_CXX98_COMPILE_FEATURES
are deliberately not documented. They
only exist for the compiler-specific implementation of adding the -std
compile flag for compilers which need that.
Help¶
The Help
directory contains CMake help manual source files.
They are written using the reStructuredText markup syntax and
processed by Sphinx to generate the CMake help manuals.
Markup Constructs¶
In addition to using Sphinx to generate the CMake help manuals, we
also use a C++-implemented document processor to print documents for
the --help-*
command-line help options. It supports a subset of
reStructuredText markup. When authoring or modifying documents,
please verify that the command-line help looks good in addition to the
Sphinx-generated html and man pages.
The command-line help processor supports the following constructs defined by reStructuredText, Sphinx, and a CMake extension to Sphinx.
- CMake Domain directives
- Directives defined in the CMake Domain for defining CMake documentation objects are printed in command-line help output as if the lines were normal paragraph text with interpretation.
- CMake Domain interpreted text roles
- Interpreted text roles defined in the CMake Domain for cross-referencing CMake documentation objects are replaced by their link text in command-line help output. Other roles are printed literally and not processed.
code-block
directive- Add a literal code block without interpretation. The command-line help processor prints the block content without the leading directive line and with common indentation replaced by one space.
include
directive- Include another document source file. The command-line help processor prints the included document inline with the referencing document.
- literal block after
::
- A paragraph ending in
::
followed by a blank line treats the following indented block as literal text without interpretation. The command-line help processor prints the::
literally and prints the block content with common indentation replaced by one space. note
directive- Call out a side note. The command-line help processor prints the block content as if the lines were normal paragraph text with interpretation.
parsed-literal
directive- Add a literal block with markup interpretation. The command-line help processor prints the block content without the leading directive line and with common indentation replaced by one space.
productionlist
directive- Render context-free grammar productions. The command-line help processor prints the block content as if the lines were normal paragraph text with interpretation.
replace
directive- Define a
|substitution|
replacement. The command-line help processor requires a substitution replacement to be defined before it is referenced. |substitution|
reference- Reference a substitution replacement previously defined by
the
replace
directive. The command-line help processor performs the substitution and replaces all newlines in the replacement text with spaces. toctree
directive- Include other document sources in the Table-of-Contents document tree. The command-line help processor prints the referenced documents inline as part of the referencing document.
Inline markup constructs not listed above are printed literally in the command-line help output. We prefer to use inline markup constructs that look correct in source form, so avoid use of \-escapes in favor of inline literals when possible.
Explicit markup blocks not matching directives listed above are removed from
command-line help output. Do not use them, except for plain ..
comments
that are removed by Sphinx too.
Note that nested indentation of blocks is not recognized by the command-line help processor. Therefore:
- Explicit markup blocks are recognized only when not indented inside other blocks.
- Literal blocks after paragraphs ending in
::
but not at the top indentation level may consume all indented lines following them.
Try to avoid these cases in practice.
CMake Domain¶
CMake adds a Sphinx Domain called cmake
, also called the
“CMake Domain”. It defines several “object” types for CMake
documentation:
command
- A CMake language command.
generator
- A CMake native build system generator.
See the
cmake(1)
command-line tool’s-G
option. manual
- A CMake manual page, like this
cmake-developer(7)
manual. module
- A CMake module.
See the
cmake-modules(7)
manual and theinclude()
command. policy
- A CMake policy.
See the
cmake-policies(7)
manual and thecmake_policy()
command. prop_cache, prop_dir, prop_gbl, prop_sf, prop_inst, prop_test, prop_tgt
- A CMake cache, directory, global, source file, installed file, test,
or target property, respectively. See the
cmake-properties(7)
manual and theset_property()
command. variable
- A CMake language variable.
See the
cmake-variables(7)
manual and theset()
command.
Documentation objects in the CMake Domain come from two sources.
First, the CMake extension to Sphinx transforms every document named
with the form Help/<type>/<file-name>.rst
to a domain object with
type <type>
. The object name is extracted from the document title,
which is expected to be of the form:
<object-name>
-------------
and to appear at or near the top of the .rst
file before any other
lines starting in a letter, digit, or <
. If no such title appears
literally in the .rst
file, the object name is the <file-name>
.
If a title does appear, it is expected that <file-name>
is equal
to <object-name>
with any <
and >
characters removed.
Second, the CMake Domain provides directives to define objects inside other documents:
.. command:: <command-name>
This indented block documents <command-name>.
.. variable:: <variable-name>
This indented block documents <variable-name>.
Object types for which no directive is available must be defined using the first approach above.
Cross-References¶
Sphinx uses reStructuredText interpreted text roles to provide cross-reference syntax. The CMake Domain provides for each domain object type a role of the same name to cross-reference it. CMake Domain roles are inline markup of the forms:
:type:`name`
:type:`text <name>`
where type
is the domain object type and name
is the
domain object name. In the first form the link text will be
name
(or name()
if the type is command
) and in
the second form the link text will be the explicit text
.
For example, the code:
* The :command:`list` command.
* The :command:`list(APPEND)` sub-command.
* The :command:`list() command <list>`.
* The :command:`list(APPEND) sub-command <list>`.
* The :variable:`CMAKE_VERSION` variable.
* The :prop_tgt:`OUTPUT_NAME_<CONFIG>` target property.
produces:
- The
list()
command. - The
list(APPEND)
sub-command. - The
list() command
. - The
list(APPEND) sub-command
. - The
CMAKE_VERSION
variable. - The
OUTPUT_NAME_<CONFIG>
target property.
Note that CMake Domain roles differ from Sphinx and reStructuredText
convention in that the form a
, without a space preceding <
,
is interpreted as a name instead of link text with an explicit target.
This is necessary because we use <placeholders>
frequently in
object names like OUTPUT_NAME_<CONFIG>
. The form a
,
with a space preceding <
, is still interpreted as a link text
with an explicit target.
Style¶
Style: Section Headers¶
When marking section titles, make the section decoration line as long as the title text. Use only a line below the title, not above. For example:
Title Text
----------
Capitalize the first letter of each non-minor word in the title.
The section header underline character hierarchy is
#
: Manual group (part) in the master document*
: Manual (chapter) title=
: Section within a manual-
: Subsection or CMake Domain object document title^
: Subsubsection or CMake Domain object document section"
: Paragraph or CMake Domain object document subsection
Style: Whitespace¶
Use two spaces for indentation. Use two spaces between sentences in prose.
Style: Line Length¶
Prefer to restrict the width of lines to 75-80 columns. This is not a hard restriction, but writing new paragraphs wrapped at 75 columns allows space for adding minor content without significant re-wrapping of content.
Style: Prose¶
Use American English spellings in prose.
Style: Starting Literal Blocks¶
Prefer to mark the start of literal blocks with ::
at the end of
the preceding paragraph. In cases where the following block gets
a code-block
marker, put a single :
at the end of the preceding
paragraph.
Style: CMake Command Signatures¶
Command signatures should be marked up as plain literal blocks, not as
cmake code-blocks
.
Signatures are separated from preceding content by a section header. That is, use:
... preceding paragraph.
Normal Libraries
^^^^^^^^^^^^^^^^
::
add_library(<lib> ...)
This signature is used for ...
Signatures of commands should wrap optional parts with square brackets,
and should mark list of optional arguments with an ellipsis (...
).
Elements of the signature which are specified by the user should be
specified with angle brackets, and may be referred to in prose using
inline-literal
syntax.
Style: Boolean Constants¶
Use “OFF
” and “ON
” for boolean values which can be modified by
the user, such as POSITION_INDEPENDENT_CODE
. Such properties
may be “enabled” and “disabled”. Use “True
” and “False
” for
inherent values which can’t be modified after being set, such as the
IMPORTED
property of a build target.
Style: Inline Literals¶
Mark up references to keywords in signatures, file names, and other
technical terms with inline-literal
syntax, for example:
If ``WIN32`` is used with :command:`add_executable`, the
:prop_tgt:`WIN32_EXECUTABLE` target property is enabled. That command
creates the file ``<name>.exe`` on Windows.
Style: Cross-References¶
Mark up linkable references as links, including repeats. An alternative, which is used by wikipedia (http://en.wikipedia.org/wiki/WP:REPEATLINK), is to link to a reference only once per article. That style is not used in CMake documentation.
Style: Referencing CMake Concepts¶
If referring to a concept which corresponds to a property, and that concept is described in a high-level manual, prefer to link to the manual section instead of the property. For example:
This command creates an :ref:`Imported Target <Imported Targets>`.
instead of:
This command creates an :prop_tgt:`IMPORTED` target.
The latter should be used only when referring specifically to the property.
References to manual sections are not automatically created by creating a section, but code such as:
.. _`Imported Targets`:
creates a suitable anchor. Use an anchor name which matches the name of the corresponding section. Refer to the anchor using a cross-reference with specified text.
Imported Targets need the IMPORTED
term marked up with care in
particular because the term may refer to a command keyword
(IMPORTED
), a target property (IMPORTED
), or a
concept (Imported Targets).
Where a property, command or variable is related conceptually to others, by for example, being related to the buildsystem description, generator expressions or Qt, each relevant property, command or variable should link to the primary manual, which provides high-level information. Only particular information relating to the command should be in the documentation of the command.
Style: Referencing CMake Domain Objects¶
When referring to CMake Domain objects such as properties, variables, commands etc, prefer to link to the target object and follow that with the type of object it is. For example:
Set the :prop_tgt:`AUTOMOC` target property to ``ON``.
Instead of
Set the target property :prop_tgt:`AUTOMOC` to ``ON``.
The policy
directive is an exception, and the type us usually
referred to before the link:
If policy :prop_tgt:`CMP0022` is set to ``NEW`` the behavior is ...
However, markup self-references with inline-literal
syntax.
For example, within the add_executable()
command
documentation, use
``add_executable``
not
:command:`add_executable`
which is used elsewhere.
Modules¶
The Modules
directory contains CMake-language .cmake
module files.
Module Documentation¶
To document CMake module Modules/<module-name>.cmake
, modify
Help/manual/cmake-modules.7.rst
to reference the module in the
toctree
directive, in sorted order, as:
/module/<module-name>
Then add the module document file Help/module/<module-name>.rst
containing just the line:
.. cmake-module:: ../../Modules/<module-name>.cmake
The cmake-module
directive will scan the module file to extract
reStructuredText markup from comment blocks that start in .rst:
.
Add to the top of Modules/<module-name>.cmake
a
Line Comment block of the form:
#.rst:
# <module-name>
# -------------
#
# <reStructuredText documentation of module>
or a Bracket Comment of the form:
#[[.rst:
<module-name>
-------------
<reStructuredText documentation of module>
#]]
Any number of =
may be used in the opening and closing brackets
as long as they match. Content on the line containing the closing
bracket is excluded if and only if the line starts in #
.
Additional such .rst:
comments may appear anywhere in the module file.
All such comments must start with #
in the first column.
For example, a Modules/Findxxx.cmake
module may contain:
#.rst:
# FindXxx
# -------
#
# This is a cool module.
# This module does really cool stuff.
# It can do even more than you think.
#
# It even needs two paragraphs to tell you about it.
# And it defines the following variables:
#
# * VAR_COOL: this is great isn't it?
# * VAR_REALLY_COOL: cool right?

#[========================================[.rst:
.. command:: xxx_do_something
This command does something for Xxx::
xxx_do_something(some arguments)
#]========================================]
macro(xxx_do_something)

endmacro()
After the top documentation block, leave a BLANK line, and then add a copyright and licence notice block like this one (change only the year range and name)
#=============================================================================
# Copyright 2009-2011 Your Name
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
Test the documentation formatting by running
cmake --help-module <module-name>
, and also by enabling the
SPHINX_HTML
and SPHINX_MAN
options to build the documentation.
Edit the comments until generated documentation looks satisfactory. To
have a .cmake file in this directory NOT show up in the modules
documentation, simply leave out the Help/module/<module-name>.rst
file and the Help/manual/cmake-modules.7.rst
toctree entry.
Find Modules¶
A “find module” is a Modules/Find<package>.cmake
file to be loaded
by the find_package()
command when invoked for <package>
.
The primary task of a find module is to determine whether a package
exists on the system, set the <package>_FOUND
variable to reflect
this and provide any variables, macros and imported targets required to
use the package. A find module is useful in cases where an upstream
library does not provide a
config file package.
The traditional approach is to use variables for everything, including libraries and executables: see the Standard Variable Names section below. This is what most of the existing find modules provided by CMake do.
The more modern approach is to behave as much like config file packages files as possible, by providing imported target. This has the advantage of propagating Transitive Usage Requirements to consumers.
In either case (or even when providing both variables and imported targets), find modules should provide backwards compatibility with old versions that had the same name.
A FindFoo.cmake module will typically be loaded by the command:
find_package(Foo [major[.minor[.patch[.tweak]]]]
[EXACT] [QUIET] [REQUIRED]
[[COMPONENTS] [components...]]
[OPTIONAL_COMPONENTS components...]
[NO_POLICY_SCOPE])
See the find_package()
documentation for details on what
variables are set for the find module. Most of these are dealt with by
using FindPackageHandleStandardArgs
.
Briefly, the module should only locate versions of the package
compatible with the requested version, as described by the
Foo_FIND_VERSION
family of variables. If Foo_FIND_QUIETLY
is
set to true, it should avoid printing messages, including anything
complaining about the package not being found. If Foo_FIND_REQUIRED
is set to true, the module should issue a FATAL_ERROR
if the package
cannot be found. If neither are set to true, it should print a
non-fatal message if it cannot find the package.
Packages that find multiple semi-independent parts (like bundles of
libraries) should search for the components listed in
Foo_FIND_COMPONENTS
if it is set , and only set Foo_FOUND
to
true if for each searched-for component <c>
that was not found,
Foo_FIND_REQUIRED_<c>
is not set to true. The HANDLE_COMPONENTS
argument of find_package_handle_standard_args()
can be used to
implement this.
If Foo_FIND_COMPONENTS
is not set, which modules are searched for
and required is up to the find module, but should be documented.
For internal implementation, it is a generally accepted convention that variables starting with underscore are for temporary use only.
Like all modules, find modules should be properly documented. To add a module to the CMake documentation, follow the steps in the Module Documentation section above.
Standard Variable Names¶
For a FindXxx.cmake
module that takes the approach of setting
variables (either instead of or in addition to creating imported
targets), the following variable names should be used to keep things
consistent between find modules. Note that all variables start with
Xxx_
to make sure they do not interfere with other find modules; the
same consideration applies to macros, functions and imported targets.
Xxx_INCLUDE_DIRS
- The final set of include directories listed in one variable for use by client code. This should not be a cache entry.
Xxx_LIBRARIES
- The libraries to link against to use Xxx. These should include full paths. This should not be a cache entry.
Xxx_DEFINITIONS
- Definitions to use when compiling code that uses Xxx. This really
shouldn’t include options such as
-DHAS_JPEG
that a client source-code file uses to decide whether to#include <jpeg.h>
Xxx_EXECUTABLE
- Where to find the Xxx tool.
Xxx_Yyy_EXECUTABLE
- Where to find the Yyy tool that comes with Xxx.
Xxx_LIBRARY_DIRS
- Optionally, the final set of library directories listed in one variable for use by client code. This should not be a cache entry.
Xxx_ROOT_DIR
- Where to find the base directory of Xxx.
Xxx_VERSION_Yy
- Expect Version Yy if true. Make sure at most one of these is ever true.
Xxx_WRAP_Yy
- If False, do not try to use the relevant CMake wrapping command.
Xxx_Yy_FOUND
- If False, optional Yy part of Xxx sytem is not available.
Xxx_FOUND
- Set to false, or undefined, if we haven’t found, or don’t want to use Xxx.
Xxx_NOT_FOUND_MESSAGE
- Should be set by config-files in the case that it has set
Xxx_FOUND
to FALSE. The contained message will be printed by thefind_package()
command and byfind_package_handle_standard_args()
to inform the user about the problem. Xxx_RUNTIME_LIBRARY_DIRS
- Optionally, the runtime library search path for use when running an
executable linked to shared libraries. The list should be used by
user code to create the
PATH
on windows orLD_LIBRARY_PATH
on UNIX. This should not be a cache entry. Xxx_VERSION
- The full version string of the package found, if any. Note that many
existing modules provide
Xxx_VERSION_STRING
instead. Xxx_VERSION_MAJOR
- The major version of the package found, if any.
Xxx_VERSION_MINOR
- The minor version of the package found, if any.
Xxx_VERSION_PATCH
- The patch version of the package found, if any.
The following names should not usually be used in CMakeLists.txt files, but are typically cache variables for users to edit and control the behaviour of find modules (like entering the path to a library manually)
Xxx_LIBRARY
- The path of the Xxx library (as used with
find_library()
, for example). Xxx_Yy_LIBRARY
- The path of the Yy library that is part of the Xxx system. It may or may not be required to use Xxx.
Xxx_INCLUDE_DIR
- Where to find headers for using the Xxx library.
Xxx_Yy_INCLUDE_DIR
- Where to find headers for using the Yy library of the Xxx system.
To prevent users being overwhelmed with settings to configure, try to
keep as many options as possible out of the cache, leaving at least one
option which can be used to disable use of the module, or locate a
not-found library (e.g. Xxx_ROOT_DIR
). For the same reason, mark
most cache options as advanced. For packages which provide both debug
and release binaries, it is common to create cache variables with a
_LIBRARY_<CONFIG>
suffix, such as Foo_LIBRARY_RELEASE
and
Foo_LIBRARY_DEBUG
.
While these are the standard variable names, you should provide backwards compatibility for any old names that were actually in use. Make sure you comment them as deprecated, so that no-one starts using them.
A Sample Find Module¶
We will describe how to create a simple find module for a library
Foo
.
The first thing that is needed is documentation. CMake’s documentation system requires you to start the file with a documentation marker and the name of the module. You should follow this with a simple statement of what the module does.
#.rst:
# FindFoo
# -------
#
# Finds the Foo library
#
More description may be required for some packages. If there are caveats or other details users of the module should be aware of, you can add further paragraphs below this. Then you need to document what variables and imported targets are set by the module, such as
# This will define the following variables::
#
# Foo_FOUND - True if the system has the Foo library
# Foo_VERSION - The version of the Foo library which was found
#
# and the following imported targets::
#
# Foo::Foo - The Foo library
If the package provides any macros, they should be listed here, but can be documented where they are defined. See the Module Documentation section above for more details.
After the documentation, leave a blank line, and then add a copyright and licence notice block
#=============================================================================
# Copyright 2009-2011 Your Name
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
Now the actual libraries and so on have to be found. The code here will obviously vary from module to module (dealing with that, after all, is the point of find modules), but there tends to be a common pattern for libraries.
First, we try to use pkg-config
to find the library. Note that we
cannot rely on this, as it may not be available, but it provides a good
starting point.
find_package(PkgConfig)
pkg_check_modules(PC_Foo QUIET Foo)
This should define some variables starting PC_Foo_
that contain the
information from the Foo.pc
file.
Now we need to find the libraries and include files; we use the
information from pkg-config
to provide hints to CMake about where to
look.
find_path(Foo_INCLUDE_DIR
NAMES foo.h
PATHS ${PC_Foo_INCLUDE_DIRS}
PATH_SUFFIXES Foo
)
find_library(Foo_LIBRARY
NAMES foo
PATHS ${PC_Foo_LIBRARY_DIRS}
)
If you have a good way of getting the version (from a header file, for
example), you can use that information to set Foo_VERSION
(although
note that find modules have traditionally used Foo_VERSION_STRING
,
so you may want to set both). Otherwise, attempt to use the information
from pkg-config
set(Foo_VERSION ${PC_Foo_VERSION})
Now we can use FindPackageHandleStandardArgs
to do most of the
rest of the work for us
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Foo
FOUND_VAR Foo_FOUND
REQUIRED_VARS
Foo_LIBRARY
Foo_INCLUDE_DIR
VERSION_VAR Foo_VERSION
)
This will check that the REQUIRED_VARS
contain values (that do not
end in -NOTFOUND
) and set Foo_FOUND
appropriately. It will also
cache those values. If Foo_VERSION
is set, and a required version
was passed to find_package()
, it will check the requested version
against the one in Foo_VERSION
. It will also print messages as
appropriate; note that if the package was found, it will print the
contents of the first required variable to indicate where it was found.
At this point, we have to provide a way for users of the find module to link to the library or libraries that were found. There are two approaches, as discussed in the Find Modules section above. The traditional variable approach looks like
if(Foo_FOUND)
set(Foo_LIBRARIES ${Foo_LIBRARY})
set(Foo_INCLUDE_DIRS ${Foo_INCLUDE_DIR})
set(Foo_DEFINITIONS ${PC_Foo_CFLAGS_OTHER})
endif()
If more than one library was found, all of them should be included in these variables (see the Standard Variable Names section for more information).
When providing imported targets, these should be namespaced (hence the
Foo::
prefix); CMake will recognize that values passed to
target_link_libraries()
that contain ::
in their name are
supposed to be imported targets (rather than just library names), and
will produce appropriate diagnostic messages if that target does not
exist (see policy CMP0028
).
if(Foo_FOUND AND NOT TARGET Foo::Foo)
add_library(Foo::Foo UNKNOWN IMPORTED)
set_target_properties(Foo::Foo PROPERTIES
IMPORTED_LOCATION "${Foo_LIBRARY}"
INTERFACE_COMPILE_OPTIONS "${PC_Foo_CFLAGS_OTHER}"
INTERFACE_INCLUDE_DIRECTORIES "${Foo_INCLUDE_DIR}"
)
endif()
One thing to note about this is that the INTERFACE_INCLUDE_DIRECTORIES
and
similar properties should only contain information about the target itself, and
not any of its dependencies. Instead, those dependencies should also be
targets, and CMake should be told that they are dependencies of this target.
CMake will then combine all the necessary information automatically.
The type of the IMPORTED
target created in the
add_library()
command can always be specified as UNKNOWN
type. This simplifies the code in cases where static or shared variants may
be found, and CMake will determine the type by inspecting the files.
If the library is available with multiple configurations, the
IMPORTED_CONFIGURATIONS
target property should also be
populated:
if(Foo_FOUND)
if (NOT TARGET Foo::Foo)
add_library(Foo::Foo UNKNOWN IMPORTED)
endif()
if (Foo_LIBRARY_RELEASE)
set_property(TARGET Foo::Foo APPEND PROPERTY
IMPORTED_CONFIGURATIONS RELEASE
)
set_target_properties(Foo::Foo PROPERTIES
IMPORTED_LOCATION_RELEASE "${Foo_LIBRARY_RELEASE}"
)
endif()
if (Foo_LIBRARY_DEBUG)
set_property(TARGET Foo::Foo APPEND PROPERTY
IMPORTED_CONFIGURATIONS DEBUG
)
set_target_properties(Foo::Foo PROPERTIES
IMPORTED_LOCATION_DEBUG "${Foo_LIBRARY_DEBUG}"
)
endif()
set_target_properties(Foo::Foo PROPERTIES
INTERFACE_COMPILE_OPTIONS "${PC_Foo_CFLAGS_OTHER}"
INTERFACE_INCLUDE_DIRECTORIES "${Foo_INCLUDE_DIR}"
)
endif()
The RELEASE
variant should be listed first in the property
so that that variant is chosen if the user uses a configuration which is
not an exact match for any listed IMPORTED_CONFIGURATIONS
.
Most of the cache variables should be hidden in the ccmake
interface unless
the user explicitly asks to edit them.
mark_as_advanced(
Foo_INCLUDE_DIR
Foo_LIBRARY
)
If this module replaces an older version, you should set compatibility variables to cause the least disruption possible.
# compatibility variables
set(Foo_VERSION_STRING ${Foo_VERSION})


The Great Debaters
The Great Debaters is a movie starring Denzel Washington, Forest Whitaker, and Kimberly Elise. A drama based on the true story of Melvin B. Tolson, a professor at Wiley College Texas. In 1935, he inspired students to form the...


Panels help you contextually separate sections of your code which out to be presented in their own place.
Compartmentalizing your content in a visually effective manner is done thus:


{{ .Stats.NumberTotal }} White House petitions have met their signature thresholds
The White House has responded to {{ .Stats.NumberResponse }} of them ({{ .Stats.PercentResponded }}%) with an average response time of {{ .Stats.AverageResponse }} days
Average waiting time so far for {{ .Stats.NumberPending }} unanswered petitions: {{ .Stats.AveragePending }} days


--- title: Snickers image: /images/chocolate/Snickers.jpg ---
Frank Mars, founder of Mars, Inc. (originally called Mar-O-Bar Co.), invented the Snickers bar in 1930. The candy bar is named after one of Frank Mars' favorite horses, Snickers. But until 1990, the bar was sold under the name “Marathon” in the United Kingdom, the Isle of Man, and Ireland.


NBCC (India) Consolidated September 2019 Net Sales at Rs 1,665.57 crore, up 18.47% Y-o-Y
Reported Consolidated quarterly numbers for NBCC (India) are:
Net Sales at Rs 1,665.57 crore in September 2019 up 18.47% from Rs. 1,405.88 crore in September 2018.
Quarterly Net Loss at Rs. 99.19 crore in September 2019 down 230.09% from Rs. 76.25 crore in September 2018.
EBITDA stands at Rs. 53.42 crore in September 2019 down 49.15% from Rs. 105.05 crore in September 2018.
NBCC (India) shares closed at 37.30 on November 14, 2019 (NSE) and has given -30.73% returns over the last 6 months and -43.10% over the last 12 months.
| NBCC (India) | |
| Consolidated Quarterly Results | in Rs. Cr. |
| Sep'19 | Jun'19 | Sep'18 | |
| Net Sales/Income from operations | 1,656.32 | 1,885.76 | 1,366.41 |
| Other Operating Income | 9.25 | 5.37 | 39.47 |
| Total Income From Operations | 1,665.57 | 1,891.13 | 1,405.88 |
| EXPENDITURE | |||
| Consumption of Raw Materials | 0.54 | 0.34 | 0.26 |
| Purchase of Traded Goods | -- | -- | -- |
| Increase/Decrease in Stocks | -13.94 | -9.95 | 18.71 |
| Power & Fuel | -- | -- | -- |
| Employees Cost | 87.53 | 82.91 | 69.31 |
| Depreciation | 0.95 | 2.02 | 0.05 |
| Excise Duty | -- | -- | -- |
| Admin. And Selling Expenses | -- | -- | -- |
| R & D Expenses | -- | -- | -- |
| Provisions And Contingencies | 17.05 | 19.97 | 23.89 |
| Exp. Capitalised | -- | -- | -- |
| Other Expenses | 1,575.88 | 1,770.76 | 1,248.09 |
| P/L Before Other Inc., Int., Excpt. Items & Tax | -2.42 | 25.08 | 45.57 |
| Other Income | 54.89 | 50.61 | 59.43 |
| P/L Before Int., Excpt. Items & Tax | 52.47 | 75.69 | 105.00 |
| Interest | 1.34 | 2.65 | -0.89 |
| P/L Before Exceptional Items & Tax | 51.12 | 73.03 | 105.88 |
| Exceptional Items | -- | -- | -- |
| P/L Before Tax | 51.12 | 73.03 | 105.88 |
| Tax | 142.13 | 22.11 | 33.34 |
| P/L After Tax from Ordinary Activities | -91.01 | 50.92 | 72.55 |
| Prior Year Adjustments | -- | -- | -- |
| Extra Ordinary Items | -- | -- | -- |
| Net Profit/(Loss) For the Period | -91.01 | 50.92 | 72.55 |
| Minority Interest | -8.27 | -2.56 | 3.48 |
| Share Of P/L Of Associates | 0.10 | 0.54 | 0.22 |
| Net P/L After M.I & Associates | -99.19 | 48.90 | 76.25 |
| Equity Share Capital | 180.00 | 180.00 | 180.00 |
| Reserves Excluding Revaluation Reserves | -- | -- | -- |
| Equity Dividend Rate (%) | -- | -- | -- |
| EPS Before Extra Ordinary | |||
| Basic EPS | -0.55 | 0.27 | 0.42 |
| Diluted EPS | -0.55 | 0.27 | 0.42 |
| EPS After Extra Ordinary | |||
| Basic EPS | -0.55 | 0.27 | 0.42 |
| Diluted EPS | -0.55 | 0.27 | 0.42 |
| Public Share Holding | |||
| No Of Shares (Crores) | -- | -- | -- |
| Share Holding (%) | -- | -- | -- |
| Promoters and Promoter Group Shareholding | |||
| a) Pledged/Encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| b) Non-encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| Source : Dion Global Solutions Limited |


Get(RecordModificationCount)Returns the total number of times changes to the current record have been committed.
• click out of all fields (exit the record)
• If the current calculation is stored and you specify its context, this function will be evaluated based on that context; otherwise, it will be evaluated based on the context of the current window.
• Get(RecordModificationCount)returns NULL for ODBC data sources.
• Returns 0 if the record has not been modified since it was created.


{{ story?.title }} Published on {{ story?.created_at | date: "mediumDate" }} {{ story?.comments_count }} {{ story?.likes_count }} {{ story?.summary }}


Paragraph Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam.
Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam.
Steve Jobs, CEO Apple
Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet.
Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet.
Creative Tim symbolizes the creative spirit inside of each and everyone of us. A designer by trade, he enjoys making the World Wide Web a more beautiful place and helping others do the same.
Creative Tim stands for everything a designer looks in his work: clean, functions interfaces for great products. The number of friends with similar attitude can only increase over time, since the vision for a better web is a wish of many designers. Be sure to enroll and browse around for anything that may brng extra value to your project and ask Tim wherever you see something missing.
Tim thinks communication is key and he enjoys all the feedback you give him. If you have any ideas about how he could make our community better or even if you have any questions or complaints drop him a line.


??
???
?
?
?
6
7
8
9
10
S=:_
The
New
York
copyright
reserved
Botanical
Garden
Plants
of
the
West
Indies
St.
Vincent
Enicostemma
verticillatum
(L)
Thick
leafed
herb
on
dry
coastal
area;
flowers
white.
Fancy
area.
R.
A.
Howard
17798
G.
R.
Cooley
R.
E.
Weaver,
Jr.
March
7,
1971
1624500
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Event Location:
Microsoft Building 33
16070 NE 36th Way
Redmond, Washington
Abstract:
Elastic Database Tools for Azure SQL DB offers a set of features that make it easier to build and manage a scaled-out data tier for cloud applications. With elastic database tools, applications can easily access data spanning multiple DBs, coordinate management tasks and manage how data is distributed among them. As part of the session, we explore workloads that are a natural fit for Azure SQL DB's elastic database tools. Patterns discussed in depth include multi-tenant applications created by cloud ISVs and SaaS vendors, and applications relying on temporal data distribution. The session will illustrate how easy it is now to build, scale and manage cloud applications in SQL DB when using elastic tools capabilities such as the elastic database client library for .NET.
Speaker(s): Silvia Doomra,
Abstract:
Extended Events are used to gather a wide range of performance information to help troubleshoot performance problems in SQL Server. The system_health session is an Extended Events session that is included by default with SQL Server. This session starts automatically when the SQL Server database engine starts, and runs without any noticeable performance effects. This presentations will take you on an in-depth tour of the data provided in the system_health event session and how to use it to troubleshoot performance issues. Cases studies from real-life examples will be used to demonstrate tips and tricks.
Speaker(s): Janis Griffin,
Abstract:
Most DBAs need to use multiple native and third party tools to fully document SQL Server instances yet still dont get all the objects. Even using Visual Studio and Database Projects, not all objects are exportable and live at the server level, above the database. Using Powershell, we will script out an organized set of files that can be checked into any Source Control system and or used for moving or recovering a SQL server instance for Disaster Recovery purposes. Objects exported include: SQL Agent Jobs/Alerts/Schedules, NT Service Credentials, SSIS-MSDB, SSIS-Catalog, SSAS Cubes, SSRS Reports, Logins, Server Configs, Linked Servers, DB Mail Operators/Accounts, and Server Triggers
Speaker(s): George Walkey,
Abstract:
There are many rules, suggestions and tips that tell you to do this or don’t do that with TempDB. In this session we will explore the reasons behind many of the recommendations or best practices for TempDB. We will start by taking a look at what TempDB is, how it is used, and why this is important to your SQL Server. Next explore why TempDB needs more than one file and how many files TempDB is needed? We will look at why TempDB should be on a different logical drive, even if you are using a SAN. Explore why you should run DBCC CheckDB on my TempDB. Does the auto growth on TempDB really matter, what are these VLFs and how does that impact performance? Take away the knowledge that you need to properly manage TempDB on all your SQL Servers.
Speaker(s): Steve Stedman,
Abstract:
When asked to design a critical database system, too many people pick an HA feature and then design the solution around it. This usually results in a costly and disappointing design. This session will show you the five basic archetypes for mission critical database systems and how to select the right features from SQL Server to implement each design. Along the way you’ll hear best practices, tips, and real world advice for features like Availability Groups, clustered instances of SQL Server, as well as the history of some of the more interesting and less often used availability features. While you may not be able to revisit your current designs right away, what you learn will make you the hero of your next mission critical deployment.
Speaker(s): Maxwell Myrick,
Abstract:
You've read about table partitioning; you know that partitioning ‘promises’ to solve some performance issues, make backups -and even restores, faster, and, wait, wait, there’s more! Perhaps you have worked through demo code and set up a POC scenario. It looks good, like maybe it would solve some of the problems your organization faces. But … You’re just not sure how to pull it off. Sure, the demo code made it seem easy -and it will always be realtively simple for new tables, new data. You have a handle on the ‘basics’. However, your production database has very large tables, hundreds of millions, or even billions, of rows. The SLA does not allow much, if any, downtime. This session will look at how Table Partitioning can be introduced into existing production environments with little or no downtime And we will explore the ‘real’ performance and maintenance benefits that can be harvested. So, if you want to move beyond the ‘Basics’, don’t miss this session.
Speaker(s): Arnie Rowland,
Abstract:
Transactional replication in SQL Server is great tool for scaling out your application's primary database(s) workload onto other servers with near real-time data propagation. In this session, I will cover data replication tricks-of-the-trade to offload work from your primary database onto other replicated servers. I will show you custom and traditional replication monitoring techniques and performance profiles that you can use to improve your performance and monitoring of your existing replication installations or gain new knowledge and confidence to implement replication for your company. I will also cover how AlwaysOn Availability Groups differs and why I sometimes still choose transactional replication for scaling SQL Server.
Speaker(s): Chuck Lathrope,
Abstract:
Even if you don’t have a full-fledged Master Data project, there are use cases where SQL Server Master Data Services brings helpful tools to the table. For example, if you have data in Excel that your business wants to manage for compliance and/or wants to integrate, or have a requirement to augment data in a data warehouse dimension (such as adding and maintaining an attribute or grouping that isn’t present in the upstream system), MDS has functionality that can help you solve the problem. This presentation will outline some of the core MDS functionality and will provide detailed walk-throughs of functionality used to solve business problems using MDS.
Speaker(s): Steve Moss,
Abstract:
The updateable clustered columnstore in SQL Server 2014 offers a leading solution for your data warehouse workload with order of magnitude better data compression and query performance over traditional btree-based schemas. This session describes columnstore index internals with deep insight into data compression methodology for achieving high query performance including improvements in column store investments for SQL Server 2016
Speaker(s): Sunil Agarwal,
Abstract:
Performance troubleshooting doesn't have to be hard, yet getting good at it requires a methodology, practice, and learning a few tools, and a bit about internals. In this session we'll simulate an I/O bottleneck and walk through the steps required to identify and remediate the problem. You'll learn how to identify an I/O issue using Wait Stats, Virtual File Stats, and PerfMon. We'll talk about relevant metrics, how to zero in on a problem, and how a healthy disk I/O subsystem performs. You’ll return to the office with a suite of tips and tools that will get you on your way to becoming a Performance Tuning Superstar!
Speaker(s): Theresa Iserman,
Abstract:
TSQL is a necessity when interacting with SQL Server so knowing can be half the battle. Performance is always good as the database starts to grow, but building in resilience when you begin is a greater advantage than refactoring. I will go over 5 key things to know when you write TSQL, use DataTypes and/or variables in comparisons and you will also learn about the procedure cache and how to avoid pitfalls there. This is a beginners session but the concepts in this session are a great foundation to begin with. If you are looking for a solid foundation to build on and need the basics to start, this session is definitely for you.
Speaker(s): Ben Miller,
Abstract:
Extended Events in SQL Server provides a huge opportunity to debug and analyze complex problems with ease. Join me to understand the diagnostics enhancements available in SQL Server database engine in SQL Server 2012 Service Pack 3 and above. After this session, you will be able to leverage the diagnostics to troubleshoot and mitigate issues quickly in mission-critical environments and simplify troubleshooting experience for common SQL Server scenarios.
Speaker(s): Amit Banerjee,
Abstract:
For many engineers, interpreting disk I/O is a black art. Yet analyzing perfmon, virtual file stats, wait stats is typically straightforward. This session provides authoritative, clear guidance on collecting interpreting disk I/O metrics.
Speaker(s): J May,
Abstract:
DBAs have a unique job profile that caters to work-life imbalance. How can our spouses expect to be first in our lives when they aren't? At your kid's play and the pager goes off? At Valentine's dinner date and your manager calls? Ever try sleeping through the night during a maintenance weekend? Every one of these is a common occurance that gets interrupted when you are a DBA with on-call duties and they have their consequences. If you are getting in to being a DBA, you need to know what that means to your life, and learn a few techniques to help keep you in balance and not be another burned out techie.
Speaker(s): Eric Crew,
Abstract:
SQL Server 16 enables customers can run analytic queries on in-memory and disk-based OLTP tables with minimal impact on business critical OLTP workloads, requiring no application changes. This session covers various configurations and best practices for achieving significant performance gains with Operational Analytics.
Speaker(s): Sunil Agarwal,
Abstract:
Using Wait Types and Response Time Analysis is a proven methodology for tuning SQL Server instances and applications. However, there is often confusion on exactly what the data represents. The issue typically centers around the fact the response time data is analyzed at the wrong level and is not detailed enough. This presentation will focus on these problems and review several real-life case studies of using SQL Server wait types coupled with response time analytics to solve the most difficult performance issues.
Speaker(s): Dean Richards,
Abstract:
There are over 800 wait types in SQL Server 2014, but there are only 10 (in my experience) that are seen very often. If you can learn these 10 wait types, what causes them and their solutions, you will be ahead of the performance analysis game. The list of 10 wait types to be discussed came from over 100 consulting engagements with customers, so come find out what they are and improve your performance troubleshooting skills.
Speaker(s): Janis Griffin,
Abstract:
An interactive panel discussion will kick off with personal stories of how we change, intentionally or not, through our career(s). Topics will range from how diversity affects our experiences and choices to being intentional throughout our careers. Come with your own experiences and questions! Cindy Gross / Panelists: Aviva Stephens, Julie Koesmarno, Scott Senkeresty, Sonia Carlson
Speaker(s): Cindy Gross,
Abstract:
Choosing appropriate performance levels, monitoring and optimizing resource usage of Azure SQL database is of primary interest to SQL database users. Azure SQL DB now has a number of great tools to help sizing, scaling, monitoring and performance tuning your database solutions. This talk will provide an overview of resource usage monitoring, scaling capabilities and techniques as well as performance tuning tools that you can use today, such as Query Store, Index Advisor, Extended Events and DMVs
Speaker(s): Julie Koesmarno,
Abstract:
Without temporal tables (AKA history tables), we can only see the current version of data. We can’t see rows that have been deleted or rows as they existed before the latest update. The temporal table support in SQL Server 2016 gives us the ability to create system maintained “history” tables to track all changes to the table data. In this session we’ll discuss how you can benefit from temporal support in your tables, how to implement temporal tables in SQL Server 2016, and how to write “time travel queries” using the new FOR SYSTEM_TIME clause in a SELECT statement to easily query historical information.
Speaker(s): Vern Rabe,
Abstract:
Come see Microsoft's Power tools demonstrated for advanced analytics and hear about Microsoft's embrace of Open Source and the Hadoop platform. We'll also present on Microsoft's tools for handling Big Data, such as the Parallel Data Warehouse and HDInsights.
Speaker(s): David Patrick,
Abstract:
*** Vendor Session *** All-Flash Arrays deliver IOPS in abundance. XtremIO goes further to provide predictable, consistent sub-millisecond latency and unleash agility for your SQL Server databases. Our unique XtremIO Virtual Copies (XVC) capabilities allow for fully writable copies for production, test/dev, reporting/analytics workloads on our market leading consolidation platform. This allows for consolidation of your SQL Server based environments onto a single array to maximize efficiency.
Speaker(s): Bryan Walsh,
Abstract:
Have you ever wanted to know how Transparent Database Encryption (TDE) works or how you set it up? What about encrypting your backups? This session will go over all the steps and caveats that go with this technology. TDE allows you to have your database encrypted on disk and the same Encryption Hierarchy allows you to back up your database and have it encrypt the contents in the backup file. We will discuss the Encryption Hierarchy which is used for encryption in SQL Server and take you through keeping your secrets safe. Master the concepts of SQL Server Encryption when you are done with this session.
Speaker(s): Ben Miller,
Abstract:
People love patterns. We simplify our lives by categorizing all day long – things, activities, and even people. Categories let us make sense of a constant bombardment of sensations. But what happens when we unconsciously categorize someone at work? How do these categories box us in? Let’s talk about what we can do to shake up those categories and drive towards a more diverse and productive workplace.
Speaker(s): Cindy Gross,
Abstract:
When the SQL Server optimizer evaluates a query to determine how best to execute it, the statistics are quite possibly the most important tool at its disposal. But SQL Server statistics objects aren’t perfect because they only contain summary information. In this session, we’ll start with an overview of what the statistics objects are, how the optimizer uses them, and some general guidelines for their maintenance. Then we’ll look at some of the issues – and solutions – that can arise due to their imperfection: ascending keys, correlated predicates, skewed distribution, or downright bad summary information.
Speaker(s): Vern Rabe,
Abstract:
With R in SQL Server 2016, data engineers (DBAs, developers) are expanding their horizons and deriving more value for the business from their data. Advanced Analytics with R in SQL Server 2016 brings the traditional data engineers and data scientists together to generate greater business value. We will explore a few customer examples who are leveraging R with SQL Server today and how they are doing it.
Speaker(s): Sanjay Mishra,
Abstract:
In this session attendees will learn about the new SQL Server 2016 feature known as Always Encrypted. Attendees will find out about the different encryption types that can be used with Always Encrypted columns, as well as the limitations of these encryption types. Additionally this session attendees teach attendees how to populate Always Encrypted columns, as well as how to encrypt existing data using the Always Encrypted feature. This sessions will have a number of demo's demonstrating how to keep your confidential data out of the prying eyes of your DBA.
Speaker(s): Greg Larsen,
Abstract:
This session is a deep dive into query plans and is presented by a former Microsoft PFE (Field Engineer). Learn how a Microsoft Engineer looks at plans and go beyond the typical! There will be plenty of demos and a lot to learn. Join me as I cover the "noteworthy" query plan patterns that go beyond the normal areas that customer tend to investigate. This session covers SQL Server 2005 forward and includes the new SQL Server 2016 Query Store and Live Query Statistics.
Speaker(s): Daniel Janik,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: http://www.linkedin.com/pub/vern-rabe/a/ba3/980
Contact: http://www.rabedata.com
Vern Rabe is an independent SQL Server consultant and contract trainer in Portland, OR, and leader of the Oregon Data Community user group, formerly OregonSQL. He has attained MCSE, MCITP (both Administration and Development), and MCT certifications, among others. Vern has been passionate about databases since 1992 and has worked with SQL Server since version 4.21a. He provides broad technical SQL Server knowledge gained from the mixture of academic and practical experiences acquired from his classroom instructing and varied consulting contracts. Vern regularly presents technical sessions at SQL Server user group meetings, SQLSaturdays, and PASS Summit.
LinkedIn: http://www.linkedin.com/in/stevestedman
Contact: http://SteveStedman.com
Steve Stedman is the Leader of a PASS Local Group in Bellingham WA USA. Steve runs his own SQL consulting firm Stedman Solutions, LLC. He has 29 years of programming and SQL experience. He has written the book on SQL Common Table Expressions. He teaches, speaks at conferences, writes, and has taught SQL server classes at Western Washington University. Steve has previously spoken at PASS Summit, TechEd, DevTeach Vancouver, many SQL Saturdays, and more.
LinkedIn: https://www.linkedin.com/in/grlarsen/
Greg Larsen has been working with SQL Server since 1999. He has authored 100's of articles related to SQL Server. He holds a MCSE Data Management and Analytics. Greg also a SQL Server Consultant, adjunct professor and technical writer.
LinkedIn: http://in.linkedin.com/pub/amit-banerjee/20/64a/852
Contact: http://www.troubleshootingsql.com
I am a data professional with over a decade of experience in Relational Database Management Systems. I lead Program Management for the SQL Server engineering team focusing on the SQL Server database engine (Windows and Linux) and Azure SQL Edge. My past experiences include Program Management for Business Continuity and Disaster Recovery (HADR), Data Movement and Performance for SQL Server, Azure Database for PostgreSQL and Azure Database for MySQL. I am an active blogger, co-author of Pro SQL Server on Microsoft Azure and Professional SQL Server 2012: Internals and Troubleshooting and a regular speaker at various community events like Microsoft Ignite, SQL PASS, TechEd, Virtual Tech Days, SQL Saturday and User Group meetin
LinkedIn: http://www.linkedin.com/in/stevestedman
Contact: http://SteveStedman.com
Steve Stedman is the Leader of a PASS Local Group in Bellingham WA USA. Steve runs his own SQL consulting firm Stedman Solutions, LLC. He has 29 years of programming and SQL experience. He has written the book on SQL Common Table Expressions. He teaches, speaks at conferences, writes, and has taught SQL server classes at Western Washington University. Steve has previously spoken at PASS Summit, TechEd, DevTeach Vancouver, many SQL Saturdays, and more.
LinkedIn: http://www.linkedin.com/in/cindygross/
Contact: http://befriendingdragons.com
Cindy Gross is an Adaptive Community Leader founder of Befriending Dragons. She nurtures equitable tech cultures where everyone thrives and belongs. That starts with a foundation where workplace bullies and harassers are not tolerated. Cindy has met many scary dragons in her life – breast cancer, divorce, a layoff, changing roles and technologies, workplace harassment as a Microsoft woman in tech, constant striving to meet some impossible to meet bar for success, and the idea that we always have to put work first. Most recently she left the corporate world to strike out on her own, into a rich community filled with people who create justice, meaning, allies, and dreams.
LinkedIn: http://www.linkedin.com/in/theresaiserman/
Theresa Iserman is a SQL Server Premier Field Engineer at Microsoft. She’s been working with databases for over 15 years and has held roles working with transactional amp; data warehouse systems, web application development, amp; technical project management. Theresa tweets at www.twitter.com/theresaiserman
A seasoned professional with 30+ years of industry experience in databases, Sunil has worked as a lead developer for relational database engine solutions, as a tool designer for backup and restore technologies and as a development manager for B2B commerce and e-learning solutions. He has been in his role as a Principal Program Manager for SQL Server for the last 12+ years. Sunil has authored many technical white papers and blogs, and has co-authored two books on SQL Server and has presented database technologies in numerous national and international conferences. He enjoys teaching and has taught introductory programming courses at the University of Rhode Island and the University of Colorado.
LinkedIn: http://www.linkedin.com/in/davidepatrick
Contact: http://www.madsharepoint.com
Dave has been developing database applications for over 25 years. An MCT since 2001, he has taught many classes from Intro to Visual Interdev to Advanced SharePoint Development. Dave runs two user groups, the Maryland and Pennsylvania Microsoft Developers User Group, www.mapamdug.com, and MAD SharePoint, www.madsharepoint.com. Dave does SharePoint training and development for DSA, Inc., a DoD contractor that does great work for the Army over at Aberdeen Proving Ground. Dave is also an MVP.
LinkedIn: http://www.linkedin.com/in/juliekoesmarno
Contact: http://www.mssqlgirl.com
Julie Koesmarno, MCSE Data Platform, and MCSE Business Intelligence, MCT, is a Senior Program Manager at Microsoft, with a Bachelor’s degree in IT. She has over 10 years of experience working with SQL Server for large-scale and multi-million-dollar OLTP and ETL projects as a SQL Server developer and system analyst/designer. Her past projects include delivering a SQL Server 2012 data warehouse and BI solutions in the US and Australia. She now works with hybrid, cloud and on-prem SQL projects.
LinkedIn: http://www.linkedin.com/in/dbaduck/
Contact: https://dbaduck.com
Ben has been a member of the SQL Server Community since 2000. He loves a challenge and has fixed many SQL Servers and helped hundreds of people get more out of their DBA jobs. He is a Data Platform MVP a SQL Server Certified Master (MCM). He has worked at various companies throughout the USA, as well as at Microsoft for 7 years. He is passionate about SQL Server Infrastructure, High Availability, Automation and Integration using SMO and PowerShell. He teaches DBAs how to use PowerShell to do their job and teaches SQL Server Internals. He is @DBAduck all around the web (Twitter, LinkedIn, Facebook, Blog) so let's catch up.
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
LinkedIn: http://www.linkedin.com/pub/dean-richards/6/167/a90
Dean Richards is a Senior DBA for DBMS Insights and has helped hundreds of companies solve database and virtualization performance issues. Dean has over 20 years of experience in both development and database administration and has focused his entire career on performance tuning of Oracle and SQL Server environments. Most recently Dean has focused on the trend to virtualize and move databases to the cloud.
A seasoned professional with 30+ years of industry experience in databases, Sunil has worked as a lead developer for relational database engine solutions, as a tool designer for backup and restore technologies and as a development manager for B2B commerce and e-learning solutions. He has been in his role as a Principal Program Manager for SQL Server for the last 12+ years. Sunil has authored many technical white papers and blogs, and has co-authored two books on SQL Server and has presented database technologies in numerous national and international conferences. He enjoys teaching and has taught introductory programming courses at the University of Rhode Island and the University of Colorado.
LinkedIn: https://www.linkedin.com/pub/steve-moss/13/9b0/912
Steve Moss is a Solutions Architect consulting in data and business intelligence with Slalom Portland . He is passionate about delivering enterprise data architecture solutions, the performance of data systems and data quality/master data management and in particular Azure Data technologies. He has over 18 years experience in SQL Server including roles as BI Architect, Data Architect, DBA Manager, Sr. DBA and .Net Developer. He has previously presented at SQL Saturday Redmond, SQL Saturday Oregon (4 years). He has attended Microsoft's internal Cloud Solution Architect Training and is also a Certified AWS Solution Architect - Associate.
20 years into a career focused on Microsoft technologies and the impact of they make for companies across all industries and verticals. Started at EMC in 2006 and have held numerous leadership roles that champion Microsoft to our field, partners and customers. In my current role at XtremIO, my primary focus is SQL Server and how to unlock agility and end storage inefficiency.
LinkedIn: https://www.linkedin.com/in/arnie
Contact: http://sqlblog.com/blogs/arnie_rowland/
Arnie long ago realized that most issues between Developer and DBA comes from incomplete communication and a misunderstanding of each other's objectives. He is a frequent Trainer and Mentor for Developers and DBAs, bringing both sets of skills to better communicate with teams to create a working solution. For over a decade, Arnie has been a SQL Server MVP, Certified Trainer, technical editor for several publishers, including MOC, and has served as University and Community College adjunct faculty. Clients include Fortune 500 and Multi-Nationals, Federal and State agencies, Foreign governments, and local enterprises –both public and private.
Contact: http://insyncva.com
SQL Server DBA, Developer, IT Manager, Business Owner from the Richmond, VA USA Area Interested in pushing the limits of both hardware software and my own brain
Sanjay Mishra is a product management leader in the Azure Data product team, leading the Azure SQL Database family of products. Prior to this role, he worked in the AzureCAT organization for 14 years where he managed the SQLCAT and DataCAT teams.
LinkedIn: https://www.linkedin.com/in/silviadoomra?
Silvia is a Program Manager in Azure SQL Database Team. She has experience of over 8 years in Microsoft working on different technologies like Windows Server, Visual Studio, Mobile Operators. Currently she is working in Azure SQL Database team building scale-out database technologies.
LinkedIn: http://www.linkedin.com/in/aspiringgeek
Contact: http://blogs.msdn.com/jimmymay
Jimmy May is a Microsoft Certified Master (MCM). He's formerly a Principal Architect at Microsoft as well as Senior Program Manager for the SQL Server Customer Advisory Team (SQL CAT) where he managed the Customer Lab which hosts the biggest, fastest, most interesting SQL Server apps from all over the world. More recently he was a SQL Server Technologist for what was Fusion-io's Data Propulsion Lab (DPL). He is a founder of the IndyPASS IWUG user groups.
LinkedIn: http://www.linkedin.com/pub/vern-rabe/a/ba3/980
Contact: http://www.rabedata.com
Vern Rabe is an independent SQL Server consultant and contract trainer in Portland, OR, and leader of the Oregon Data Community user group, formerly OregonSQL. He has attained MCSE, MCITP (both Administration and Development), and MCT certifications, among others. Vern has been passionate about databases since 1992 and has worked with SQL Server since version 4.21a. He provides broad technical SQL Server knowledge gained from the mixture of academic and practical experiences acquired from his classroom instructing and varied consulting contracts. Vern regularly presents technical sessions at SQL Server user group meetings, SQLSaturdays, and PASS Summit.
LinkedIn: https://www.linkedin.com/in/eric-crew-2300451b
Inventor, geek, and SQL poet... The most important thing we can learn is how to learn - a huge passion of mine. I want to learn it all, I want to work with others to help eachother in new pursuits. I#39;ve been coding in SQL since MS Access, and a DBA since SLQ2000 came out... and I love it all (except cursors... except in Oracle... argh, it depends!). The life of a DBA is hard to balance, as there is no Active/Active or AlwaysOn for your life.
LinkedIn: http://www.linkedin.com/pub/janis-griffin/0/914/aba
Janis Griffin has over 30 years of DBA/database experience including design, development and implementation of many critical database applications. Before coming to Quest Software, Janis primarily worked in the Telecom/Network Industry, working with both real-time network routing databases and OLTP business to business applications. Janis also held positions as a Principal Architect and Senior Manager, mentoring other DBAs on best practices in database performance tuning.
LinkedIn: https://www.linkedin.com/company/sqlha
Contact: http://sqlha.com/blog
Max Myrick is a SQL Server consultant whose experience includes 15 years at Microsoft with 5 years on the SQL Server development team where he ran the SQL Customer Lab and then the Sustained Engineering team. He was an founding member of Microsoft#39;s Mission Critical team where he worked with the largest SQL Server applications worldwide for almost a decade. Max was a regular speaker for Microsoft and has continued to speak at various PASS and other SQL Conferences since becoming a managing partner of SQLHA LLC.
LinkedIn: http://www.linkedin.com/pub/daniel-janik/12/15b/606/en
Contact: http://www.sqltechblog.com
Daniel Janik has been supporting SQL Server for 18 years. Six of those years were at Microsoft Corporation supporting SQL Server as a Senior Premier Field Engineer (PFE) where he supported over 287 different clients with both reactive and proactive database needs. Daniel has presented at many community events and SQL Saturdays.
LinkedIn: http://www.linkedin.com/in/dbaduck/
Contact: https://dbaduck.com
Ben has been a member of the SQL Server Community since 2000. He loves a challenge and has fixed many SQL Servers and helped hundreds of people get more out of their DBA jobs. He is a Data Platform MVP a SQL Server Certified Master (MCM). He has worked at various companies throughout the USA, as well as at Microsoft for 7 years. He is passionate about SQL Server Infrastructure, High Availability, Automation and Integration using SMO and PowerShell. He teaches DBAs how to use PowerShell to do their job and teaches SQL Server Internals. He is @DBAduck all around the web (Twitter, LinkedIn, Facebook, Blog) so let's catch up.
LinkedIn: http://www.linkedin.com/in/cindygross/
Contact: http://befriendingdragons.com
Cindy Gross is an Adaptive Community Leader founder of Befriending Dragons. She nurtures equitable tech cultures where everyone thrives and belongs. That starts with a foundation where workplace bullies and harassers are not tolerated. Cindy has met many scary dragons in her life – breast cancer, divorce, a layoff, changing roles and technologies, workplace harassment as a Microsoft woman in tech, constant striving to meet some impossible to meet bar for success, and the idea that we always have to put work first. Most recently she left the corporate world to strike out on her own, into a rich community filled with people who create justice, meaning, allies, and dreams.
LinkedIn: https://www.linkedin.com/in/chucklathrope
Contact: http://www.sqlwebpedia.com
Chuck Lathrope is a data architect for Limeade, a SaaS health and wellness platform. Chuck is a two-time SQL Saturday event speaker on replication, was a Top 5 nominee of Red-Gate Exceptional DBA Award in 2009 and often shares his 20 years of IT knowledge on twitter under the name @SQLGuyChuck and his website www.sqlwebpedia.com.
The following is a list of sponsors that helped fund the event.


I’m Rick and this is my website. I describe myself belonging and thinking through Western Reformed Tradition, of Tamil Descent.
My Ancestors are from Tamil Nadu, India.
I graduated with a M.S in Computer Science, writing my thesis titled, "Kodai: A Software Architecture and Implementation for Segmentation",
under Dr. Joan Peckham. My Master's Degree is from the University of Rhode Island, USA.
I cherish books.
I've breathed in Rhode Island, Florida, Ohio, Virginia, D.C., Madhya Pradesh, Tamil Nadu, India.
I've been adventurous and blessed abundantly with travel experiences.
My Mom describes me as being thorough in my thoughts.
I consider myself to be a "Readers's Reader"
My friends describe me as intellectual, friendly, caring, faithful, committed, visionary and good listener. I'm trilingual. I speak English, Tamil and Hindi. In my spare time -- I delight in reading, writing, meeting new people and taking walks.
Working with International students from China, Sri Lanka, Middle East, Thailand, Japan, Brazil, UK, and fellow Americans has expanded my view of the world. My curiousity drives me to thirst for better understanding of the world around me. I especially enjoy cultures and explaining cross-cultural differences. If you had met me, you would find me gravitating towards discussing complex-ideas, inter-disciplinary topics related to History, Engineering, Philosophy, Business, Real estate, Cultures, Theology, Computer-Science.


This is the first paragraph.
This paragrpah is not affected by any style.
This is a paragraph in red.
Contact: SWDM office (RM# 420)
(a) Suseo station
(b) Bokjeong station
(c) Dogok station
(d) Gangnam station


Easy SimAuto (ESA) Documentation¶
Easy SimAuto is a Python package to ease interaction with PowerWorld Simulator’s SimAuto add-on. This documentation seeks to be comprehensive, with detailed installation instructions, complete API documentation, and a rich set of examples. If you’re new to ESA, please start by reading the Welcome! section. Returning users looking to see what’s new should check out the Changelog.