The Singleton Pattern¶
A “Creational Pattern” from the Gang of Four book
Verdict
Python programmers almost never implement the Singleton Pattern
as described in the Gang of Four book,
whose Singleton class forbids normal instantiation
and instead offers a class method that returns the singleton instance.
Python is more elegant,
and lets a class continue to support the normal syntax for instantiation
while defining a custom __new__()
method
that returns the singleton instance.
But an even more Pythonic approach,
if your design forces you to offer global access to a singleton object,
is to use The Global Object Pattern instead.
Disambiguation¶
Python was already using the term singleton before the “Singleton Pattern” was defined by the object oriented design pattern community. So we should start by distinguishing the several meanings of “singleton” in Python.
- A tuple of length one is called a singleton. While this definition might surprise some programmers, it reflects the original definition of a singleton in mathematics: a set containing exactly one element. The Python Tutorial itself introduces newcomers to this definition when its chapter on Data Structures calls a one-element tuple a “singleton” and the word continues to be used in that sense through the rest of Python’s documentation. When the Extending and Embedding guide says, “To call the Python function … with one argument, pass a singleton tuple,” it means a tuple containing exactly one item.
- Modules are “singletons” in Python
because
import
only creates a single copy of each module; subsequent imports of the same name keep returning the same module object. For example, when the Module Objects chapter of the Python/C API Reference Manual asserts that “Single-phase initialization creates singleton modules,” it means by a “singleton module” a module for which only one object is ever created. - A “singleton” is a class instance that has been assigned a global name
through The Global Object Pattern.
For example, the official Python Programming FAQ
answers the question
“How do I share global variables across modules?”
with the assertion that in Python
“using a module is also the basis for implementing the Singleton design” —
because not only can a module’s global namespace store constants
(the FAQ’s example is
x = 0
shared between several modules), but mutable class instances as well. - Individual flyweight objects
that are examples of The Flyweight Pattern
are often called “singleton” objects by Python programmers.
For example, a comment inside the Standard Library’s
itertoolsmodule.c
asserts that “CPython’s empty tuple is a singleton” — meaning that the Python interpreter only ever creates a single empty tuple object, whichtuple()
returns over and over again every time it’s passed a zero-length sequence. A comment inmarshal.c
similarly refers to the “empty frozenset singleton.” But neither of these singleton objects is an example of the Gang of Four’s Singleton Pattern, because neither object is the sole instance of its class:tuple
lets you build other tuples besides the empty tuple, andfrozenset
lets you build other frozen sets. Similarly, theTrue
andFalse
objects are a pair of flyweights, not examples of the Singleton Pattern, because neither is the sole instance ofbool
. - Finally, Python programmers on a few rare occasions do actually mean “The Singleton Pattern” when they call an object a “singleton”: the lone object returned by its class every time the class is called.
The Python 2 Standard Library included no examples of the Singleton Pattern.
While it did feature singleton objects like None
and Ellipsis
,
the language provided access to them through the more Pythonic
Global Object Pattern
by giving them names in the __builtin__
module.
But their classes were not callable:
>>> type(None)
<type 'NoneType'>
>>> NoneType = type(None)
>>> NoneType()
TypeError: cannot create 'NoneType' instances
>>> type(Ellipsis)()
TypeError: cannot create 'ellipsis' instances
In Python 3, however, the classes were upgraded to use the Singleton Pattern:
>>> NoneType = type(None)
>>> print(NoneType())
None
>>> type(Ellipsis)()
Ellipsis
This makes life easier for programmers
who need a quick callable that always returns None
,
though such occasions are rare.
In most Python projects these classes are never called
and the benefit remains purely theoretical.
When Python programmers need the None
object
they use The Global Object Pattern
and simply type its name.
The Gang of Four’s implementation¶
The C++ language that the Gang of Four were targeting imposed a distinct syntax on object creation, that looked something like:
# Object creation in a language
# that has a “new” keyword.
log = new Logger()
A line of C++ that says new
always creates a new class instance —
it never returns a singleton.
In the presence of this special syntax,
what were their options for offering singleton objects?
- The Gang of Four did not take the easy way out and use The Global Object Pattern because it did not work particularly well in early versions of the C++ language. There, global names all shared a single crowded global namespace, so elaborate naming conventions were necessary to prevent names from different libraries from colliding. The Gang judged that adding both a class and its singleton instance to the crowded global namespace would be excessive. And since C++ programmers couldn’t control the order in which global objects were initialized, no global object could depend on being able to call any other, so the responsibility of initializing globals often fell on client code.
- There was no way to override the meaning of
new
in C++, so an alternative syntax was necessary if all clients were to receive the same object. It was, though, at least possible to make it a compile-time error for client code to callnew
by marking the class constructor as eitherprotected
orprivate
. - So the Gang of Four pivoted to a class method that would return the class’s singleton object. Unlike a global function, a class method avoided adding yet another name to the global namespace, and unlike a static method, it could support subclasses that were singletons as well.
How could Python code illustrate their approach?
Python lacks the complications of new
, protected
, and private
.
An alternative is to raise an exception in __init__()
to make normal object instantiation impossible.
The class method can then use a dunder method trick
to create the object without triggering the exception:
# What the Gang of Four’s original Singleton Pattern
# might look like in Python.
class Logger(object):
_instance = None
def __init__(self):
raise RuntimeError('Call instance() instead')
@classmethod
def instance(cls):
if cls._instance is None:
print('Creating new instance')
cls._instance = cls.__new__(cls)
# Put any initialization here.
return cls._instance
This successfully prevents clients from creating new instances by calling the class:
log = Logger()
Traceback (most recent call last):
...
RuntimeError: Call instance() instead
Instead, callers are instructed to use the instance()
class method,
which creates and returns an object:
log1 = Logger.instance()
print(log1)
Creating new instance
<Logger object at 0x7f0ff5e7c080>
Subsequent calls to instance()
return the singleton
without repeating the initialization step
(as we can see from the fact that “Creating new instance” isn’t printed again),
exactly as the Gang of Four intended:
log2 = Logger.instance()
print(log2)
print('Are they the same object?', log1 is log2)
<Logger object at 0x7f0ff5e7c080>
Are they the same object? True
There are more complicated schemes that I can imagine for implementing the original Gang of Four class method in Python, but I think the above example does the best job of illustrating the original scheme with the least magic possible. Since the Gang of Four’s pattern is not a good fit for Python anyway, I’ll resist the temptation to iterate on it further, and instead move on to how the pattern is best supported in Python.
A more Pythonic implementation¶
In one sense,
Python started out better prepared than C++ for the Singleton Pattern,
because Python lacks a new
keyword
that forces a new object to be created.
Instead, objects are created by invoking a callable,
which imposes no syntactic limitation
on what operation the callable really performs:
log = Logger()
To let authors take control of calls to a class,
Python 2.4 added the __new__()
dunder method
to support alternative creational patterns
like the Singleton Pattern and The Flyweight Pattern.
The Web is replete with Singleton Pattern recipes featuring __new__()
that each propose a more or less complicated mechanism
for working around the method’s biggest quirk:
the fact that __init__()
always gets called on the return value,
whether the object that’s being returned is new or not.
To make my own example simple,
I will simply not define an __init__()
method
and thus avoid having to work around it:
# Straightforward implementation of the Singleton Pattern
class Logger(object):
_instance = None
def __new__(cls):
if cls._instance is None:
print('Creating the object')
cls._instance = super(Logger, cls).__new__(cls)
# Put any initialization here.
return cls._instance
The object is created on the first call to the class:
log1 = Logger()
print(log1)
Creating the object
<Logger object at 0x7fa8e9cf7f60>
But the second call returns the same instance. The message “Creating the object” does not print, nor is a different object returned:
log2 = Logger()
print(log2)
print('Are they the same object?', log1 is log2)
<Logger object at 0x7fa8e9cf7f60>
Are they the same object? True
The example above opts for simplicity,
at the expense of doing the cls._instance
attribute lookup twice
in the common case.
For programmers who cringe at such waste,
the result can of course be assigned a name
and re-used in the return statement.
And various other improvements can be imagined
that would result in faster bytecode.
But however elaborately tweaked,
the above pattern is the basis of every Python class
that hides a singleton object
behind what reads like normal class instantiation.
Verdict¶
While the Gang of Four’s original Singleton Pattern is a poor fit
for a language like Python
that lacks the concepts of new
, private
, and protected
,
it’s not as easy to dismiss the pattern when it’s built atop __new__()
—
after all, singletons were part of the reason
the __new__()
dunder method was introduced!
But the Singleton Pattern in Python does suffer from several drawbacks.
A first objection is that the Singleton Pattern’s implementation
is difficult for many Python programmers to read.
The alternative Global Object Pattern
is easy to read:
it’s simply the familiar assignment statement,
placed up at a module’s top level.
But a Python programmer reading a __new__()
method for the first time
is probably going to have to stop and look for documentation
to understand what’s going on.
A second objection is that the Singleton Pattern
makes calls to the class, like Logger()
, misleading for readers.
Unless the designer has put “Singleton”
or some other hint in the class name,
and the reader knows design patterns well enough to understand the hint,
the code will read as though a new instance is being created and returned.
A third objection is that the Singleton Pattern forces a design commitment
that The Global Object Pattern does not.
Offering a global object still leaves a programmer free
to create other instances of the class —
which can be particularly helpful for tests,
letting them each test a completely separate object
without needing to reset a shared object back to a known good state.
But the Singleton Pattern makes additional instances impossible.
(Unless the caller is willing to stoop to monkey patching;
or temporarily modifying _instance
to subvert the logic in __new__()
;
or creating a subclass that replaces the method.
But a pattern you have to work around
is generally a pattern you should avoid.)
Why, then, would you use the Singleton Pattern in Python?
The one situation that would really demand the pattern would be an existing class that, because of a new requirement, will now operate best as a single instance. If it’s not possible to migrate all client code to stop calling the class directly and start using a global object, then the Singeton Pattern would be a natural approach to pivoting to a singleton while preserving the old syntax.
But, otherwise, the pattern is best avoided in favor of following the advice of the official Python FAQ and using the The Global Object Pattern.


| Interface | Description |
|---|---|
| LXArtNetPollReplyListener |
LXArtNetPollReplyListener
|
| LXmDNSDelegate |
LXmDNSDelegate is an interface for searching for devices using multicast DNS
Classes implementing LXmDNSDelegate receive a receivedResponse() call when
LXmDNSDiscoverer receives a mDNS packet with a matching qualified domain name.
|
| LXUPnPDelegate |
LXUPnPDelegate is an interface for implementing Universal Plug and Play discovery.
|
| Class | Description |
|---|---|
| LXArtNet |
LXArtNet
|
| LXArtNetPollReplyInfo |
LXArtNetPollReplyInfo
|
| LXDMXEthernet |
LXDMXEthernet
|
| LXDMXInterface |
LXDMXInterface
Abstract class representing an interface capable of reading and writing dmx
contained in a serial or network packet.
|
| LXDNSReplyRecord |
LXmDNSReplyRecord holds a Reply Record Data structure
|
| LXENTTEC |
LXDMXENTTEC.java
|
| LXHueInterface |
LXHueInterface provides a network interface connection to a Phillips Hue Bridge.
|
| LXJSONElement |
LXJSONElement is a class that holds an element of a JSON object tree.
|
| LXJSONParser | |
| LXmDNSDiscoverer |
LXmDNSDiscoverer is a class for implementing mDNS discovery of devices
on a local network.
|
| LXOSC |
LXOSC
|
| LXOSCArgument |
LXOSCArgument
|
| LXOSCBundleMessage |
LXOSCBundleMessage
|
| LXOSCMessage |
LXOSCMessage
|
| LXOSCPacketReader |
LXOSCPacketReader
|
| LXPButton |
LXPButton
it highlights when it is moused over
when clicked, it calls its mouseClicked() method
to use LXPButton, create a subclass and override mouseClicked()
|
| LXPColorPicker |
LXColorPicker
Displays a color wheel type color picker.
|
| LXPRadioButton |
LXPRadioButton is a member of a LXPRadioGroup
it highlights when it is moused over
when clicked, it requests the RadioGroup select its station
|
| LXPRadioGroup |
LXPRadioGroup is a controller for a group of RadioButtons
only a single station (button) can be selected at a time
|
| LXPTextField |
LXPTextField is a member of a LXPTextGroup
it highlights when the cursor hovers over it
When clicked, it requests the LXPTextGroup select its station to receive keyPressed messages
Other key presses are added to the fields value string which is displayed,
up to the fields maximum number of characters.
|
| LXPTextGroup |
LXPTextGroup is a controller for a group of LXPTextFields
only a single field can have focus and receive keyPressed messages
|
| LXPVScrollbar |
LXPVScrollbar is a vertical slider type control
A LXPVScrollbar should receive both an update and draw message inside a PApplet's draw method.
|
| LXSACN |
LXSACN.java
|
| LXUPnPDiscoverer |
LXUPnPDiscoverer is a class for implementing Universal Plug and Play discovery.
|


This class models a quantity or amount of time in terms of years, months and days. See Duration for the time-based equivalent to this class.
Durations and period differ in their treatment of daylight savings time when added to ZonedDateTime. A Duration will add an exact number of seconds, thus a duration of one day is always exactly 24 hours. By contrast, a Period will add a conceptual day, trying to maintain the local time.
For example, consider adding a period of one day and a duration of one day to 18:00 on the evening before a daylight savings gap. The Period will add the conceptual day and result in a ZonedDateTime at 18:00 the following day. By contrast, the Duration will add exactly 24 hours, resulting in a ZonedDateTime at 19:00 the following day (assuming a one hour DST gap).
The supported units of a period are ChronoUnit#YEARS, ChronoUnit#MONTHS and ChronoUnit#DAYS. All three fields are always present, but may be set to zero.
The period may be used with any calendar system. The meaning of a 'year' or 'month' is only applied when the object is added to a date.
The period is modeled as a directed amount of time, meaning that individual parts of the period may be negative.
The months and years fields may be normalized (see normalized). The normalization assumes a 12 month year, so is not appropriate for all calendar systems.
Static properties of Class Period
Period.ZERO
A constant for a period of zero.
Static Method Summary
| Static Public Methods | ||
| public static |
Obtains a Period consisting of the number of years, months, and days between two dates. |
|
| public static |
Creates an instance. |
|
| public static |
from(amount: TemporalAmount): Period Obtains an instance of Period from a temporal amount. |
|
| public static |
Obtains a Period representing a number of years, months and days. |
|
| public static |
Obtains a Period representing a number of days. |
|
| public static |
Obtains a Period representing a number of months. |
|
| public static |
Obtains a Period representing a number of weeks. |
|
| public static |
Obtains a Period representing a number of years. |
|
| public static |
Obtains a Period from a text string such as PnYnMnD. |
Method Summary
| Public Methods | ||
| public |
Adds this period to the specified temporal object. |
|
| public |
Gets the chronology that defines the meaning of the supported units. |
|
| public |
days(): number Gets the amount of days of this period. |
|
| public |
equals(obj: *): boolean Checks if this period is equal to another period. |
|
| public |
get(unit: TemporalUnit): number Gets the value of the requested unit. |
|
| public |
hashCode(): number A hash code for this period. |
|
| public |
isNegative(): boolean Checks if any of the three units of this period are negative. |
|
| public |
isZero(): boolean Checks if all three units of this period are zero. |
|
| public |
minus(amountToSubtract: TemporalAmount): Period Returns a copy of this period with the specified amount subtracted. |
|
| public |
Returns a copy of this period with the specified days subtracted. |
|
| public |
minusMonths(monthsToSubtract: number): Period Returns a copy of this period with the specified months subtracted. |
|
| public |
minusYears(yearsToSubtract: number): Period Returns a copy of this period with the specified years subtracted. |
|
| public |
months(): number Gets the amount of months of this period. |
|
| public |
multipliedBy(scalar: number): Period Returns a new instance with each element in this period multiplied by the specified scalar. |
|
| public |
Returns a new instance with each amount in this period negated. |
|
| public |
normalized(): Period Returns a copy of this period with the years and months normalized using a 12 month year. |
|
| public |
plus(amountToAdd: TemporalAmount): Period Returns a copy of this period with the specified amount added. |
|
| public |
Returns a copy of this period with the specified days added. |
|
| public |
plusMonths(monthsToAdd: number): Period Returns a copy of this period with the specified months added. |
|
| public |
Returns a copy of this period with the specified years added. |
|
| public |
subtractFrom(temporal: Temporal): Temporal Subtracts this period from the specified temporal object. |
|
| public |
toJSON(): string |
|
| public |
toString(): string Outputs this period as a string, such as P6Y3M1D. |
|
| public |
toTotalMonths(): number Gets the total number of months in this period using a 12 month year. |
|
| public |
units(): ChronoUnit[] Gets the list of units, from largest to smallest, that fully define this amount. |
|
| public |
Returns a copy of this period with the specified amount of days. |
|
| public |
withMonths(months: number): Period Returns a copy of this period with the specified amount of months. |
|
| public |
Returns a copy of this period with the specified amount of years. |
|
| public |
years(): number Gets the amount of years of this period. |
Inherited Summary
| From class TemporalAmount | ||
| public |
Adds to the specified temporal object. |
|
| public |
get(unit: TemporalUnit): number Returns the value of the requested unit. |
|
| public |
subtractFrom(temporal: Temporal): Temporal Subtracts this object from the specified temporal object. |
|
| public |
units(): TemporalUnit[] Returns the list of units uniquely defining the value of this TemporalAmount. |
Static Public Methods
public static between(startDate: LocalDate, endDate: LocalDate): Period source
Obtains a Period consisting of the number of years, months, and days between two dates.
The start date is included, but the end date is not.
The period is calculated by removing complete months, then calculating
the remaining number of days, adjusting to ensure that both have the same sign.
The number of months is then split into years and months based on a 12 month year.
A month is considered if the end day-of-month is greater than or equal to the start day-of-month.
For example, from 2010-01-15
to 2011-03-18
is one year, two months and three days.
The result of this method can be a negative period if the end is before the start. The negative sign will be the same in each of year, month and day.
public static create(years: number, months: number, days: number): Duration source
Creates an instance.
Params:
| Name | Type | Attribute | Description |
| years | number | the amount |
|
| months | number | the amount |
|
| days | number | the amount |
public static from(amount: TemporalAmount): Period source
Obtains an instance of Period from a temporal amount.
This obtains a period based on the specified amount. A TemporalAmount represents an - amount of time, which may be date-based or time-based, which this factory extracts to a Period.
The conversion loops around the set of units from the amount and uses the ChronoUnit#YEARS, ChronoUnit#MONTHS and ChronoUnit#DAYS units to create a period. If any other units are found then an exception is thrown.
If the amount is a ChronoPeriod then it must use the ISO chronology.
Params:
| Name | Type | Attribute | Description |
| amount | TemporalAmount | the temporal amount to convert, not null |
Throw:
* |
DateTimeException if unable to convert to a Period |
* |
ArithmeticException if the amount of years, months or days exceeds an int |
public static of(years: number, months: number, days: number): Period source
Obtains a Period representing a number of years, months and days.
This creates an instance based on years, months and days.
Params:
| Name | Type | Attribute | Description |
| years | number |
|
the amount of years, may be negative |
| months | number |
|
the amount of months, may be negative |
| days | number |
|
the amount of days, may be negative |
public static ofDays(days: number): Period source
Obtains a Period representing a number of days.
The resulting period will have the specified days. The years and months units will be zero.
Params:
| Name | Type | Attribute | Description |
| days | number | the number of days, positive or negative |
public static ofMonths(months: number): Period source
Obtains a Period representing a number of months.
The resulting period will have the specified months. The years and days units will be zero.
Params:
| Name | Type | Attribute | Description |
| months | number | the number of months, positive or negative |
public static ofWeeks(weeks: number): Period source
Obtains a Period representing a number of weeks.
The resulting period will have days equal to the weeks multiplied by seven. The years and months units will be zero.
Params:
| Name | Type | Attribute | Description |
| weeks | number | the number of weeks, positive or negative |
public static ofYears(years: number): Period source
Obtains a Period representing a number of years.
The resulting period will have the specified years. The months and days units will be zero.
Params:
| Name | Type | Attribute | Description |
| years | number | the number of years, positive or negative |
public static parse(text: string): Period source
Obtains a Period from a text string such as PnYnMnD.
This will parse the string produced by toString which is based on the ISO-8601 period formats PnYnMnD and PnW.
The string starts with an optional sign, denoted by the ASCII negative
or positive symbol. If negative, the whole period is negated.
The ASCII letter 'P' is next in upper or lower case.
There are then four sections, each consisting of a number and a suffix.
At least one of the four sections must be present.
The sections have suffixes in ASCII of 'Y', 'M', 'W' and 'D' for
years, months, weeks and days, accepted in upper or lower case.
The suffixes must occur in order.
The number part of each section must consist of ASCII digits.
The number may be prefixed by the ASCII negative or positive symbol.
The number must parse to an int
.
The leading plus/minus sign, and negative values for other units are not part of the ISO-8601 standard. In addition, ISO-8601 does not permit mixing between the PnYnMnD and PnW formats. Any week-based input is multiplied by 7 and treated as a number of days.
For example, the following are valid inputs:
'P2Y' -- Period.ofYears(2) 'P3M' -- Period.ofMonths(3) 'P4W' -- Period.ofWeeks(4) 'P5D' -- Period.ofDays(5) 'P1Y2M3D' -- Period.of(1, 2, 3) 'P1Y2M3W4D' -- Period.of(1, 2, 25) 'P-1Y2M' -- Period.of(-1, 2, 0) '-P1Y2M' -- Period.of(-1, -2, 0)
Params:
| Name | Type | Attribute | Description |
| text | string | the text to parse, not null |
Throw:
* |
DateTimeParseException if the text cannot be parsed to a period |
Public Methods
public addTo(temporal: Temporal): Temporal source
Adds this period to the specified temporal object.
This returns a temporal object of the same observable type as the input with this period added.
In most cases, it is clearer to reverse the calling pattern by using Temporal#plus.
// these two lines are equivalent, but the second approach is recommended dateTime = thisPeriod.addTo(dateTime); dateTime = dateTime.plus(thisPeriod);
The calculation will add the years, then months, then days. Only non-zero amounts will be added. If the date-time has a calendar system with a fixed number of months in a year, then the years and months will be combined before being added.
This instance is immutable and unaffected by this method call.
Override:
TemporalAmount#addToParams:
| Name | Type | Attribute | Description |
| temporal | Temporal | the temporal object to adjust, not null |
Throw:
* |
DateTimeException if unable to add |
* |
ArithmeticException if numeric overflow occurs |
public chronology(): IsoChronology source
Gets the chronology that defines the meaning of the supported units.
The period is defined by the chronology. It controls the supported units and restricts addition/subtraction to ChronoLocalDate instances of the same chronology.
public days(): number source
Gets the amount of days of this period.
This returns the days unit.
Return:
| number | the amount of days of this period, may be negative |
public equals(obj: *): boolean source
Checks if this period is equal to another period.
The comparison is based on the amounts held in the period. To be equal, the years, months and days units must be individually equal. Note that this means that a period of '15 Months' is not equal to a period of '1 Year and 3 Months'.
Params:
| Name | Type | Attribute | Description |
| obj | * | the object to check, null returns false |
Return:
| boolean | true if this is equal to the other period |
public get(unit: TemporalUnit): number source
Gets the value of the requested unit.
The supported units are chronology specific. They will typically be ChronoUnit#YEARS, ChronoUnit#MONTHS and ChronoUnit#DAYS. Requesting an unsupported unit will throw an exception.
Override:
TemporalAmount#getParams:
| Name | Type | Attribute | Description |
| unit | TemporalUnit | the TemporalUnit for which to return the value |
Return:
| number | the long value of the unit |
Throw:
* |
DateTimeException if the unit is not supported |
* |
UnsupportedTemporalTypeException if the unit is not supported |
public isNegative(): boolean source
Checks if any of the three units of this period are negative.
This checks whether the years, months or days units are less than zero.
Return:
| boolean | true if any unit of this period is negative |
public isZero(): boolean source
Checks if all three units of this period are zero.
A zero period has the value zero for the years, months and days units.
Return:
| boolean | true if this period is zero-length |
public minus(amountToSubtract: TemporalAmount): Period source
Returns a copy of this period with the specified amount subtracted.
This input amount is converted to a Period using from. This operates separately on the years, months and days.
For example, '1 year, 6 months and 3 days' minus '2 years, 2 months and 2 days' returns '-1 years, 4 months and 1 day'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| amountToSubtract | TemporalAmount | the period to subtract, not null |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public minusDays(daysToSubtract: number): Period source
Returns a copy of this period with the specified days subtracted.
This subtracts the amount from the days unit in a copy of this period. The years and months units are unaffected. For example, '1 year, 6 months and 3 days' minus 2 days returns '1 year, 6 months and 1 day'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| daysToSubtract | number | the months to subtract, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public minusMonths(monthsToSubtract: number): Period source
Returns a copy of this period with the specified months subtracted.
This subtracts the amount from the months unit in a copy of this period. The years and days units are unaffected. For example, '1 year, 6 months and 3 days' minus 2 months returns '1 year, 4 months and 3 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| monthsToSubtract | number | the years to subtract, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public minusYears(yearsToSubtract: number): Period source
Returns a copy of this period with the specified years subtracted.
This subtracts the amount from the years unit in a copy of this period. The months and days units are unaffected. For example, '1 year, 6 months and 3 days' minus 2 years returns '-1 years, 6 months and 3 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| yearsToSubtract | number | the years to subtract, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public months(): number source
Gets the amount of months of this period.
This returns the months unit.
The months unit is not normalized with the years unit. This means that a period of '15 months' is different to a period of '1 year and 3 months'.
Return:
| number | the amount of months of this period, may be negative |
public multipliedBy(scalar: number): Period source
Returns a new instance with each element in this period multiplied by the specified scalar.
This simply multiplies each field, years, months, days and normalized time, by the scalar. No normalization is performed.
Params:
| Name | Type | Attribute | Description |
| scalar | number | the scalar to multiply by, not null |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public negated(): Period source
Returns a new instance with each amount in this period negated.
Throw:
* |
ArithmeticException if numeric overflow occurs |
public normalized(): Period source
Returns a copy of this period with the years and months normalized using a 12 month year.
This normalizes the years and months units, leaving the days unit unchanged. The months unit is adjusted to have an absolute value less than 11, with the years unit being adjusted to compensate. For example, a period of '1 Year and 15 months' will be normalized to '2 years and 3 months'.
The sign of the years and months units will be the same after normalization. For example, a period of '1 year and -25 months' will be normalized to '-1 year and -1 month'.
This normalization uses a 12 month year which is not valid for all calendar systems.
This instance is immutable and unaffected by this method call.
Throw:
* |
ArithmeticException if numeric overflow occurs |
public plus(amountToAdd: TemporalAmount): Period source
Returns a copy of this period with the specified amount added.
This input amount is converted to a Period using from. This operates separately on the years, months and days.
For example, '1 year, 6 months and 3 days' plus '2 years, 2 months and 2 days' returns '3 years, 8 months and 5 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| amountToAdd | TemporalAmount | the period to add, not null |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public plusDays(daysToAdd: number): Period source
Returns a copy of this period with the specified days added.
This adds the amount to the days unit in a copy of this period. The years and months units are unaffected. For example, '1 year, 6 months and 3 days' plus 2 days returns '1 year, 6 months and 5 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| daysToAdd | number | the days to add, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public plusMonths(monthsToAdd: number): Period source
Returns a copy of this period with the specified months added.
This adds the amount to the months unit in a copy of this period. The years and days units are unaffected. For example, '1 year, 6 months and 3 days' plus 2 months returns '1 year, 8 months and 3 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| monthsToAdd | number | the months to add, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public plusYears(yearsToAdd: number): Period source
Returns a copy of this period with the specified years added.
This adds the amount to the years unit in a copy of this period. The months and days units are unaffected. For example, '1 year, 6 months and 3 days' plus 2 years returns '3 years, 6 months and 3 days'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| yearsToAdd | number | the years to add, positive or negative |
Throw:
* |
ArithmeticException if numeric overflow occurs |
public subtractFrom(temporal: Temporal): Temporal source
Subtracts this period from the specified temporal object.
This returns a temporal object of the same observable type as the input with this period subtracted.
In most cases, it is clearer to reverse the calling pattern by using Temporal#minus.
// these two lines are equivalent, but the second approach is recommended dateTime = thisPeriod.subtractFrom(dateTime); dateTime = dateTime.minus(thisPeriod);
The calculation operates as follows. First, the chronology of the temporal is checked to ensure it is ISO chronology or null. Second, if the months are zero, the years are added if non-zero, otherwise the combination of years and months is added if non-zero. Finally, any days are added.
The calculation will subtract the years, then months, then days. Only non-zero amounts will be subtracted. If the date-time has a calendar system with a fixed number of months in a year, then the years and months will be combined before being subtracted.
This instance is immutable and unaffected by this method call.
Override:
TemporalAmount#subtractFromParams:
| Name | Type | Attribute | Description |
| temporal | Temporal | the temporal object to adjust, not null |
Throw:
* |
DateTimeException if unable to subtract |
* |
ArithmeticException if numeric overflow occurs |
public toString(): string source
Outputs this period as a string, such as P6Y3M1D.
The output will be in the ISO-8601 period format. A zero period will be represented as zero days, 'P0D'.
Return:
| string | a string representation of this period, not null |
public toTotalMonths(): number source
Gets the total number of months in this period using a 12 month year.
This returns the total number of months in the period by multiplying the number of years by 12 and adding the number of months.
This uses a 12 month year which is not valid for all calendar systems.
This instance is immutable and unaffected by this method call.
Return:
| number | the total number of months in the period, may be negative |
public units(): ChronoUnit[] source
Gets the list of units, from largest to smallest, that fully define this amount.
Override:
TemporalAmount#unitspublic withDays(days: number): Period source
Returns a copy of this period with the specified amount of days.
This sets the amount of the days unit in a copy of this period. The years and months units are unaffected.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| days | number | the days to represent, may be negative |
public withMonths(months: number): Period source
Returns a copy of this period with the specified amount of months.
This sets the amount of the months unit in a copy of this period. The years and days units are unaffected.
The months unit is not normalized with the years unit. This means that a period of '15 months' is different to a period of '1 year and 3 months'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| months | number | the months to represent, may be negative |
public withYears(years: number): Period source
Returns a copy of this period with the specified amount of years.
This sets the amount of the years unit in a copy of this period. The months and days units are unaffected.
The months unit is not normalized with the years unit. This means that a period of '15 months' is different to a period of '1 year and 3 months'.
This instance is immutable and unaffected by this method call.
Params:
| Name | Type | Attribute | Description |
| years | number | the years to represent, may be negative |
public years(): number source
Gets the amount of years of this period.
This returns the years unit.
The months unit is not normalized with the years unit. This means that a period of '15 months' is different to a period of '1 year and 3 months'.
Return:
| number | the amount of years of this period, may be negative |


You can change the viewer used to Word Documents, Excel Spreadsheets, and PowerPoint presentations. The default is Google Docs.
Note: This does not affect PDFs, RTFs, and links to Google Docs files.
Peek shows previews over file download links. Just hover your mouse over a link to a file, and the preview will appear.
Try clicking here and hover over some results.
You can click the full-screen button on the popup to open the preview in a new window.
To open Peek settings, click the settings gear on any popup, or click the Peek icon in the toolbar.
If you find Peek useful, please donate to support continued development. It would mean a lot!
Donate via PayPal Donate via Bitcoin
If you find a bug, or have a suggestion for a new feature, please create an issue at Peek GitHub repository.


We are a global software product and services company. With more than 20 years of experience, we have gained expertise in solving business issues leveraging our IT knowledge and skilled teams. We strive to understand our customers and their pain points to provide right and cost effective solutions.
Our mission is to become a trusted business partner in public sector, high education and corporate consulting. We are driven to transform case management and career services management through our innovative platforms.
Our mission is to become a trusted business partner in public sector, high education and corporate consulting. We are driven to transform case management and career services management through our innovative platforms.
Our mission is to become a trusted business partner in public sector, high education and corporate consulting. We are driven to transform case management and career services management through our innovative platforms.
Our mission is to become a trusted business partner in public sector, high education and corporate consulting. We are driven to transform case management and career services management through our innovative platforms.
2017 © Empyra.com, Inc. All Rights Reserved


--- layout: default title: 404 permalink: /404 nav_exclude: true search_exclude: true ---
So it's like this: either I broke something on the site, or you messed up the URL. Try the navigation panel {% if site.search_enabled != false %}or search {% endif %}to find what you're looking for or go to home page. Also, contact a technical writer about this.


Reports any
new StringBuffer()
and
new StringBuilder()
calls with an argument of type
char
. Such an argument is silently cast to an integer and interpreted as initial capacity of the buffer. Usually this is not what was intended.


Event will be having three rounds.
1.First round will be a written round in which teams will be given a question paper having questions related to current affairs,sports,simple business related questions
elimination will be done based on it
2.Second round is like a quizmaster will be asking all the teams the same question and the teams have to write answer on a paper.max time for a question will be of 15 sec.
Questions may a audioclip or video clip or simple question.max4 teams will be selected for final round.
3.Final round will be a buzzer round. The team who will give maximum answer will be the winner.
2 members only
10/3/17 friday
10:00 am onwards
Dental seminar hall/MMH/seminar hall/ Classroom
Karan Shah
Mo.7698649686
Email: karanpankajshah@gail.com


Honolulu Acting Prosecuting Attorney Dwight Nadamoto appears before grand jury for 3 hours | Honolulu Star-Advertiser
Honolulu Acting Prosecuting Attorney Dwight Nadamoto spent roughly three hours before a grand jury in U.S. District Court today and emerged with little to say to reporters.
Nadamoto said he cannot provide details of what federal prosecutors asked him, citing the ongoing investigation, but did say that he would need to appear again.
U.S. attorneys who won public corruption convictions against former Police Chief Louis Kealoha and his wife, former Deputy Prosecuting Attorney Katherine Kealoha, have now turned their attention to possible wrongdoing by Prosecuting Attorney Keith Kaneshiro and others in the Prosecutor’s Office.


"""
Implementation of the Wright, Richmond, Odlyzko and McKay (WROM)
algorithm for the enumeration of all non-isomorphic free trees of a
given order. Rooted trees are represented by level sequences, i.e.,
lists in which the i-th element specifies the distance of vertex i to
the root.
"""
# Copyright (C) 2013 by
# Aric Hagberg<EMAIL_ADDRESS># Dan Schult<EMAIL_ADDRESS># Pieter Swart<EMAIL_ADDRESS># All rights reserved.
# BSD license.
__author__ = "\n".join(["Aric Hagberg (hagberg@lanl.gov)",
"Mridul Seth (seth.mridul@gmail.com)"])
__all__ = ['nonisomorphic_trees',
'number_of_nonisomorphic_trees']
import networkx as nx
[docs]def nonisomorphic_trees(order, create="graph"):
"""Returns a list of nonisomporphic trees
Parameters
----------
order : int
order of the desired tree(s)
create : graph or matrix (default="Graph)
If graph is selected a list of trees will be returned,
if matrix is selected a list of adjancency matrix will
be returned
Returns
-------
G : List of NetworkX Graphs
M : List of Adjacency matrices
References
----------
"""
if order < 2:
raise ValueError
# start at the path graph rooted at its center
layout = list(range(order // 2 + 1)) + list(range(1, (order + 1) // 2))
while layout is not None:
layout = _next_tree(layout)
if layout is not None:
if create == "graph":
yield _layout_to_graph(layout)
elif create == "matrix":
yield _layout_to_matrix(layout)
layout = _next_rooted_tree(layout)
[docs]def number_of_nonisomorphic_trees(order):
"""Returns the number of nonisomorphic trees
Parameters
----------
order : int
order of the desired tree(s)
Returns
-------
length : Number of nonisomorphic graphs for the given order
References
----------
"""
return sum(1 for _ in nonisomorphic_trees(order))
def _next_rooted_tree(predecessor, p=None):
"""One iteration of the Beyer-Hedetniemi algorithm."""
if p is None:
p = len(predecessor) - 1
while predecessor[p] == 1:
p -= 1
if p == 0:
return None
q = p - 1
while predecessor[q] != predecessor[p] - 1:
q -= 1
result = list(predecessor)
for i in range(p, len(result)):
result[i] = result[i - p + q]
return result
def _next_tree(candidate):
"""One iteration of the Wright, Richmond, Odlyzko and McKay
algorithm."""
# valid representation of a free tree if:
# there are at least two vertices at layer 1
# (this is always the case because we start at the path graph)
left, rest = _split_tree(candidate)
# and the left subtree of the root
# is less high than the tree with the left subtree removed
left_height = max(left)
rest_height = max(rest)
valid = rest_height >= left_height
if valid and rest_height == left_height:
# and, if left and rest are of the same height,
# if left does not encompass more vertices
if len(left) > len(rest):
valid = False
# and, if they have the same number or vertices,
# if left does not come after rest lexicographically
elif len(left) == len(rest) and left > rest:
valid = False
if valid:
return candidate
else:
# jump to the next valid free tree
p = len(left)
new_candidate = _next_rooted_tree(candidate, p)
if candidate[p] > 2:
new_left, new_rest = _split_tree(new_candidate)
new_left_height = max(new_left)
suffix = range(1, new_left_height + 2)
new_candidate[-len(suffix):] = suffix
return new_candidate
def _split_tree(layout):
"""Return a tuple of two layouts, one containing the left
subtree of the root vertex, and one containing the original tree
with the left subtree removed."""
one_found = False
m = None
for i in range(len(layout)):
if layout[i] == 1:
if one_found:
m = i
break
else:
one_found = True
if m is None:
m = len(layout)
left = [layout[i] - 1 for i in range(1, m)]
rest = [0] + [layout[i] for i in range(m, len(layout))]
return (left, rest)
def _layout_to_matrix(layout):
"""Create the adjacency matrix for the tree specified by the
given layout (level sequence)."""
result = [[0] * len(layout) for i in range(len(layout))]
stack = []
for i in range(len(layout)):
i_level = layout[i]
if stack:
j = stack[-1]
j_level = layout[j]
while j_level >= i_level:
stack.pop()
j = stack[-1]
j_level = layout[j]
result[i][j] = result[j][i] = 1
stack.append(i)
return result
def _layout_to_graph(layout):
"""Create a NetworkX Graph for the tree specified by the
given layout(level sequence)"""
result = [[0] * len(layout) for i in range(len(layout))]
G = nx.Graph()
stack = []
for i in range(len(layout)):
i_level = layout[i]
if stack:
j = stack[-1]
j_level = layout[j]
while j_level >= i_level:
stack.pop()
j = stack[-1]
j_level = layout[j]
G.add_edge(i, j)
stack.append(i)
return G


--- layout: post authors: ["Greg Wilson"] title: "How Teaching Knowledge Is Transferred" date: 2015-09-13 time: "03:00:00" tags: ["Teaching", "Research", "Opinion"] ---
I hesitate to say so, but I believe that we pedagogues tend to exaggerate greatly the amount of change in educational practice that results from reading what other people say should be done...
— Stephen Corey, 1951
Being back in Edinburgh thirty years on has occasioned much reflection upon lessons learned. This has occasioned a re-reading of some papers by Prof. Sally Fincher, whose research group at the University of Kent studies the teaching and learning of computer science. In particular, I have been looking at what they have discovered about how educators share teaching practices. I hope these excerpts and reflections are of interest. (Note: section titles link to papers.)
This paper is a close look at a request for help that one instructor posted to a forum and what happened next. The conclusion is that top-down dissemination rarely if ever works. Instead, instructors borrow bits and pieces that they happen to stumble upon when and as they need them:
It is not a common practice among tertiary educators to observe teaching in someone else's institution. Although peer observation is becoming more common within departments (sometimes within institutions) it is essentially unheard of between institutions. And when the motivations for peer observation are examined, this is not surprising. They are, in general, linked to the quality assurance and staff development of the observed teacher. From that perspective there is simply no point in observing practice to ensure the quality of teaching in some other institution, nor any incentive to develop their staff.
Unexpectedly, whether because observers were observing outside their home institutions, or whether because they were highly sensitised to the curriculum and material being delivered, observers were especially struck by aspects of context that are normally invisible. These observations included the physical setting of the university, the material and technological objects within the classroom, the student interactions with one another. The shared disciplinary background meant that, for the observer, the observation began not when entering the classroom, but when leaving their own.
The normal mechanisms employed for transfer of ideas in teaching and learning are in the mode of disseminator push: that is that something is identified (a teaching method, a "best practice", a theory) and it is packaged and promoted to interested parties by a staff developer or a researcher, via mechanisms such as papers, books, websites and workshops. This is the trajectory that is often assumed for educational research—that "dissemination" to practitioners occurs simply by virtue of publication in a research venue. However, evidence from empirical studies suggests that transfer of practice and knowledge to practitioners is rarely occasioned by these research-to-practice, top-down methods.
Teachers change their practices, adopting (transferring) ideas and materials from direct, personal contact with other practitioners as and when they need—often in very small, partial, pieces ("piecemeal accretion") or by virtue of having experienced it in another institution and, with a change of employment, importing it to a new context ("charismatic embedding"). Thus these transfers are achieved directly from practitioner to practitioner, from one specific setting to another, mediated neither by theory, researcher, or staff developer.
Survey results...support the conjecture that knowledge transfer rarely happens top-down, from researcher to practitioner. When asked "What published material do you read with regard to your teaching?", seven participants mention reading technical publications related to disciplinary knowledge, five mention textbooks, five mention CS Ed practitioner conference proceedings... Only one... (a CS Ed researcher) ...mentioned reading the CS Education research literature; and none mentioned reading research in the learning sciences, in the behavioural or social sciences, or disciplinary education research in cognate disciplines...
The inefficiency of "pull transfer" is its most obvious drawback, but in addition, its ad hoc nature makes even its practitioners downplay it, which in turn means that people aren't given full credit for their ideas:
[C]'s acknowledgement of this cycle of adoption and adaptation comes with the slightly shamefaced 'there's nothing like plagiarism, eh?' This...symbolises one of the fundamental features that differentiate the activities of teaching and research. 'Plagiarism' is about public attribution of the source of ideas, a basic requirement of research-based activity but one that is more-or-less unknown in teaching. It suggests that it is not important—to [C], to the colleagues within his institution, or to his disciplinary peers—to acknowledge sources of teaching knowledge in the same way as in research. This would also imply that there is no incentive or reward for giving such acknowledgement, and that there are no evolved norms that require it. Part of the reason for this is that teaching practice is often ephemeral, enacted but not documented. And those parts of teaching that are documented are rarely referenced with sources as would be ordinary in the documentation of research. As a result, provenance is easily lost in teaching practice.
This loss of provenance in teaching, this rootlessness and reinvention of practice, paradoxically places more emphasis on practitioner-to-practitioner transfer, unmediated by documentary evidence.
This paper's abstract is a better summary than I could possibly write:
Innovative tools and teaching practices often fail to be adopted by educators in the field, despite evidence of their effectiveness. Naïve models of educational change assume this lack of adoption arises from failure to properly disseminate promising work, but evidence suggests that dissemination via publication is simply not effective. Instead of studying the adoption or rejection of a particular intervention, this paper turns the problem around. We asked educators to describe changes they had made to their teaching practice and analyzed the resulting stories to learn more about: the kinds of changes being made, their motivations for changing their practice, and the means by which they learned of pedagogical innovations. Of the 99 change stories analyzed, only three demonstrate an active search for new practices or materials on the part of teachers, and published materials were consulted in just eight of the stories. Most of the changes occurred locally, without input from outside sources, or involved only personal interaction with other educators.
A few quotes from the paper:
...there is little evidence that enhanced efforts at dissemination are working. A report to the National Research Council in 2008 found that "NSF- and association-funded reforms at the classroom level, however well intentioned, have not led to the hoped for magnitude of change in student learning, retention in the major, and the like in spite of empirical evidence of effectiveness". Failure to adopt effective practices is not limited to computing or education. A meta-analysis of 743 reports, books, and articles in 2005 found that dissemination alone was not an effective implementation method in human services, education, health, business, or manufacturing.
...there were notable differences in response dependent on how long the contributor had been teaching, and on the time a contributor had been at their current institution. In both cases the longer the time, the more the response moved from the change affecting individual practice only towards affecting other colleagues and then programmatic change.
The most populated catalyst category [i.e., explanation of reason for change] was of educators initiating change in response to students: in response to something they did, or something they said, or to a close observation of their attitudes and achievements.
...a least populated category was 'external imposition'...
In just over half of the stories...the instructor apparently formulated the details of their pedagogical change on their own, without consulting peers or other resources... This...is perhaps not surprising given that 'change in response to students' was...the most common catalyst category.
...[some] stories described changes resulting from chance encounters with educators who shared or demonstrated details of their teaching practice. The authors of these stories had not intended to change their practice until they were exposed to a new approach.
A larger group of change stories...involved primed serendipity, where the author encountered unanticipated information but while putting themselves in situations where they could reasonably expect to learn something about teaching practices (e.g. attending a conference or workshop, or browsing a journal issue)...Over 90% of the stories described changes that were either created without drawing on outside sources, or were informed by personal interactions with other educators.
The key challenges in building a lesson repository are:
Software Carpentry instructors must do this once to qualify. We have maintainers, but our contribution curve definitely has a long-tail distribution.
We are one course with only a handful of modules, so our focus is pretty narrow by the paper's measure.
This is not as much a problem for us: we're mostly curating.
Our community is defined as "people who use our lessons", which helps with recognition. That said, we should probably add all the contributors' names to each lesson's home page...
We only have a small number of modules, so it's easy to find what you want—once you've found the site, of course.
We borrow rules and conventions from open source, which most of our contributors accept as given, and don't try to control who uses materials.
As a side note, it's interesting to contrast Software Carpentry with the Nifty Assignments repository: new material is only added to Nifty Assignments once a year, and entry is competitive (i.e., it's not enough to be good: you have to be better than other assignments put forward in that year). Neither choice seems likely to build a culture of contribution or increase the average would-be contributor's confidence in her/his ability.
Later, quoting earlier work, the authors say that "borrowing provokes invention", so that "using a software library" is the wrong model for using a lesson, because (almost) everyone adapts to a different audience, a different precursor, or a different personal style of teaching. However, no alternative metaphor given: if sharing lessons isn't like using a library, what is it like?
Later still, "There was little distaste—indeed, some enthusiasm—for the re-use of pedagogic materials." That's hardly a ringing endorsement...
Finally, the paper teases out some implications:
...the users of the Nifty repository do not appear to want library-type resources. They do not feel the need for catalogues, they are content with the current methods of searching, but would like the metadata associated with each resources extended...
...they are not looking for a one-stop-shop with a comprehensive set of resources and the heavyweight 'authority' of editorial constraints... Nor are they especially interested in the comprehensiveness of the content of the resources as they recognise that they will have to adapt anything to local context.
They would seem to value curators above librarians.
None yet, but there's a lot here to think about. Please add your thoughts as comments.


| Edition 2019-20 Edition 2020-21 |
The number in “[dd]” represents the age of that page, i.e., the number of days that page is left untouched. So “[00]” means “edited today,” while “[01]” means “edited yesterday”. A double star “[**]” means older than 99 days.


Mindfulness Coach was a collaborative effort between the VA’s National Center for PTSD and the DoD’s National Center for Telehealth and Technology.
“Advancing Science and Promoting Understanding of Traumatic Stress”
The National Center for PTSD, within the Department of Veterans Affairs, aims to help U.S. veterans and others through research, education, and training on trauma and PTSD.
“Technology to Make People Healthy”
The National Center for Telehealth and Technology |T2| researches, develops, evaluates, and deploys new and existing technologies for Psychological Health (PH) and Traumatic Brain Injury (TBI) across the Department of Defense (DoD).
T2 is a component center of the Defense Centers of Excellence for Psychological Health and Traumatic Brain Injury (DCoE), which leads a collaborative global network to promote the resilience, recovery and reintegration of Warriors and their families who face psychological health and traumatic brain injury issues.
For more information about mindfulness and other topics for Veterans, see http://ptsd.va.gov.


remote sensors
07 Sep 2015A distributed client sensor to data server network.

- Data servers receive client sensor data and log it to a file.
- Any number of client sensors can transmit to any number of data servers as long as the client sensors know the IP address of the servers.
- Data servers are agnostic to the identity of the client sensors. Each client sensor embeds its identity into the data sent to the server.
Interface
- Point your browser to the webpage http://cudmore.duckdns.org:5000
Hardware
- Sensors clients can run on either a Raspberry Pi or an Arduino.
- Sensors clients can include: temperature, motion detection, light levels, or a camera.
- Data servers run on Linux Debian Jessie, OS X, or Raspberry Raspian.
- Both sensor clients and data servers are running Python. If sensor client is on Arduino, it runs Arduino code.
- Date servers run Flask to serve the webpage and use socket-io for realtime updates of pages served.
Mix-n-match
- A client sensor can also be running a data server. For example, a Raspberry Pi with a motion sensor client can also have a data server to receive motion events to trigger an image capture.
- Alternatively, a sensor client could have two sensors: a motion detector and a camera. In this case, motion would trigger an image capture and then transmit this as two events to a data server (a motion detection timestamp and an image).
###’Real world’ input
- Data servers can receive input from people. For example, a button to request a sensor client to read the current temperature or to take an image. In this senario, the sensor client also needs a data server to receive the button commands.
API
/bokeh
plot with bokeh (python generates javascript and plots off my server)
/images/a
plot with matplotlib (generates a static image)
/plotly
plot with plotly javascript (pure javascript pulling data off my server)
/keen
plot with keen (pure javascript, pulling data from keen server)
/system
the type of system the server is running on


-
Requests for Startups
www.ycombinator.com
You shouldn't start a company just because it's on this list. 1. It’s mostly here to help stimulate you to think about ideas.
-
Stripe: Apple Pay
stripe.com
Stripe is a suite of APIs that powers commerce for businesses of all sizes.
-
Zenefits’ Leader Is Rattling an Industry, So Why Is He Stressed Out? - ...
www.nytimes.com
Parker Conrad’s start-up, Zenefits, is thought to be one of the fastest-growing companies in recent Silicon Valley history, and his investors and ...
-
How to Start a Startup
startupclass.samaltman.com
CS183B is a class we’re teaching at Stanford. It’s designed to be a sort of one-class business course for people who want to start startups.
-
Behind the Scenes: 60+ Influencers on How They Do What They Do
www.linkedin.com
This post is part of a series in which Influencers go behind the scenes to explain in detail one aspect of their work. Read all the stories here and ...
-
Culture Code: What Makes a Company Great?
www.slideshare.net
How do you create the ideal workplace? Share the values, rules, principles and tactics your organization follows. Upload your presentation and tag it ...
-
Does This Desk Increase Productivity or Simply Make You Look Ridiculous?
www.entrepreneur.com
A couple of inventors in San Francisco built a 'Human Hamster Wheel' desk in 24 hours. You have to see it to believe it.
-
What The World's Greatest Leaders Can Teach Us
www.linkedin.com
Each year, Fortune ranks the world’s top 50 most influential leaders. And while the list is inspiring, I think the greater message lies in looking ...
-
What To Do When You Are Rejected
www.linkedin.com
Everyone around the dinner table had been brutally rejected hundreds of times.
-
OpenGov: The Startup Analyzing $50B in Spending | Andreessen Horowitz
a16z.com
“A billion here, a billion there, and pretty soon you’re talking real money!” — attributed to Fmr. Sen. Everett Dirksen
-
How Successful People Deal With Stress
www.linkedin.com
A survey by TalentSmart showed that 90 percent of top performers know how to manage their emotions in times of stress so that they remain cool, calm, ...
-
Six Easy Ways to Tap into Your Network on the Go
blog.linkedin.com
'I’d like to, but I don’t have enough time.” That’s the excuse I typically hear from people who don’t network. The reality is, whether you’re waiting ...
-
6 Ways to Make a Great First Impression
www.entrepreneur.com
Many entrepreneurs overlook the importance of poise and professionalism.   That’s why it’s important to focus on ...
 Here Georgetown professor Cal Newport explains the five steps to actually getting there.
-
LinkedIn Speaker Series: Tim Westergren
www.ustream.tv
We are lucky to host Tim Westergren, Founder of Pandora and LinkedIn Influencer. This will be a unique opportunity to get a behind-the-scenes look at ...
-
Why Successful People Never Bring Smartphones Into Meetings
www.linkedin.com
You are annoying your boss and colleagues any time you take your phone out during meetings, says new research from USC's Marshall School of Business, ...
-
Nine Ways To Light Your Creativity On Fire
www.linkedin.com
I felt so ashamed. I had just lost my apartment in the city. I had no jobs. No prospects for jobs. No money. A few years earlier I had millions and ...
-
Small Town, Big Impact: How People Helped Get Me Here
blog.linkedin.com
People helped get me here. I’ve gone from a 16-year-old waitress to the 30-year-old business owner and brand communications manager of an incredible ...
-
Be A Leader Who Can Bounce Back
www.linkedin.com
After talking to hundreds of CEOs in dozens of countries there is one fundamental truth that stands out for me. There is no such thing as stability, ...
-
How To Keep Workers Happy -- It's Not What You Think
www.forbes.com
Happiness in the workplace is something of a double-edged sword. Yes, having happy employees is critical to the success of any company, but there are ...
-
Larry Ellison Steps Down: Succession Done Well
www.linkedin.com
Founders always have a very hard time giving up their roles as CEO.Look at pioneering technology founders like Bill Gates of Microsoft, Andy Grove of ...
-
10 Things Exceptional People Say Every Single Day
www.linkedin.com
Want to make a huge difference in another person's life?Want to make a huge difference in your life?Here are things you should say every day -- to ...
-
7 Reasons Likeable People Succeed
www.linkedin.com
We all know this to be true, whether or not we are conscious of it. In the longer term, likeable people win out over all others. It does not matter ...
-
How to Avoid Being Underpaid for Your Work
www.linkedin.com
For twenty years, I've watched both professionals - and companies - be pushed into competing on the basis of price. This is a horrible position, ...
-
The Underappreciated Factor for Success
www.linkedin.com
Ask people what the key factor for success is, and they’ll provide the typical answers: skill, luck intelligence . . .These things are often keys to ...
-
Helping Professionals Achieve Their Career Aspirations: Kaplan’s Career ...
blog.linkedin.com
Our mission at LinkedIn is to connect the world’s professionals to make them more productive and successful. That’s why we’re excited to power ...
-
Here’s How You Can Take Action and Make The World a Better Place
blog.linkedin.com
This post is part of a series in which Influencers and members discuss how to drive change that matters. Read all the posts here and write your own; ...
-
9 Things Interviewers Never Tell Job Candidates, But Should
www.linkedin.com
In the best job interviews the candidate says a lot and the interviewer very little – after all, the interview is about the candidate, not the ...
-
Behind the Scenes: How I Stopped Sweating Over Public Speaking
www.linkedin.com
This post is part of a series in which Influencers go behind the scenes to explain in detail one aspect of their work. Read all the stories here and ...


koRpus: An R Package for Text Analysis
A set of tools to analyze texts. Includes, amongst others,
functions for automatic language detection, hyphenation,
several indices of lexical diversity (e.g., type token ratio,
HD-D/vocd-D, MTLD) and readability (e.g., Flesch, SMOG, LIX,
Dale-Chall). Basic import functions for language corpora are
also provided, to enable frequency analyses (supports Celex and
Leipzig Corpora Collection file formats) and measures like
tf-idf. Note: For full functionality a local installation of
TreeTagger is recommended. It is also recommended to not load
this package directly, but by loading one of the available
language support packages from the 'l10n' repository
<https://undocumeantit.github.io/repos/l10n>. 'koRpus' also
includes a plugin for the R GUI and IDE RKWard, providing
graphical dialogs for its basic features. The respective R
package 'rkward' cannot be installed directly from a
repository, as it is a part of RKWard. To make full use of this
feature, please install RKWard from <https://rkward.kde.org>
(plugins are detected automatically). Due to some restrictions
on CRAN, the full package sources are only available from the
project homepage. To ask for help, report bugs, request
features, or discuss the development of the package, please
subscribe to the koRpus-dev mailing list
(<http://korpusml.reaktanz.de>).
| Version: |
0.11-5 |
| Depends: |
R (≥ 3.0.0), sylly (≥ 0.1-4) |
| Imports: |
data.table, methods |
| Suggests: |
testthat, tm, SnowballC, shiny, knitr, rmarkdown, koRpus.lang.de, koRpus.lang.en, koRpus.lang.es, koRpus.lang.fr, koRpus.lang.it, koRpus.lang.ru |
| Enhances: |
rkward |
| Published: |
2018-10-28 |
| Author: |
Meik Michalke [aut, cre],
Earl Brown [ctb],
Alberto Mirisola [ctb],
Alexandre Brulet [ctb],
Laura Hauser [ctb] |
| Maintainer: |
Meik Michalke <meik.michalke at hhu.de> |
| BugReports: |
https://github.com/unDocUMeantIt/koRpus/issues |
| License: |
GPL (≥ 3) |
| URL: |
https://reaktanz.de/?c=hacking&s=koRpus |
| NeedsCompilation: |
no |
| Citation: |
koRpus citation info |
| Materials: |
README NEWS ChangeLog |
| In views: |
NaturalLanguageProcessing |
| CRAN checks: |
koRpus results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=koRpus
to link to this page.


55% of Nevada fatal crashes caused by impairment, 2016-18
LAS VEGAS (AP) - Law enforcement officials trying to bolster safety on Nevada’s roadways ahead of the upcoming holiday season are warning that impaired drivers continue to be a contributing factor in the majority of fatal traffic crashes in the state.
The Nevada Department of Public Safety says 55.4% of the 893 fatal crashes in Nevada were caused by a driver under the influence of alcohol or drugs, or a combination of both over the three-year period from 2016 to 2018. They accounted for 55.9% of the state’s 967 roadway deaths during that span.
Department spokesman Andrew Bennett says that’s a total of 494 fatal crashes over three years involving an impaired substance accounting for 540 deaths. He told the Las Vegas Review-Journal , “That’s 540 dreams lost and unfulfilled.”
Information from: Las Vegas Review-Journal, http://www.lvrj.com
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


RubyTerraform
A simple wrapper around the Terraform binary to allow execution from within a Ruby program, RSpec test or Rakefile.
Installation
Add this line to your application's Gemfile:
gem 'ruby-terraform'
And then execute:
$ bundle
Or install it yourself as:
$ gem install ruby-terraform
Usage
To require RubyTerraform
:
require 'ruby-terraform'
Supported versions and commands
RubyTerraform
supports all commands and options up to Terraform 0.15, except terraform console
, terraform test
and terraform version
.
Getting started
There are a couple of ways to call Terraform using RubyTerraform
.
Firstly, the RubyTerraform
module includes class methods for each of the supported Terraform commands. Each class method takes a parameter hash containing options to pass to Terraform.
For example, to save the plan of changes for a Terraform configuration located under infra/network
to a file called network.tfplan
whilst providing some vars:
RubyTerraform.plan(
chdir: 'infra/network',
out: 'network.tfplan',
vars: {
region: 'eu-central'
},
var_file: 'defaults.tfvars'
)
To apply the generated plan of changes:
RubyTerraform.apply(
chdir: 'infra/network',
plan: 'network.tfplan',
vars: {
region: 'eu-central'
},
var_file: 'defaults.tfvars'
)
…and to destroy the resulting resources:
RubyTerraform.destroy(
chdir: 'infra/network',
vars: {
region: 'eu-central'
},
var_file: 'defaults.tfvars'
)
Each class method also accepts a second hash argument of invocation options to use at command invocation time. Currently, the only supported option is :environment
which allows environment variables to be exposed to Terraform.
For example, to apply a configuration with trace level logging:
RubyTerraform.apply(
{
chdir: 'infra/network',
plan: 'network.tfplan',
vars: {
region: 'eu-central'
},
var_file: 'defaults.tfvars'
},
{
environment: {
'TF_LOG' => 'trace'
}
}
)
Additionally, RubyTerraform
allows command instances to be constructed and invoked separately. This is useful when you need to override global configuration on a command by command basis or when you need to pass a command around.
Using the command class approach, the equivalent plan invocation above can be achieved using:
command = RubyTerraform::Commands::Plan.new
command.execute(
chdir: 'infra/network',
out: 'network.tfplan',
vars: {
region: 'eu-central'
},
var_file: 'defaults.tfvars'
)
As with the class methods, the #execute
method accepts a second hash argument of invocation options allowing an environment to be specified.
See the API docs for the RubyTerraform module or the RubyTerraform::Commands module more details on the supported commands.
Parameters
The parameter hash passed to each command, whether via the class methods or the #execute
method, supports all the options available on the corresponding Terraform command. There are a few different types of options depending on what Terraform expects to receive:
-
Boolean
options, acceptingtrue
orfalse
, such as:input
or:lock
; -
String
options, accepting a single string value, such as:state
or:target
; -
Array<String>
options, accepting an array of strings, such as:var_files
or:targets
; and -
Hash<String,Object>
options, accepting a hash of key value pairs, where the value might be complex, such as:vars
and:backend_config
.
For all options that allow multiple values, both a singular and a plural option key are supported. For example, to specify multiple var files during a plan:
RubyTerraform.plan(
chdir: 'infra/network',
out: 'network.tfplan',
var_file: 'defaults.tfvars',
var_files: %w[environment.tfvars secrets.tfvars]
)
In this case, all three var files are passed to Terraform.
Some options have aliases. For example, the :out
option can also be provided as :plan
for symmetry with other terraform commands. However, in such situations only one of the aliases should be used in the provided parameters hash.
See the API docs for a more complete listing of available parameter options.
Configuration
RubyTerraform
uses sensible defaults for all configuration options. However, there are a couple of ways to override the defaults when they are sufficient.
Binary
By default, RubyTerraform
looks for the Terraform binary on the system path. To globally configure a specific binary location:
RubyTerraform.configure do |config|
config.binary = 'vendor/terraform/bin/terraform'
end
To configure the Terraform binary on a command by command basis, for example for the Plan
command:
command = RubyTerraform::Commands::Plan.new(
binary: 'vendor/terraform/bin/terraform'
)
command.execute(
# ...
)
Logging
By default, RubyTerraform
's own log statements are logged to $stdout
with level info
.
To globally configure a custom logger:
require 'logger'
logger = Logger.new($stdout)
logger.level = Logger::DEBUG
RubyTerraform.configure do |config|
config.logger = logger
end
RubyTerraform
supports logging to multiple different outputs at once, for example:
require 'logger'
file_device = Logger::LogDevice.new('/foo/bar.log')
stdout_device = Logger::LogDevice.new(STDOUT)
multi_io = RubyTerraform::MultiIO.new(file_device, stdout_device)
logger = Logger.new(multi_io, level: :debug)
RubyTerraform.configure do |config|
config.binary = '/binary/path/terraform'
config.logger = logger
config.stdout = multi_io
config.stderr = multi_io
end
Creating the Logger with a file this way (using
Logger::LogDevice
), guarantees that the buffer content will be saved/written, as it sets implicit flushing.
Configured in this way, any logging performed by RubyTerraform
will log to both STDOUT
and to the specified file.
To configure the logger on a command by command basis, for example for the Show
command:
require 'logger'
logger = Logger.new($stdout)
logger.level = Logger::DEBUG
command = RubyTerraform::Commands::Show.new(
logger: logger
)
command.execute(
# ...
)
Standard streams
By default, RubyTerraform
uses streams $stdin
, $stdout
and $stderr
.
To configure custom output and error streams:
log_file = File.open('path/to/some/ruby_terraform.log', 'a')
RubyTerraform.configure do |config|
config.stdout = log_file
config.stderr = log_file
end
In this way, both outputs will be redirected to log_file
.
Similarly, a custom input stream can be configured:
require 'stringio'
input = StringIO.new("user\ninput\n")
RubyTerraform.configure do |config|
config.stdin = input
end
In this way, terraform can be driven by input from somewhere other than interactive input from the terminal.
To configure the standard streams on a command by command basis, for example for the Init
command:
require 'logger'
input = StringIO.new("user\ninput\n")
log_file = File.open('path/to/some/ruby_terraform.log', 'a')
command = RubyTerraform::Commands::Init.new(
stdin: input,
stdout: log_file,
stderr: log_file
)
command.execute(
# ...
)
Documentation
Development
To install dependencies and run the build, run the pre-commit build:
script
./go
This runs all unit tests and other checks including coverage and code linting / formatting.
To run only the unit tests, including coverage:
script
./go test:unit
To attempt to fix any code linting / formatting issues:
script
./go library:fix
To check for code linting / formatting issues without fixing:
script
./go library:check
You can also run bin/console
for an interactive prompt that will allow you to experiment.
Managing CircleCI keys
To encrypt a GPG key for use by CircleCI:
openssl aes-256-cbc \
-e \
-md sha1 \
-in ./config/secrets/ci/gpg.private \
-out ./.circleci/gpg.private.enc \
-k "<passphrase>"
To check decryption is working correctly:
openssl aes-256-cbc \
-d \
-md sha1 \
-in ./.circleci/gpg.private.enc \
-k "<passphrase>"
Contributing
Bug reports and pull requests are welcome on GitHub at github.com/infrablocks/ruby_terraform. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.
License
The gem is available as open source under the terms of the MIT License.


Radan Skorić
Business logic that changes
the state of the system
class JobsController < ApplicationController
#...
def create
@job = current_user.post_job(job_params)
if @job.persisted?
redirect_to jobs_path,
notice: 'Job was successfully created.'
else
render :new
end
end
def apply
if current_user.apply_for_job(@job)
redirect_to jobs_path,
notice: 'You successfully applied to the job'
else
redirect_to jobs_path,
alert: "You don't have the necessary skills"
end
end
#...
end
class User < ActiveRecord::Base
has_many :jobs
has_many :user_skills
has_many :skills, through: :user_skills
def post_job(job_params)
job_params[:skills] &&= Skill.where(id: job_params.delete(:skills)).load
jobs.create(job_params).tap do |job|
if job.persisted?
#Notify users with matching skills
end
end
end
def apply_for_job(job)
return false if (self.skills & job.skills).size != job.skills.size
#Notify job owner about application
true
end
end
module JobPoster
def post_job(job_params)
job_params[:skills] &&= Skill.where(id: job_params.delete(:skills)).load
jobs.create(job_params).tap do |job|
if job.persisted?
#Notify users with matching skills
end
end
end
end
module JobApplicant
def apply_for_job(job)
return false if (self.skills & job.skills).size != job.skills.size
#Notify job owner about application
true
end
end
class User < ActiveRecord::Base
has_many :jobs
has_many :user_skills
has_many :skills, through: :user_skills
include JopPoster
include JobApplicant
end
class Job < ActiveRecord::Base
...
after_create :notify_users_with_matching_skills
...
end
class JobApplication < ActiveRecord::Base
...
validate :user_has_necessary_skills
...
after_create :notify_job_owner
...
end
class JobsController < ApplicationController
#...
def create
job_params[:skills] &&=
Skill.where(id: job_params.delete(:skills)).load
@job = current_user.jobs.create(job_params)
if @job.persisted?
#Notify users with matching skills
redirect_to jobs_path,
notice: 'Job was successfully created.'
else
render :new
end
end
def apply
if (current_user.skills & job.skills).size == job.skills.size
#Notify job owner about application
redirect_to jobs_path,
notice: 'You successfully applied to the job'
else
redirect_to jobs_path,
alert: "You don't have the necessary skills"
end
end
end
class User < ActiveRecord::Base
has_many :jobs
has_many :user_skills
has_many :skills,
through: :user_skills
end
#app/forms/job_application_form.rb
class JobApplicationForm
include ActiveModel::Model
attr_accessor :user, :job
validates :user_has_necessary_skills
def save
# Notify job owner
# ...
# Create/Update real models as needed
end
private
def user_has_necessary_skills
(@user.skills & @job.skills).size != @job.skills.size
end
end
#app/controller/jobs_controller.rb
def apply
@form = JobApplicationForm.new(job_application_form_params).save
if @form.persisted?
redirect_to jobs_path, notice: 'Job was successfully created.'
else
render :new
end
end
#app/models/job.rb
class Job < ActiveRecord::Base
belongs_to :user
has_many :job_skills
has_many :skills, through: :job_skills
validates_presence_of :description
end
#app/controller/jobs_controller.rb
def create
@job = JobPostingService.new(current_user).post(job_params)
if @job.persisted?
redirect_to jobs_path, notice: 'Job was successfully created.'
else
render :new
end
end
def apply
if JobApplicationService.new(current_user, @job).apply
redirect_to jobs_path, notice: 'You successfully applied to the job'
else
redirect_to jobs_path, alert: "You don't have the necessary skills"
end
end
#app/models/user.rb
class User < ActiveRecord::Base
has_many :jobs
has_many :user_skills
has_many :skills, through: :user_skills
end
#app/models/job.rb
class Job < ActiveRecord::Base
belongs_to :user
has_many :job_skills
has_many :skills, through: :job_skills
validates_presence_of :description
end
#app/managers/base_service.rb
class BaseService
def initialize(performer)
@performer = performer
end
end
#app/managers/job_posting_service.rb
class JobPostingService < BaseService
def post(job_params)
job_params[:skills] &&= Skill.where(id: job_params.delete(:skills)).load
@performer.jobs.create(job_params).tap do |job|
if job.persisted?
#Notify users with matching skills
end
end
end
end
#app/managers/job_application_service.rb
class JobApplicationService < BaseService
def initialize(performer, job)
@job = job
super(performer)
end
def apply
return false if (@performer.skills & @job.skills).size != @job.skills.size
#Notify job owner about application
true
end
end
class JobsController < ApplicationController
#...
def create
@job = JobCreationContext.new(current_user, job_params).post_new_job
if @job.persisted?
redirect_to jobs_path,
notice: 'Job was successfully created.'
else
render :new
end
end
def apply
if EmploymentNegotiationContext.new(current_user, @job).apply
redirect_to jobs_path,
notice: 'You successfully applied to the job'
else
redirect_to jobs_path,
alert: "You don't have the necessary skills"
end
end
#...
end
#app/models/user.rb
class User < ActiveRecord::Base
has_many :jobs
has_many :user_skills
has_many :skills, through: :user_skills
end
#app/models/job.rb
class Job < ActiveRecord::Base
belongs_to :user
has_many :job_skills
has_many :skills, through: :job_skills
validates_presence_of :description
end
#app/contexts/post_job_context.rb
class JobCreationContext
def initialize(user, job_params)
@user, @job_params = user, job_params
@user.extend Employer
end
def post_new_job
@user.post_job(@job_params)
end
end
#app/contexts/apply_to_job_context.rb
class EmploymentNegotiationContext
def initialize(user, job)
@user, @job = user, job
@user.extend Developer
end
def apply
@user.apply_for_job(@job)
end
end
#app/roles/employer.rb
module Employer
def post_job(job_params)
job_params[:skills] &&= Skill.where(id: job_params.delete(:skills)).load
jobs.create(job_params).tap do |job|
if job.persisted?
#Notify users with matching skills
end
end
end
end
#app/roles/developer.rb
module Developer
def apply_for_job(job)
return false if (self.skills & job.skills).size != job.skills.size
#Notify job owner about application
true
end
end


Currently running private practices
Open practices at JC Harmon High School (7-8:30pm)
KC IMPACT is a grass roots basketball program dedicated to competitive youth basketball.
We are also a Christian, faith based organization that is reaching out to surrounding parishes to help us grow within their communities and surrounding communities.
We will be having fun as well as challenging young players to understand the game quicker, explore their basketball talents, and improve their individual skills which will provide an opportunity for them to advance in basketball.
We will do this by building their spirits and supporting and assisting them with our knowledge of basketball as coaches and parents.
• We are an organization reaching out to parishes in the metropolitan area to help us grow within the community. • We recruit players and allocate them to teams. • We ask parishes for gym times to hold practices, scrimmages, leagues and tournaments.
• We develop basketball players as young as Kindergarten and plan on working the program throughout their high school experience.
• During the developmental years K-7th grade, we use a universal play book with an easy to understand structure. • Play development starts as early as 1st grade. • Older players 8th-12th grade will have more advanced structure concentrating on point production and allowing the athlete to identify their individual and unique talents in the game of basketball. • The older athletes are constantly encouraged to become model students and work as hard in the classroom as on the court. • We follow tournament structures that expose them to college coaches and high levels of competitive play.
• Locations vary, simply stated we need gyms. • We are asking all the surrounding parishes to consider our program and to help KC IMPACT grow within their own community. • We reach out to surrounding parishes asking if we can rent their gyms, once gyms are established we build teams and develop practice schedules out of available gym times.
• We have quite a bit of operating cost. (Gym rentals, uniforms, product apparel, practice equipment, web development, etc…) • Once the above costs have been met we give all other profit to charity and the church. • We will have a 60% (church/charity) to 40%(KC IMPACT operational cost) for team development, league play, and tournament play.
• We will sell KC Impact t-shirts which will be used towards fundraising. • We have and will provide the "GOLDEN TOTE". (more information on this fundraiser will be available soon!)
• We try to and work around kids school structured programs to allow them to play during their school basketball season. • Typically these programs run in the winter, then KC IMPACT will start up during spring, summer and fall taking breaks as needed within our sessions.
Goal coming soon!


Format: BackdropTileBackground,
Example: BackdropTileBackground,
Purpose: Fills the Frame with instances of the texture. Without the background file is stretched. One also should set BackdropBackgroundSize when using this feature.
Used in: BACKDROP


directive("alert", [ ->
defObj =
restrict: "E"
replace: true
transclude: true
scope:
theme: "@"
dismissible: "@"
template: '

<button type="button" class="close" data-dismiss="alert" data-ng-show="dismissible">
×
Close
</button>

'
link: (scope, el, attrs) ->
if attrs.dismissible is "" then attrs.dismissible = true
return defObj
]
)


| Generalized Linear Modeling (GLM) | Tutorial | Booklet | Reference |
| Gradient Boosting Machine (GBM) | Tutorial | Booklet | Reference |
| Deep Learning | Tutorial | Booklet | Reference |
| Distributed Random Forest | Tutorial | Booklet | Reference |
| Naive Bayes | Tutorial | Booklet | Reference |
| Ensembles (Stacking) | Tutorial | Booklet | Reference |


|
BIBLIOGRAPHY
Andrews, J. Cutler, The South Reports the Civil War. Princeton, N.J.: Princeton University Press, 1970.
Bates, Samuel P., History of Pennsylvania Volunteers, 1861-5. Harrisburg: B. Singerly, state printer, 1869-1871.
Bils, Mark, "Tariff Protection and Production in the Early U.S. Cotton Textile Industry," Journal of Economic History, 44, Dec. 1984, pp.1033-45.
Blair, William, Virginia's Private War: Feeding Body and Soul in the Confederacy, 1861-1865. New York: Oxford University Press, 1998.
--------------, and William Pencak, eds., Making and Remaking Pennsylvania's Civil War. University Park, Pa.: Pennsylvania State University Press, 2001.
Bragg, William Harris, Joe Brown's Army. The Georgia State Line, 1862-1865. Macon, Ga,: Mercer Univ. Press, 1987.
Craven Avery O., "The Price of Union," Journal of Southern History, XVIII, Feb. 1952, pp.3-19.
Davis, David Brion, Slavery and Human Progress. New York: Oxford University Press, 1987.
Elliot, Jonathan, The Debates of the Several State Conventions on the Adoption of the Federal Constitution. Philadelphia: J.B. Lippincott & Co., 1876.
Emerson, William E., "Leadership and Civil War Desertion in the Twenty-fourth and Twenty-fifth Regiments of North Carolina Troops," Southern Historian 18 (fall 1997), pp. 17-33.
Fogel, Robert William, and Engerman, Stanley L., Time on the Cross: The Economics of American Negro Slavery. Boston: Little, Brown and Company, 1974.
-------------, "Philanthropy at Bargain Prices: Notes on the Economics of Gradual Emancipation," Journal of Legal Studies, III, 1974, pp.380-1.
Fuller, J.F.C., "The Place of the American Civil War in the Evolution of War," Army Quarterly, XXVI, 1933, pp.316-325.
Gallagher, Gary W., The Confederate War. Boston: Harvard University Press, 1997.
Geary, James W., We Need Men: The Union Draft in the Civil War. DeKalb, Ill.: Northern Illinois University Press, 1991.
Genovese, Eugene, Roll, Jordan, Roll: The World the Slaves Made. New York: Pantheon Books, 1974.
Giuffre, Katherine A., "First in Flight: Desertion as Politics in the North Carolina Confederate Army," Social Science History 21, no.2 (summer 1997), pp. 245-63.
Hacker, Louis M., The Triumph of American Capitalism. N.Y.: Simon & Schuster, 1940.
Hamilton, Alexander, "Report on the Subject of Manufactures," in F.W. Taussig, State Papers and Speeches on the Tariff. Cambridge, Mass.: Harvard University Press, 1892. The report is also online, in exerpts, at http://members.tripod.com/~american_almanac/hammanuf.htm
Hammond, Bray, Banks and Politics in America From the Revolution to the Civil War. Princeton, N.J.: Princeton University Press, 1957.
Hancock, Harold B., Delaware During the Civil War: A Political History. Wilmington, Historical Society of Delaware, 1961.
Harper, Douglas R., "If Thee Must Fight:" A Civil War History of Chester County, Pa. West Chester, Pa.: Chester County Historical Society, 1990.
------------------, West Chester to 1865: That Elegant & Notorious Place. West Chester, Pa.: Chester County Historical Society, 1999.
Hay, John, and John G. Nicolay, Letters and State Papers of Abraham Lincoln, 1894.
Hummel, Jeffrey Rogers, Emancipating Slaves, Enslaving Free Men. Chicago: Open Court, 1996.
Jacoby, Tamar, Someone Else's House: America's Unfinished Struggle for Integration. Basic Books, 2000.
Klein, Herbert S., The Atlantic Slave Trade. Cambridge Univ. Press, 1999.
Litwack, Leon F., North of Slavery. The Negro in the Free States, 1790-1860. Chicago: Univ. of Chicago Press, 1961.
Lonn, Ella, Desertion During the Civil War. Gloucester, Mass.: American Historical Association, 1928. Reprint 1998 by Bison Books.
McManus, Edgar J., Black Bondage in the North. Syracuse, N.Y.: Syracuse Univ. Press, 1973.
-------------, A History of Negro Slavery in New York. Syracuse, N.Y.: Syracuse Univ. Press, 1966.
McPherson, James M., Drawn with the Sword: Reflections on the American Civil War. Oxford University Press, 1996.
-------------, What They Fought For, 1861-1865. Baton Rouge: Louisiana State University Press, 1994.
-------------, introduction to Writing the Civil War: The Quest to Understand, McPherson and William J. Cooper, eds. University of South Carolina Press, 1998.
McDonald, Forrest, States Rights and the Union 1776-1876. University Press of Kansas, 2000.
-------------, Novus Ordo Seclorum. University Press of Kansas, 1985.
Mitchell, Reid, The Vacant Chair: the Northern Soldier Leaves Home. New York: Oxford University Press, 1993.
Moore, Albert Burton, Conscription and Conflict in the Confederacy. New York: MacMillan, 1924; reprint 1963 (with introduction by William Garrett Piston), University of South Carolina.
Murdock, Eugene C., Patriotism Limited 1862-1865: The Civil War Draft & Bounty System, Kent State U. Press, 1967.
-----------------, ed., One Million Men: The Civil War Draft in the North, Champaign: University of Illinois, 1971.
Nash, Gary B., Race and Revolution. Madison, Wisc.: Madison House, 1990.
------------, and Jean R. Soderlund, Freedom by Degrees: Emancipation in Pennsylvania and Its Aftermath. N.Y.: Oxford University Press, 1991.
Nichols, Roy Franklin, The Disruption of the American Democracy. N.Y.: The MacMillan Co., 1948.
O'Connor, Thomas H., Lords of the Loom, the Cotton Whigs and the Coming of the Civil War. N.Y.: Scribner's, 1968.
Paquette, Robert Louis, and Ferleger, Louis A., eds., Slavery, Secession, and Southern History. Charlottesville: University of Virginia Press, 2000.
Rable, George C., The Confederate Republic: A Revolution Against Politics. Chapel Hill: University of North Carolina Press, 1994.
Reed, H. Clay, "Lincoln's Compensated Emancipation Plan," in Delaware Notes, 7 (1931).
Roark, James L., "Behind the Lines: Confederate Economy and Society," in James M. McPherson and William J. Cooper, eds., Writing the Civil War: The Quest to Understand. University of South Carolina Press, 1998.
Ruffner, Kevin Conley, "Civil War Desertion from a Black Belt Regiment: An Examination of the 44th Virginia Infantry," in Edward L. Ayers and John C. Willis, eds., The Edge of the South: Life in Nineteenth-Century Virginia. Charlottesville: University of Virginia, 1991.
--------------------, Maryland's Blue & Gray: A Border State's Union and Confederate Junior Officer Corps. Baton Rouge, La.: Louisiana State University Press, 1997.
Scott, Robert N., ed., The War of the Rebellion: A Compilation of the Official Records of the Union and Confederate Armies, 127 volumes, Washington, D.C., Government Printing Office, 1880-1909.
Shankman, Arnold M., The Pennsylvania Anti-War Movement 1861-1865. Cranbury, N.J.: Associated University Presses, 1980.
Shannon, Fred Albert, The Organization and Administration of the Union Army, 1861-65, Cleveland: The Arthur H. Clark Co., 1928.
Silver, David M., Lincoln's Supreme Court, Univ. of Ill. Press, 1957.
Stampp, Kenneth M., And the War Came. The North and the Secession Crisis, 1860-1861. Baton Rouge, La.: Louisiana State Univ. Press, 1970.
Summers, Mark W., The Plundering Generation: Corruption and the Crisis of the Union, 1849-1861. N.Y.: Oxford University Press, 1987.
Taussig, F.W., The Tariff History of the United States. New York, 1893.
Terrell, W.H.H., Indiana in the War of the Rebellion, official report of the state adjutant general, Indianapolis, 1869.
Thomas, Emory, The Confederate Nation, 1861-65. New York: Harper & Row, 1979.
Trefousse, Hans L., Thaddeus Stevens: Nineteenth-Century Egalitarian. Mechanicsburg, Pa.: Stackpole Books, 2000.
Van Metre, T.W., "The Coastwise Trade of the Atlantic Coast, 1789-1860," and "Early Development of the Internal Commerce of the United States, 1789-1830," both in History of Domestic and Foreign Commerce of the United States, Vol. I, Washington, D.C., The Carnegie Institution of Washington, 1915.
Vandiver, Frank E., "The Confederacy and the American Tradition," Journal of Southern History, XXVIII, Aug. 1962, pp.277-286.
Wallace, Anthony F.C., Rockdale: The Growth of an American Village in the Early Industrial Revolution. N.Y.: W.W. Norton & Co., 1972.
Watkins, Sam R., Co Aych. N.Y.: Macmillan, 1962.
Weigley, Russell F., ed., Philadelphia: A 300-Year History. N.Y.: W.W. Norton & Co., 1982.
Weitz, Mark A., A Higher Duty : Desertion Among Georgia Troops During the Civil War. University of Nebraska Press, 2000.
Williams, William H., Slavery and Freedom in Delaware, 1639-1865, Wilmington: Scholarly Resources, 1996.
Woodward, C. Vann, The Burden of Southern History. 3rd edition.
Louisiana State University Press, 1993.
Wright, William C., The Secession Movement in the Middle Atlantic States. Cranbury, N.J.: Associated University Presses, 1973.
|
| ©2002Douglas Harper | "When misunderstanding serves others as an advantage, one is helpless to make oneself understood." -Lionel Trilling |