Functional Spec
1. Introduction
1.1 Overview
I am going to develop a Real Time Strategy game for iOS and OSX devices with the possibility of expansion to further platforms such as Android. To this end I've decided to port the PC game ‘Age of Empires: Age of Kings’. I want to justify the mobile platform for RTS games, to prove this platform I have decided to take a game that was great and prove its quality on mobile.
I intend to rewrite this game through objective-C, I intend to work in an agile fashion with sprints and MVP adding core features and expanding to additional features as the project deadline allows. I intend to reuse game assets from the original game such as graphics and sounds, the reason for this reuse is: I would like to focus on usability and developing a gesture scheme for RTS on a mobile device. Game assets are easy to swap out allowing me to market this project with a different suit of non-copyright assets at a later stage.
Real Time Strategy Computing Elements
Real Time Strategy games interest me due to the diversity of computing elements.
AI
RTS games use intelligent Algorithms for path finding, player automation and combat mechanics and teamwork; I am very interested in implementing these elements.
Swarm AI
This type of game takes elements from swarm AI with the added interaction of a human coordinator to direct the swarm towards a structured goal.
Game Theory
Game Theory is a branch of mathematics concerned with the analysis of strategies for dealing with competitive situations where the outcome of a participant's choice of action depends critically on the actions of other participants. Game theory has been applied to contexts in war, business, and biology.
Game Board
This sort of game requires a ‘world’, this can be approached in several ways such as: a tiled hex-grid board. The world or board for this game can be displayed as:
- 3D,
- 2.5D/Isometric
- 2-D
I am most interested in the Isometric approach due to my interest in games like Age of Empires and Command and Conquer.
Human Computer Interaction
There is a lot of HCI in these games, well designed clear interfaces, intuitive feedback for actions, intelligent reward schemes, and immersive sounds. I believe HCI is what really sells a product and hooks a user. I want to prove the mobile platform as a good home for RTS through intelligent use of HCI.
Interface
I believe that interface has been more of a barrier on mobile platforms than processing power.
Background
Age of Empires 2 was released in 1999 for the PC; despite the age a decent port to mobile has yet to be created. The mobile platform is very powerful so far emulators exist for: PSP, PS2, Nintendo DS.
I believe a mobile platforms would be ideal for an RTS game in which gameplay is prioritized over graphics. I hope to overcome the absence of left; right and middle click operations with a combination of swipe gestures and multi touch gestures.
Gestures
Swipe selections and multi touch gestures will allow for easy unit selections; selecting a group will be as easy as circling the units, Pinching to zoom, gesture commands to choose formation or unit types…
Sliding windows
Removing clutter from the main screen will be key on small devices, using sliding windows will allow the user to view their army, resources and other non-critical information more with more detail.
Sound, Visual cues and Rewards
I believe that part of what makes games like ‘cut the rope’ and ‘Angry Birds’ successful is the depth of experience brought on by the sound effects and visuals such as visual and sound responses to success, rewards and positive reinforcement at a randomized percentage; the inconsistent rewards appeal to the gambler mind frame.
- The Psychology of the Near Miss, R. L. Reid
Psychology
A game in which the user becomes immersed and can pass hours without noticing is a good game, this is achieved by balancing task difficulties to user ability, if this balance is achieved a state coined as ‘cognitive flow’ occurs. This term was coined and explained by the psychologist Mihaly Csikszentmihalyi in the 1970s.
- Extreme focus on a task.
- A sense of active control.
- Merging of action and awareness.
- Loss of self-awareness.
- Distortion of the experience of time.
- The experience of the task being the only necessary justification for continuing it.
1.2 Business Context
I hope to appeal to a clientele with an interest in Games, particularly RTS games. I also hope to appeal to people interested in game design strategies as I intend to blog the development and strongly rely on good design techniques.
Business Contexts: From the customers perspective
The two obvious options for distribution of this application and charging are:
- Outright purchase.
- Free downloads which will include in-app ads
The existence of a free option will allow potential buyers to trial the game in a limited environment, a user that purchases a game after a trial is more likely to have a good experience than a user that buys and then decides they do not like the game.
Further revenue and experience can be generated through Micro Transactions, this will allow the user to purchase in game boosts and additional features such as:
- Expansions
- Faster farming, better combat abilities, cheats
Business Contexts: From the business owner’s perspective
Micro transactions, this will fund future development and continue to bring in revenue after the original purchase.
The Apple App store gives an inexpensive distribution to a huge market across countless devices: phones, tablets and OSX machines.
Depending on the ad placement ads could be included in the paid version as long as it doesn’t affect gameplay. However unpaid downloads would have less subtly placed ads as there was no original purchase and the revenue needs to be recovered for the download.
Similar Products
Age of Empires II: Age of Kings:
My project depends on re-use of game assets such as sounds and graphics from the original game
My finished product should closely mirror the original game, though only game assets will have been reused, this allows me the freedom to exchange the game assets after the project to market my game without copyright dangers. Released September 30, 1999, Re-released April 9, 2013
1.3 Glossary
- Sprite: 2D image / animation that can be moved on-screen and manipulated as a single object.
- AOE: Age of Empires, an RTS game developed by Ensemble Studios, released in 1999 and re-released in 2013
- Texture: a skin or overlay for a vertex
- Game Asset: A suite of sounds, graphics or behaviors used for a game
- IOS: The operating system for Apples smartphone and table series
- OSX: The operating system for Apples desktop and laptop devices
- RTS: In an Real Time Strategy, as in other war-games, the participants position and maneuver units and structures under their control to secure areas of the map and/or destroy their opponents' assets.
- MVP: Minimum Viable Product, this involves creating core functionality before adding high scope or additional features, it is used on tight deadline and lean startup projects.
2. General Description
2.1 Product / System Functions
Functionality:
The use of this game will follow four stages; first a game/match must be tweaked and created, then a map must be customized and created, the actual game to be played and then the victory state in which a goal state has been achieved. The user will be able to save their progress either to local storage or remote storage, based on the sprint this will different from Google game services to a remote API
Stage One:
Set up the match
- Choose Teams
- Allies
- Team Colours
- Choose Nation
- Define rules
- Resource limits
- Build times
- Choose Enemy
- Number of enemies
- Alliances
Stage Two:
Generate map or Choose Map
The aim is to create dynamically generated worlds with randomly placed resources, tiles and players; this makes replaying interesting.
- Choose the size of map
- Small, Medium, Large
- Choose Map type
- Islands
- Continents
- Random
- Generate a hex tile grid relevant to the chosen type The Hex grid will be the frame of reference for moving the sprites and placing textures such as:
- Soil
- Water
- Trees
- Gold, Stone, Food
- Disperse players at equal intervals within range of similar resources
Stage Three: Game play
Gameplay is the truly vital element to the game, this contains the most functionality and
- Select unit
- Circle or tap unit/s, long press to begin selection
- Move Camera
- Swipe or drag to move in a direction
- Pinch to zoom
- Move Unit
- Tap destination to move
- Double tap to gather/attack
- Use Unit abilities
- Drag ability tab from right/left
- Gesture to use ability (Macro)
- Create buildings
- Create
- Choose from ability list or Macro
- Choose location
- Required resources
- Correct Tech Age
- Accessible
- Create
- Repair
- Tap item to be repaired
- Accessible
- Resourced available
- Gather resource
- Stone
- Gold
- Food
- Wood
- Attack
- Animal
- Enemy
- Save State
- Google Game services
- Remote API
- Time out
- Annihilation
- Wonders
- Tap item to be repaired
Stage Four: Victory
2.2 User Characteristics and Objectives
Audience
This application will cater to users across several groups; the original game AOE was available for users of 10 years and up but primarily marketed at a more mature audience of RTS gamers.
Play Style & Interface
My aim is to create a user input system and user interface that will be clear to younger users while not feeling over simplified for the more hardcore gamers. RTS games tend to become extremely competitive with users using key bindings and macros to maximize their efficiency; I hope to create a gesture system similar to this macro system to allow hardcore gamers to optimize their play style.
The use of Google Game Services or a remote API will lead to the ability to save state and retrieve it on another android device; this is safer than local storage and handy if the user has more than one device. This should appeal to dedicated players that move from on the go devices to tablet devices.
2.3 Operational Scenarios
The following are explanations for the different interactions a user will be able to perform when running the application:
1. Create a game 2. Create a map
3. Game play functions
2.4 Constraints
IOS: Devices and IOS versions
Memory available per device
Project must be completed by the June 2014
Design Patterns
RESTFUL Standards compliance with API
3. Functional Requirements
3.1 MVP – Minimum Viable Product
Sprint 1
- Basic GUI:
- Animated sprites
- Basic AI:
- Move
- Single Player
- Static World
- Basic User input:
- Tap unit
- Basic drag-able camera
- Basic Unit Stats
- Health, Damage
- Persistence: Google Game Services
Sprint 2
- GUI:
- Add smoother digging and foraging, show units carrying resources, units decaying
- AI:
- Attack, gather
- Add more elaborate path choices, I intend to allow units to move around terrain, pick the shortest path to a resource
- User versus AI controlled enemy
- Allow the user to decide if there should be a completely automated enemy sharing the world. This will allow the soldier units to be used, along with trade and diplomacy menus. It will drain resources in the world twice as fast.
- Balanced unit stats
- Dynamic World Generation
- Randomly decide on the amount of wood, stone etc. to place and the location of the placements, keeping the random generation within fair a limit.
- Persistence: NodeJS Web service
- User input: Zoom, circle units
3.2 Interface
Description:
This is the interface the user will use to interact the game. This must be displayed properly on all acceptable devices. This encompasses features such as pinch zoom, drag camera, circle units and slide menus.Criticality: Vital
This is a vital component for our system as it is the front end of the application and the users only way to interface with the app. The real goal of this project is to make RTS more accessible, this goal above all is the most important for justifying RTS on mobile.Technical issues:
Screen size, processing power and platform can go from iPod Touch all the way to iMac Desktops, this app will need to make sure to take screen size into account when preforming actions, physical button placement also differs on devices and should be considered.Dependencies with other requirements:
GraphicsOTHER
The performance of our application relies a great deal on whether or not the end-user’s device is suitable to run it.3.3 Logic & Intelligence
Description:
This section deals with the game logic, the movement of units, combat, building this is section is very important for a good game.Criticality: Moderate
This section is important but the game is still playable will poor AI though the experience will be less enjoyable.Technical issues:
Porting the logic from the original game will be difficult without the original code to work off, this will be similar to black box testing in the way I will need to play the game and create and action and observe its results.Dependencies with other requirements:
Interface and Graphics3.4 Graphics
Description:
This requirement differs from Interface in that it is directly responsible for the drawing of the tiles and sprites, this requirement details the setup of a grid of hexagons to cover the board, this allows for sprite movement in 6 directions and a good interlocking board. It is intended to draw unit sprites separate from the grid but to use the grid to store location and tile graphics.Criticality: Vital
This element is vital and comprises the visualization of all other work, without this element no other elements can be tested.Technical issues:
Screen size, processing power and platform can go from iPod Touch all the way to iMac Desktops, this app will need to have sprites capable of scaling. The application should not lag and needs to be well optimized in order to provide the end-user with the performance they expect; in other words if they have a low end phone it may experience lag despite our efforts, so it’s not our fault but none the less should be striven to avoid.Dependencies with other requirements:
None3.5 Persistence
Description:
This section details the creation of a local and remote database to store game state if the match is paused, the intention is to implement a RESTful API using a MongoDB database and NodeJS backend but that will be seen in a later sprint such as Sprint 3.Criticality: Low
This is not a critical item but its inclusion would greatly increase player satisfaction, being able to continue games on different devices or to save a game and start a new one would be very helpful.Technical issues:
Implementing a full API takes a significant amount of time compared to the payoff of a simple file store, using third party API’ such as the Google Game Library allows speedier development but also enforces coding to their libraries removing a lot of wriggle room.Dependencies with other requirements:
This is dependent on all other elements since it is going to be saving their states e.g: saving unit layout and resources.4. System Architecture
4.1 System Structure Diagram
5. High-Level Design
Fig 5.1 Entity Relationship Diagram
6. Preliminary Schedule
6.1 Original Project Plan
Description
I intend to write a game for an iOS device, this game will take advantage of HCI features to make it comfortable on a mobile device. This project will utilize a web service to store state across devices, store high scores visible by other players, and allow playing against the same AI enemy.General area covered by the project:
This project covers:
Mobile applications Graphics HCI AI Persistence Web services Gaming Programming tools: List tools (compiler, database, web server, etc.) to be used NoSQL – MongoDB or CouchDB NodeJS – Backend service writing Typescript – Adds type and object orientation to JavaScript Express – A web framework for NodeJS to allow structured NodeJS projects ARC – Memory management in iOS Tiled – For creating tile maps in games Sprite framework – For creating graphics and animations on iOS devices Webserver – Apache, this will be used to expose my web services Debian – I will host my NodeJS and NoSQL DB on a Debian server, most likely on Rackspace or Amazons AWS. Learning Challenges: List the main new things (technologies, languages, tools, etc.) that you will have to learn: Objective-C NodeJS Express JavaScript Typescript MongoDB or CouchDB Tile and Graphic design Sprite Framework Path Finding AlgorithmsHardware / software platform:
State the hardware, software and platform for development: Debian iPad, iPhone MacBook Pro, OSX Mountain Lion Fig 6.2 PERT Chart| Task Name | Duration | Start | Finish |
| Submit Proposal | 0 | -- | -- |
| Submit Functional Spec | 0 | -- | -- |
| Research Objective C | 30~ | 1/12/13 | 10/1/14 |
| Research SpriteKit | 10~ | 10/1/14 | 20/1/14 |
| Research iOS Frameworks and tools: Mantle,Typhoon | 2~ | 20/1/14 | 22/1/14 |
| Create Map | 8~ | 22/1/14 | 30/1/14 |
| Create generic sprite | 14 | 1/2/14 | 15/2/14 |
| Create base classes: unit, building | 15 | 15/2/14 | 30/2/14 |
| Add movement AI | 14 | 1/3/14 | 15/3/14 |
| Add attack AI | 15 | 15/3/14 | 30/3/14 |
| Add Camera Movement | 10 | 1/4/14 | 10/4/14 |
| Add World generation | 10 | 10/4/14 | 20/4/14 |
| Persistence | 5 | 20/4/14 | 25/4/14 |
| Unit Stats | 5 | 25/4/14 | 30/4/14 |
| Tasks, mining, foraging | 15 | 1/5/14 | 15/5/14 |
| Review | 15 | 15/5/14 | 30/5/14 |
| Submit Project | 1 | 3/6/14 | 3/6/14 |
| Demonstration | - | 5/6/14 | 10/6/2014 |


With the comntr widget you can add comments to your page. Add this to your index.html:
Loading...
Your filter tag: FooBar
Your public key:
Anybody can post comments, as long as they can solve a basic captcha, only you can hide comments, as long as you have the proper private key.
An advanced user may use the the comntr extension or just remove the filter tag from the iframe URL to see hidden comments.
If you want to use this comments widget on your site, contact comntr (dot) io (plus) github (at) protonmail (dot) com for details.


MediaCapabilitiesProber
Overview
The MediaCapabilitiesProber is a tool probing what your browser can do, especially:
-
Which DRM system is supported
-
Check for HDCP support
-
which codecs are available
-
Check the color space support
⚠ This tool is still in an experimental phase, meaning that its API can change at any new release. This is not because it is not stable (it is actually) or should not be used in production. This is just because we want to receive your feedbacks before locking definitely the API.
We can for example add supplementary information of even explode the MediaCapabilitiesProber into several tools to lower the size of the import. We’re waiting for your feedbacks!
How to use it
As an experimental tool, the MediaCapabilitiesProber won’t be included in a default RxPlayer build.
Instead, it should be imported by adding the RxPlayer through a dependency
trough the npm registry (e.g. by doing something like npm install rx-player
) and then specifically importing this tool from
"rx-player/experimental/tools"
:
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
mediaCapabilitiesProber.getStatusForHDCP("1.1")
.then((hdcp11Status) => {
if (hdcp11Status === "Supported") {
console.log("HDCP 1.1 is supported");
}
});
Properties
LogLevel
type: string
default: "WARNING"
The current level of verbosity for this prober logs. Those logs all use the console.
From the less verbose to the most:
-
"NONE"
: no log -
"ERROR"
: unexpected errors (viaconsole.error
) -
"WARNING"
: The previous level + minor problems encountered (viaconsole.warn
) -
"INFO"
: The previous levels + noteworthy events (viaconsole.info
) -
"DEBUG"
: The previous levels + normal events of the prober (viaconsole.log
)
If the value set to this property is different than those, it will be
automatically set to "NONE"
.
It is set to "WARNING"
by default as it allows you to know if you forgot to
set required information on each APIs, if some APIs are missing in your
browser, etc.
You might want to set it to "NONE"
when in production.
Example
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
mediaCapabilitiesProber.LogLevel = "NONE";
Functions
getCompatibleDRMConfigurations
arguments:
-
keySystems (
Array.<Object>
): An array of key system configurations. Those objects have the following properties:-
type (
string
): Key system string identifying it in the browser. Always a reverse domain name (e.g. “org.w3.clearkey”). -
configuration (
Object
): Wanted MediaKeySystemConfiguration for this key system, as defined in the EME w3c specification.
-
return value: Array.<Object>
Probe the support of various key sytems and for each compatible ones, returns the corresponding configuration that will be used.
Return value
The returned value is an array of object with the same number of elements than the one given in argument.
It indicates the support for each Key System given in argument in the same order.
Due to that, the objects in this array look like the ones given in argument (but with an added property):
-
type (
string
): Corresponding key system string given in input. -
configuration (
Object
): Corresponding wanted MediaKeySystemConfiguration given in input. -
compatibleConfiguration (
undefined|Object
):if the type and configuration are both compatible with the browser, this is the corresponding actual MediaKeySystemConfiguration that will be effectively used. It will often correspond to a subset of the inputted configuration object (for example, you might have there fewer videoCapabilities that in the configuration object).
If the type and/or the configuration are not compatible, this property will not be defined.
Example
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
const mksConfiguration = {
initDataTypes: ["cenc"],
videoCapabilities: [
{
contentType: "video/mp4;codecs=\"avc1.4d401e\"", // standard mp4 codec
robustness: "HW_SECURE_CRYPTO",
},
{
contentType: "video/mp4;codecs=\"avc1.4d401e\"",
robustness: "SW_SECURE_DECODE",
}
]
};
const keySystems = [
// Let's consider this one as a compatible key system configuration
{ type: "com.widevine.alpha", configuration: mksConfiguration },
// Let's consider this one as not compatible
{ type: "com.microsoft.playready", configuration: mksConfiguration },
];
mediaCapabilitiesProber.getCompatibleDRMConfigurations(keySystems)
.then((drmConfigs) => {
drmConfigs.forEach((config) => {
const {
type,
configuration,
compatibleConfiguration
} = config;
if (compatibleConfiguration !== undefined) {
console.log("# Compatible configuration #############################");
console.log("Key System:", type);
console.log("Wanted configuration:", configuration);
console.log("Compatible configuration:", compatibleConfiguration);
console.log("########################################################");
console.log("");
} else {
console.log("# Incompatible configuration ###########################");
console.log("Key System:", type);
console.log("Wanted configuration:", configuration);
console.log("########################################################");
console.log("");
}
});
});
// Example output (please note that in this example, one of the widevine
// robustness is not supported):
//
// # Compatible configuration #############################
// Key System: com.widevine.alpha
// Wanted configuration:
// {
// "initDataTypes":["cenc"],
// "videoCapabilities": [
// {
// "contentType": "video/mp4;codecs=\"avc1.4d401e\"",
// "robustness": "HW_SECURE_CRYPTO"
// },
// {
// "contentType": "video/mp4;codecs=\"avc1.4d401e\"",
// "robustness": "SW_SECURE_DECODE"
// }
// ]
// }
// Compatible configuration:
// {
// "audioCapabilities": [],
// "distinctiveIdentifier": "not-allowed",
// "initDataTypes": ["cenc"],
// "label": "",
// "persistentState": "not-allowed",
// "sessionTypes": ["temporary"],
// "videoCapabilities": [
// {
// "contentType": "video/mp4;codecs=\"avc1.4d401e\"",
// "robustness":"SW_SECURE_DECODE"
// }
// ]
// }
// ########################################################
//
// # Incompatible configuration ###########################
// Key System: com.microsoft.playready
// Wanted configuration:
// {
// "initDataTypes":["cenc"],
// "videoCapabilities": [
// {
// "contentType": "video/mp4;codecs=\"avc1.4d401e\"",
// "robustness": "HW_SECURE_CRYPTO"
// },
// {
// "contentType": "video/mp4;codecs=\"avc1.4d401e\"",
// "robustness": "SW_SECURE_DECODE"
// }
// ]
// }
// ########################################################
getStatusForHDCP
arguments:
- type (
string
): The HDCP type (e.g. “1.0”, “1.1” or “2.0”)
return value: string
Test for an HDCP configuration.
The returned string of this function is either:
-
"Supported"
: This HDCP configuration is supported. -
"NotSupported"
: The HDCP configuration is not supported. -
"Unknown"
: The API is not available or it is but could not check if the HDCP type is supported.
⚠ As of the 2018-july-03, this feature is very poorly supported (with only some support on the EDGE browser). We should have a real support of it in the coming months on Chrome and Firefox.
Example
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
mediaCapabilitiesProber.getStatusForHDCP("1.1")
.then((hdcpStatus) => {
switch (hdcpStatus) {
case "Supported":
console.log("This HDCP version is supported");
break;
case "NotSupported":
console.log("This HDCP version is not supported");
break;
case "Unknown":
console.log("We could'nt tell if this HDCP version is supported.");
break;
}
});
getDecodingCapabilities
arguments:
- config (
Object
): Object with type, video and audio configuration.
return value: string
Probe for audio/video decoding capabilities.
Argument
The object in argument is inspired from the concerned API configurations. All its properties are optional, here are what you can set.
-
type (
string
): The media is either buffered in MediaSource, or directly as a file. As such, you can specify which one you want to probe through one of the following strings:- “media-source”
- “file”.
-
video (
Object
): The video capabilities you want to probe.- contentType (
string
): Media codec in mimeType format. - width (
number
): Video width. - height (
number
): Video Height. - bitrate (
number
): Bitrate of the video (in bits per second). - framerate (
string
): Number of frames used in one second. - bitsPerComponent (
number
): Number of bits used to encode one component par pixel.
- contentType (
-
audio (
Object
): The video capabilities you want to probe.- contentType (
string
): Media codec in mimeType format. - channels (
string
): Audio channels used by the track. - bitrate (
number
): Bitrate from stream (bits/second). - samplerate (
number
): Number of samples of audio carried per second.
- contentType (
Return value
The returned string of this function is either:
-
"Supported"
: This configuration is supported. -
"MaybeSupported"
: Some set configuration could not be probed because not enough information was provided, but what has been probed is supported. -
"NotSupported"
: The configuration is not supported.
Example
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
mediaCapabilitiesProber.getDecodingCapabilities({
type: "media-source",
video: {
contentType: "video/webm; codecs=\"vp<IP_ADDRESS>\"",
width: 1920,
height: 1080,
bitrate: 3450000,
framerate: '25',
bitsPerComponent: 8,
},
audio: {
contentType: "audio/webm; codecs=\"opus\"",
channels: 6,
bitrate: 1200,
samplerate: 44100,
},
}).then((status) => {
switch (status) {
case "Supported":
console.log("The configuration is supported");
break;
case "MaybeSupported":
console.log("The configuration may be supported");
break;
case "NotSupported":
console.log("The configuration is not supported");
break;
}
});
getDisplayCapabilities
arguments:
- config (
Object
): Object with display configuration.
return value: string
Probe what can be displayed on the screen.
Argument
The object in argument is inspired from the concerned API configurations. All its properties are optional, here are what you can set.
- colorSpace (
string
): Wanted color space (“srgb”, “p3”, etc). - width (
number
): Wanted display horizontal resolution. - height (
number
): Wanted display vertical resolution. - bitsPerComponent (
number
): Wanted display bpc capability.
Return Value
The returned string of this function is either:
-
"Supported"
: This configuration is supported. -
"MaybeSupported"
: Some set configuration could not be probed because not enough information was provided, but what has been probed is supported. -
"NotSupported"
: The configuration is not supported.
Example
import { mediaCapabilitiesProber } from "rx-player/experimental/tools";
mediaCapabilitiesProber.getDisplayCapabilities({
colorSpace: "p3",
width: 3840,
height: 2160,
bitsPerComponent: 10,
}).then((status) => {
switch (status) {
case "Supported":
console.log("The configuration is supported");
break;
case "MaybeSupported":
console.log("The configuration may be supported");
break;
case "NotSupported":
console.log("The configuration is not supported");
break;
}
});
Exploited browser APIs
The tool probes media capabilities from browsers (Chrome, Firefox, etc.) exploiting current available media API:
-
mediaCapabilities - Chrome >= 64 (https://github.com/WICG/media-capabilities)
- Check for decoding capabilites from video and audio attributes.
-
isTypeSupportedWithFeatures - Microsoft EDGE
- Check for DRM support + decoding and displaying capabilites from video, audio, display and media protection configuration.
-
isTypeSupported - Chrome >= 31 / Firefox >= 41 / EDGE / IE >= 11 / Safari
= 8 (https://developer.mozilla.org/en-US/docs/Web/API/MediaSource/isTypeSupported)
- Check for video and audio decoding support from content type.
-
matchMedia (with color gamut support) - Chrome >= 58.
- Check for color space support.
-
requestMediaKeySystemAccess - Chrome >= 42 / Firefox / EDGE / Safari (https://developer.mozilla.org/fr/docs/Web/API/Navigator/requestMediaKeySystemAccess)
- Check for DRM support.
-
getStatusForPolicy - ? (https://github.com/WICG/hdcp-detection/blob/master/explainer.md)
- Query a hypothetical status associated with an HDCP policy.


Entity Light
Light is the Entity definition for a light object.
Subclass of Entity.
Functions
| GetColor1 () | GetColor1 returns the first color used for the light. |
| GetColor2 () | GetColor2 returns the second color used for the light. |
| GetRateChange () | GetRateChange returns the rate of change of the light in msec. |
| GetArc () | GetArc returns the arc over which the light source shines. |
| GetIntensityStringPos () | GetIntensityStringPos returns the current location in the intensity string for the light. |
| GetIntensityStringPos () | GetIntensityString returns the string used to vary intensity of the light. |
| GetRadius () | GetRadius returns the radius of the light effect. |
| GetHighBound () | GetHighBound returns the high bound for the light (unknown). |
| GetLowBound () | GetLowBound returns the low bound for the light (unknown). |
| GetFogAlpha () | GetFogAlpha returns the intensity of fog effect. |
| OnOffSwitch () | OnOffSwitch returns true if the light is on. |
| IsNightOnly () | IsNightOnly returns true if the light is on during night only. |
| IsRepeating () | IsRepeating returns true if the light pattern repeats. |
| IsUseColor2 () | IsUseColor2 returns true if the light uses the secondary color. |
| IsUseArc () | IsUseArc returns true if the light uses the arc value. |
| IsUseFog () | IsUseFog returns true if the light uses the fog value. |
Functions
- GetColor1 ()
-
GetColor1 returns the first color used for the light.
Returns:
-
A table with "r", "g", and "b" members indicating light color components (each is numeric from 0.0 to 1.0).
- GetColor2 ()
-
GetColor2 returns the second color used for the light.
Returns:
-
A table with "r", "g", and "b" members indicating light color components (each is numeric from 0.0 to 1.0).
- GetRateChange ()
-
GetRateChange returns the rate of change of the light in msec.
Returns:
-
An integer indicating the rate of change of the light.
- GetArc ()
-
GetArc returns the arc over which the light source shines.
Returns:
-
An integer indicating the arc of the light in degrees.
- GetIntensityStringPos ()
-
GetIntensityStringPos returns the current location in the intensity string for the light.
Returns:
-
An integer indicating the current offset in the intensity string.
- GetIntensityStringPos ()
-
GetIntensityString returns the string used to vary intensity of the light.
Returns:
-
A string indicating the pattern of intensity change for the light.
- GetRadius ()
-
GetRadius returns the radius of the light effect.
Returns:
-
A numeric value indicating the radius.
- GetHighBound ()
-
GetHighBound returns the high bound for the light (unknown).
Returns:
-
A numeric value indicating the high bound.
- GetLowBound ()
-
GetLowBound returns the low bound for the light (unknown).
Returns:
-
A numeric value indicating the low bound.
- GetFogAlpha ()
-
GetFogAlpha returns the intensity of fog effect.
Returns:
-
A numeric value indicating the fog level.
- OnOffSwitch ()
-
OnOffSwitch returns true if the light is on.
Returns:
-
A boolean indicating if the light is on.
- IsNightOnly ()
-
IsNightOnly returns true if the light is on during night only.
Returns:
-
A boolean indicating if the light is on during night only.
- IsRepeating ()
-
IsRepeating returns true if the light pattern repeats.
Returns:
-
A boolean indicating if the light pattern repeats.
- IsUseColor2 ()
-
IsUseColor2 returns true if the light uses the secondary color.
Returns:
-
A boolean indicating if the light uses both defined colors.
- IsUseArc ()
-
IsUseArc returns true if the light uses the arc value.
Returns:
-
A boolean indicating if the light uses the arc value.
- IsUseFog ()
-
IsUseFog returns true if the light uses the fog value.
Returns:
-
A boolean indicating if the light uses the fog value.


Regular Expressions
CODEX
Regular Expressions
description:
Regular expressions are patterns used to match character
combinations in strings. In JavaScript, regular expressions
are also objects. These patterns are used with the exec()
and test()
methods of RegExp
, and with the match()
, matchAll()
, replace()
, replaceAll()
, search()
, and split()
methods of String
. This chapter describes JavaScript regular expressions.
Creating a regular expression
You construct a regular expression in one of two ways:
- Using a regular expression literal, which consists of a pattern enclosed between slashes, as follows:
let re = /ab+c/;
- Regular expression literals provide compilation of the regular expression when the script is loaded. If the regular expression remains constant, using this can improve performance.
2. Or calling the constructor function of the RegExp
object, as follows:
-
let re = new RegExp('ab+c');
Using the constructor function provides runtime compilation of the regular expression. Use the constructor function when you know the regular expression pattern will be changing, or you don't know the pattern and are getting it from another source, such as user input.
Writing a regular expression pattern
A regular expression pattern is composed of simple characters,
such as /abc/
,
or a combination of simple and special characters, such as
/ab*c/
or
/Chapter (\d+)\.\d*/
.
The last example includes parentheses, which are used as a memory device. The match made with this part of the pattern is remembered for later use.
Using simple patterns
Simple patterns are constructed of characters for which you want to find a direct match.
For example, the pattern
/abc/
matches
character combinations in strings only when the exact sequence
"abc"
occurs (all characters together and in that order).
Such a match would succeed in the strings
"Hi, do you know your abc's?"
and
"The latest airplane designs evolved from
slabcraft."
In both cases the match is with the substring
"abc"
.
There is no match in the string
"Grab crab"
because while it contains the substring
"ab c"
, it does not contain the exact substring
"abc"
.
Using special characters
When the search for a match requires something more than a direct match, such as finding one or more b's, or finding white space, you can include special characters in the pattern.
For example, to match
a single "a"
followed by zero or more "b"
s followed by "c"
, you'd use the pattern
/ab*c/
:
the*
after"b"
means "0 or more occurrences of the preceding item." In the string"cbbabbbbcdebc"
, this pattern will match the substring"abbbbc"
.
Assertions : Assertions include boundaries, which indicate the beginnings and endings of lines and words, and other patterns indicating in some way that a match is possible (including look-ahead, look-behind, and conditional expressions).
Character classes : Distinguish different types of characters. For example, distinguishing between letters and digits.
Groups and ranges : Indicate groups and ranges of expression characters.
Quantifiers : Indicate numbers of characters or expressions to match.
Unicode property escapes : Distinguish based on unicode character properties, for example, upper- and lower-case letters, math symbols, and punctuation.
If you want to look at all the special characters that can be used in regular expressions in a single table, see the following:
Special characters in regular expressions.
Escaping
If you need to use any of the special characters literally
(actually searching for a
"*"
,
for instance), you must escape it by putting a
backslash
in front of it.
For instance, to search for
"a"
followed by
"*"
followed by
"b"
,
you'd use/a\*b/
--- the backslash "escapes" the"*"
, making it literal instead of special.
Similarly, if you're writing a regular expression literal and need to match a slash ("/"), you need to escape that (otherwise, it terminates the pattern)
For instance, to search for the string "/example/"
followed by one or more alphabetic characters, you'd use
/\/example\/[a-z]+/i
--the backslashes before each slash make them literal.
To match a literal backslash, you need to escape the backslash.
For instance, to match the string "C:\" where "C" can be any letter,
you'd use
/[A-Z]:\\/
--- the first backslash escapes the one after it, so the expression searches for a single literal backslash.
If using the
RegExp
constructor with a string literal,
remember that the backslash is an escape in string literals,
so to use it in the regular expression, you need to escape it
at the string literal level.
/a\*b/
and
new RegExp("a\\*b")
create the same expression,
which searches for "a" followed by a literal "*" followed by "b".
If escape strings are not already part of your pattern you can
add them using
String.replace
:
function escapeRegExp(string) {
return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}
The "g" after the regular expression is an option or flag that performs a global search, looking in the whole string and returning all matches.
Using parentheses
Parentheses around any part of the regular expression pattern causes that part of the matched substring to be remembered.
Once remembered, the substring can be recalled for other use.
Using regular expressions in JavaScript
Regular expressions are used with the
RegExp
methods
test()
and exec()
and with the
String
methods match()
, replace()
, search()
, and split()
.
Method Descriptions
exec()
Executes a search for a match in a string.
It returns an array of information or
null
on a
mismatch.
test()
Tests for a match in a string.
It returns
true
or
false
.
match()
Returns an array containing all of the matches, including
capturing groups, or
null
if no
match is found.
matchAll()
Returns an iterator containing all of the matches, including capturing groups.
search()
Tests for a match in a string.
It returns the index of the match, or
-1
if the
search fails.
replace()
Executes a search for a match in a string, and replaces the matched substring with a replacement substring.
replaceAll()
Executes a search for all matches in a string, and replaces the matched substrings with a replacement substring.
split()
Uses a regular expression or a fixed string to break a string into an array of substrings.
Methods that use regular expressions
When you want to know whether a pattern is found in a string,
use the
test()
or
search()
methods;
for more information (but slower execution) use the
exec()
or
match()
methods.
If you use
exec()
or
match()
and if
the match succeeds, these methods return an array and update
properties of the associated regular expression object and also
of the predefined regular expression object,
RegExp
.
If the
match fails, the exec()
method returns null
(which coerces to
false
).
In the following example, the script uses the
exec()
method
to find a match in a string.
let myRe = /d(b+)d/g;
let myArray = myRe.exec('cdbbdbsbz');
If you do not need to access the properties of the regular
expression, an alternative way of creating
myArray
is with
this script:
let myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to "cdbbdbsbz".match(/d(b+)d/g); however,
// "cdbbdbsbz".match(/d(b+)d/g) outputs Array [ "dbbd" ], while
// /d(b+)d/g.exec('cdbbdbsbz') outputs Array [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ].
(See different behaviors for further info about the different behaviors.)
If you want to construct the regular expression from a string, yet another alternative is this script:
let myRe = new RegExp('d(b+)d', 'g');
let myArray = myRe.exec('cdbbdbsbz');
With these scripts, the match succeeds and returns the array and updates the properties shown in the following table.
Results of regular expression execution.
You can use a regular expression created with an object initializer without assigning it to a letiable.
If you do, however, every occurrence is a new regular expression.
For this reason, if you use this form without assigning it to a letiable, you cannot subsequently access the properties of that regular expression.
For example, assume you have this script:
let myRe = /d(b+)d/g;
let myArray = myRe.exec('cdbbdbsbz');
console.log('The value of lastIndex is ' + myRe.lastIndex);
// "The value of lastIndex is 5"
However, if you have this script:
let myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log('The value of lastIndex is ' + /d(b+)d/g.lastIndex);
// "The value of lastIndex is 0"
The occurrences of
/d(b+)d/g
in
the two statements are different regular expression objects and
hence have different values for their
lastIndex
property.
If you need to access the properties of a regular expression created with an object initializer, you should first assign it to a variable.
[Advanced searching with flags]
Regular expressions have six optional flags that allow for functionality like global and case insensitive searching.
These flags can be used separately or together in any order, and are included as part of the regular expression.
Flag Description Corresponding property
g
Global
search.
RegExp.prototype.global
i
Case-insensitive search.
RegExp.prototype.ignoreCase
m
Multi-line
search.
RegExp.prototype.multiline
s
Allows .
to match newline characters.
RegExp.prototype.dotAll
u
"unicode"; treat a pattern as a sequence of unicode
code points.
RegExp.prototype.unicode
y
Perform a
"sticky" search that matches starting at the current
position in the target string.
RegExp.prototype.sticky
Regular expression flags
To include a flag with the regular expression, use this syntax:
let re = /pattern/flags;
or
let re = new RegExp('pattern', 'flags');
Note that the flags are an integral part of a regular expression. They cannot be added or removed later.
For example,
re = /\w+\s/g
creates a regular expression that looks for one or more
characters followed by a space, and it looks for this
combination throughout the string.
let re = /\w+\s/g;
let str = 'fee fi fo fum';
let myArray = str.match(re);
console.log(myArray);
// ["fee ", "fi ", "fo "]
You could replace the line:
let re = /\w+\s/g;
with:
let re = new RegExp('\\w+\\s', 'g');
and get the same result.
The behavior associated with the
g
flag is
different when the .exec()
method is used.
The roles of "class" and "argument" get reversed:
In the case of .match()
, the string class (or data type) owns the method and the
regular expression is just an argument,
while in the case of .exec()
, it is the regular expression that owns the method, with the
string being the argument.
Contrast this
str.match(re)
versus
re.exec(str)
.
The g
flag is
used with the .exec()
method to get iterative progression.
let xArray; while(xArray = re.exec(str)) console.log(xArray);
// produces:
// ["fee ", index: 0, input: "fee fi fo fum"]
// ["fi ", index: 4, input: "fee fi fo fum"]
// ["fo ", index: 7, input: "fee fi fo fum"]
The m
flag is
used to specify that a multiline input string should be treated
as multiple lines.
If the m
flag
is used, ^
and
$
match at the
start or end of any line within the input string instead of the
start or end of the entire string.
Using special characters to verify input
In the following example, the user is expected to enter a phone number. When the user presses the "Check" button, the script checks the validity of the number. If the number is valid (matches the character sequence specified by the regular expression), the script shows a message thanking the user and confirming the number. If the number is invalid, the script informs the user that the phone number is not valid.
Within non-capturing parentheses
(?:
, the
regular expression looks for three numeric characters
\d{3}
OR
|
a left
parenthesis
\(
followed by
three digits
\d{3}
, followed by a close parenthesis
\)
, (end
non-capturing parenthesis
)
), followed by
one dash, forward slash, or decimal point and when found,
remember the character
([-\/\.])
,
followed by three digits
\d{3}
, followed
by the remembered match of a dash, forward slash, or decimal
point \1
,
followed by four digits
\d{4}
.
The
Change
event
activated when the user presses Enter sets the value of
RegExp.input
.
HTML

Enter your phone number (with area code) and then click "Check".

The expected format is like ###-###-####.

<form action="#">
<input id="phone">
<button onclick="testInfo(document.getElementById('phone'));">Check</button>
</form>
JavaScript
let re = /(?:\d{3}|\(\d{3}\))([-\/\.])\d{3}\1\d{4}/;
function testInfo(phoneInput) {
let OK = re.exec(phoneInput.value);
if (!OK) {
console.error(phoneInput.value + ' isn\'t a phone number with area code!');
} else {
console.log('Thanks, your phone number is ' + OK[0]);}
}
Cheat Sheet
If you found this guide helpful feel free to checkout my GitHub/gist's where I host similar content:
bgoonz’s gists · GitHub
Web Developer, Electrical Engineer JavaScript | CSS | Bootstrap | Python | React | Node.js | Express | Sequelize…github.com
Or Checkout my personal Resource Site:


Dr. Babloo Chaudhary (Ph.D., Kyushu University Japan) came to speak on the topic "Resilient Foundation Model against Earthquake and Tsunami".
Dr. Nimisha Joshi (Ph.D., University of Edinburgh) came to speak on the topic "Nanoparticles: applications, mobility and their environmental impact".
Dr. Bachu Anilkumar (Ph.D., Indian Institute of Technology Madras) came to speak on the topic "Use of Vehicle Location Data for Advanced Public Transportation Systems Applications".
Dr. Saikat Sarkar (Ph.D., Indian Institute of Science Bangalore) came to speak on the topic "A discrete formulation for macroscopic modelling".
Dr. Debojyoti Pandit (Ph.D., Indian Institute of Technology Madras) came to speak on the topic "A general framework for large deflection of beams using moment-curvature based models".
Dr. Kundan Kumar (Ph.D., Eindhoven University of Technology) came to speak on the topic "Solution strategies for coupled flow and geomechanics problems in porous media".
Dr. Debojyoti Pandit (Ph.D., Indian Institute of Technology Madras) came to speak on the topic "A general framework for large deflection of beams using moment-curvature based models".
Dr. S.K. Chakrabarti (Ph.D., University of Arizona, USA) came to speak on the topic "A Parametric Study on the Behavior of Steel Plate-Anchor Assembly Embedded in Concrete under Torsion".
Dr. S.L. Dhingra (Ph.D., Indian Institute of Technology Kanpur) came to speak on the topic "Planning for Beautiful and Smart Cities for Sustainable Infrastructure".


This website is under construction!
We will be live in:
0
Days
0
Hours
0
Minutes
0
Seconds
Enter your email address to receive updates
Subscribe


This is an exciting site with a lot of interesting projects.
I have just had my solarpanels and a ventilationssystem with passive heat recovery (Nilan Comfort 300) installed in my house. Now its time to monitor....
The basics is that i have 3 phase supply from the grid and 1 phase inverter from the PV setup.The inverter is a Solutronics SP35 which can supply production data through RS232 or RS485. There is also the possibility to fetch data through an ethernet port but this is a binary protocol that I don't think my programming skills are good enough to utilize.
My present electricity meter is a dial type but soon the electricity company will exchange that for a electronic type with a IR blinking 400 times for every Kwh being used
I was planning on using my newly bought RaspberryPi to get data from the inverter through a RS485 cable. At the same time build and install the PV and home monitoring system. I have some questions though.
Base station and CMS should be on the RaspberryPi with a RFM12PI supplied by a emonTx with 1 CT and a AC-AC adapter (later a IR detector) temperature sensors etc.
- For my setup 3 phase in and 1 phase inverter i need 4 CT's Do I need need 2 pcs of emonTX for this?
- Could the EmonTx shield be used in stead of 2 emonTx'es to monitor 3 grid phases and one inverter phase?
- Could I rely on the blinking Ir led on the new meter in stead of the CT's?
- Alse if I use CT's, do i need 4 AC-AC transformers or could i do with just 1?
- If I succeed in getting the inverter data out through the RS486 interface, will it be possible to display these data alongside the Emon data in the emoncms?
- Which frequence should I choose 433MHz or 868MHz? I guess there will be fever systems on 868MHz so there i should expect less interference using this frequency – but then shorter range.
I am fortunate to have a contract with the electricity company that lets me get my surplus production of electricity in the summer back at no charge (no tax, no vat etc.) within a year.
I have soldering skills but my programming skills are very old and rusty – aka haven't been used since 1975.
Sorry for my many questions. They reflect my lack of knowledge in this area.
Re: What shall I choose?
Just dealing with the power side (I'll leave the CMS & RaspberryPi to others more knowledgeable in those areas).
If you want to measure the true power across 3 phases, then you need a voltage monitor on each phase. It's possible to use just one, but then you have to assume the phases are perfectly balanced voltage-wise. That could lead to errors.
Have a read of this thread to see how 3 emonTx's can be stacked to read 3 phases.
Have a read of this one where you should find details about reading the LED on your meter (and what it means!).


YARN is scalable very easily: any new NodeManager could join to the configured ResourceManager and start to execute jobs. But to achieve full elasticity we need a decommissioning process which helps to remove existing nodes and down-scale the cluster.
YARN Nodes could be decommissioned NORMAL or GRACEFUL.
Normal Decommission of YARN Nodes means an immediate shutdown.
Graceful Decommission of YARN Nodes is the mechanism to decommission NMs while minimize the impact to running applications. Once a node is in DECOMMISSIONING state, RM won’t schedule new containers on it and will wait for running containers and applications to complete (or until decommissioning timeout exceeded) before transition the node into DECOMMISSIONED.
To do a normal decommissioning:
In the next sections we will cover some more detailed usage (for example: using graceful decommissioning with timeout).
yarn rmadmin -refreshNodes [-g [timeout in seconds] -client|server] notifies NodesListManager to detect and handle include and exclude hosts changes. NodesListManager loads excluded hosts from the exclude file as specified through the yarn.resourcemanager.nodes.exclude-path configuration in yarn-site.xml. (Note: It is unnecessary to restart RM in case of changing the exclude-path as this config will be read again for every refreshNodes command)
The format of the file could be plain text or XML depending the extension of the file. Only the XML format supports per node timout for graceful decommissioning.
NodesListManager inspects and compares status of RMNodes in resource manager and the exclude list, and apply necessary actions based on following rules:
Accordingly, RECOMMISSION, GRACEFUL_DECOMMISSION or DECOMMISSION RMNodeEvent will be sent to the RMNode.
To support flexible graceful decommission of nodes using different timeout through single or multiple refreshNodes requests, HostsFileReader supports optional timeout value after each hostname (or ip) in the exclude host file.
The effective decommissioning timeout to use for a particular host is based on following priorities:
In case of server side timeout:
In case of client side timout (see bellow):
NodesListManager decides the effective timeout to use and set it on individual RMNode. The timeout could also be dynamically adjusted through yarn rmadmin -refreshNodes -g [timeout in seconds] command. NodesListManager will resolve the effective timeout to use and update RMNode as necessary of the new timeout. Change of timeout does not reset the ongoing decommissioning but only affect the evaluation of whether the node has reached decommissioning timeout.
Here is a sample excludes file in xml format.
<?xml version="1.0"?> <hosts> <host><name>host1</name></host> <host><name>host2</name><timeout>123</timeout></host> <host><name>host3</name><timeout>-1</timeout></host> <host><name>host4, host5,host6</name><timeout>1800</timeout></host> </hosts>
If the file extension of the exclude file is not xml, standard one-line-per-host format is used without timeout support.
host1 host2 host3
Note: In the future more file formats are planned with timeout support. Follow the YARN-5536 if you are interested.
Important to mention, that the timeout is not persited. In case of a RM restart/failover the node will be immediatelly decommission. (Follow the YARN-5464 for changes in this behavior).
Timeout of Graceful decommissioning could be tracked on server or client side. The -client|server indicates if the timeout tracking should be handled by the client or the ResourceManager. The client side tracking is blocking, while the server-side tracking is not.
Upon receiving GRACEFUL_DECOMMISSION event, the RMNode will save the decommissioning timeout if specified, update metrics for graceful decommission and preserve its original total capacity, and transition into DECOMMISSIONING state.
Resources will be dynamically and periodically updated on DECOMMISSIONING RMNode so that scheduler won’t be scheduling new containers on them due to no available resources.
DecommissioningNodeWatcher is the YARN component that tracks DECOMMISSIONING nodes status automatically and asynchronously after client/admin made the graceful decommission request. NM periodically send RM heart beat with it latest container status. DecommissioningNodeWatcher tracks heartbeat updates on all DECOMMISSIONING nodes to decide when, after all running containers on the node have completed, will be transitioned into DECOMMISSIONED state after which NodeManager will be told to shutdown.
Under MR application, a node, after completes all its containers, may still serve it map output data during the duration of the application for reducers. The YARN graceful decommission mechanism keeps such DECOMMISSIONING nodes until all involved applications complete. It could be however undesirable under long-running applications scenario where a bunch of “idle” nodes might stay around for long period of time. DecommissioningNodeWatcher balances such concern with a timeout — a DECOMMISSIONING node will be DECOMMISSIONED no later than decommissioning timeout regardless of running containers or applications. If running containers finished earlier, it continues waiting for applications to finish until the decommissioning timeout. When decommissioning timeout reaches, the node will be decommissioned regardless. The node will be deactivated and owning tasks will be rescheduled as necessary.
Status of all decommissioning node are logged periodically (every 20 seconds) in resource manager logs. Following are the sub-status of a decommissioning node:
| Property | Value |
|---|---|
| yarn.resourcemanager.nodemanager-graceful-decommission-timeout-secs | Timeout in seconds for YARN node graceful decommission. This is the maximal time to wait for running containers and applications to complete before transition a DECOMMISSIONING node into DECOMMISSIONED. The default value is 3600 seconds. Negative value (like -1) is handled as infinite timeout. |
| yarn.resourcemanager.decommissioning-nodes-watcher.poll-interval-secs | Period in seconds of the poll timer task inside DecommissioningNodesWatcher to identify and take care of DECOMMISSIONING nodes missing regular heart beat. The default value is 20 seconds. |
| yarn.resourcemanager.nodes.exclude-path | Path to file with nodes to exclude. |
| yarn.resourcemanager.nodes.include-path | Path to file with nodes to include. |


{{message?.data}}
Connecting to backend...
Waiting for log messages...
{{ state$ | async }} / Messages [{{(throttledMessages$ | async).length}}/{{historyLimit}}]
Disconnected
Connecting
[{{retry.count}}/{{retry.max}}] Connection failed - retrying in {{ getRetrySeconds(retry.delay) }}s


The game of Pig Dice may seem simple, but it is a test of greed, luck, and strategy.
Each player may roll as many times as they want on their turn, and save their roll at any time, rolling 2 1d6 dice.
If at any point you roll a 1, on either of your dice, your turn is forcibly ended and your score for that turn is 0
Will you take your low roll and guaranteed points? Or will you try to push for the maximum score of 12 in a turn?
When player1 has ended their turn, regardless of score, player2 will begin their turn under the same rules
First player to score a total of 100 or more wins!


Mr Key is averse to the habit of computer boffins to constantly tweak and fiddle with software, even if there may be good reasons for doing so. But as you can see, Hooting Yard is undergoing some form of WordPress “upgrade”, so things may look a bit odd for a few days until the new fanglements have been ironed out. Bear with me.


Dunce help Desk is a tool for all Students to communicate amongst eachother
seamlessly. This app will allow Students to chat live, create projects, blog, etc.
This section will explain the features of DhD and how it will benefit the user.
The DhD Mission
This will be our mission and what we stand for.
Not sure what exactly we will put here.
Message of the day: DhD is going to be an awesome site!


|
|
def | Operator_Name |
| |
|
def | __init__ |
| |
|
def | property |
| |
|
def | mutable_property |
| |
|
def | clear_property |
| |
|
def | has_property |
| |
|
def | operator |
| |
|
def | set_operator |
| |
|
def | clear_operator |
| |
|
def | has_operator |
| |
|
def | value |
| |
|
def | mutable_value |
| |
|
def | clear_value |
| |
|
def | has_value |
| |
|
def | MergeFrom |
| |
|
def | ParseASCII |
| |
|
def | ParseASCIIIgnoreUnknown |
| |
|
def | Equals |
| |
|
def | IsInitialized |
| |
|
def | ByteSize |
| |
|
def | ByteSizePartial |
| |
|
def | Clear |
| |
|
def | OutputUnchecked |
| |
|
def | OutputPartial |
| |
|
def | TryMerge |
| |
|
def | __str__ |
| |
|
|
| property_ |
| |
|
| value_ |
| |
|
| has_property_ |
| |
|
| has_operator_ |
| |
|
| operator_ |
| |
|
| has_value_ |
| |
|
|
int | LESS_THAN = 1 |
| |
|
int | LESS_THAN_OR_EQUAL = 2 |
| |
|
int | GREATER_THAN = 3 |
| |
|
int | GREATER_THAN_OR_EQUAL = 4 |
| |
|
int | EQUAL = 5 |
| |
|
int | HAS_ANCESTOR = 11 |
| |
|
tuple | Operator_Name = classmethod(Operator_Name) |
| |
|
int | has_property_ = 0 |
| |
|
int | has_operator_ = 0 |
| |
|
int | operator_ = 0 |
| |
|
int | has_value_ = 0 |
| |
|
int | kproperty = 1 |
| |
|
int | koperator = 2 |
| |
|
int | kvalue = 3 |
| |
The documentation for this class was generated from the following file:
- code/googleappengine-read-only/python/google/appengine/datastore/datastore_v4_pb.py


Mary-Claire & Kasey
menu
WEDDING DETAILS
REGISTRY
GUEST BOOK
PHOTO GALLERY
WEDDING DETAILS
REGISTRY
GUEST BOOK
PHOTO GALLERY
Our Gift Registry
Click the images to follow the link to our personal gift registry for each store.


The GetOpt
structure provides command-line argument processing similar
to the GNU getopt library. It supports both short options (a single
character preceded by a single minus character) and long options (multi-character
names preceded by two minus characters). Options may require an argument;
for short options, the argument is the next command-line argument, while for
long options, the argument follows an equal character (e.g.,
"--foo=bar"). If the command-line arguments contains the string
"--", then all subsequent arguments are passed through
as non-options.
This implementation was ported from Sven Panne’s Haskell implementation by Riccardo Pucella and has then been updated in various ways.
Synopsis
structure GetOpt
Interface
datatype 'a arg_order
= RequireOrder
| Permute
| ReturnInOrder of string -> 'a
datatype 'a arg_descr
= NoArg of unit -> 'a
| ReqArg of (string -> 'a) * string
| OptArg of (string option -> 'a) * string
type 'a opt_descr = {
short : string,
long : string list,
desc : 'a arg_descr,
help : string
}
val usageInfo : {
header : string,
options : 'a opt_descr list
} -> string
val getOpt : {
argOrder : 'a arg_order,
options : 'a opt_descr list,
errFn : string -> unit
} -> string list -> ('a list * string list)
Description
datatype 'a arg_order = …
-
This datatype is used to specify the ordering policy for command-line arguments. The constructors are interpreted as follows:
RequireOrder
-
No options are processed after the first non-option argument is encountered.
Permute
-
Options and non-options may be freely mixed.
ReturnInOrder of string -> 'a
-
Non-options are converted to options using the supplied function.
datatype 'a arg_descr
= …-
This datatype is used to describe the optional argument of an option. Each of the constructors has a function as an argument that is used to generate the representation of the processed option. The constructors are interpreted as follows:
NoArg of unit -> 'a
-
The option does not have an argument, the supplied function is applied to unit when processing the option.
ReqArg of (string -> 'a) * string
-
The option requires an argument, which is handled by the given function. The string is the name of the argument used when printing a usage message.
OptArg of (string option -> 'a) * string
-
The argument is optional and The string is the name of the argument used when printing a usage message.
type 'a opt_descr = { … }
-
This record type describes the properties of a command-line option. Its fields have the following meaning:
short : string
-
A string containing the allowed short flags for the option.
long : string list
-
A list of the allowed long flags for the option.
desc : 'a arg_descr
-
The description of how to process the option’s argument.
help : string
-
A descriptive message that is used to construct the usage message (see the
usageInfo
function).
val usageInfo : {header, options} -> string
-
usageInfo {header, options}
returns a usage string suitable for a help message. Theheader
argument is prepended to the message (with a newline between it and the rest of the message). Each option is described on its own line. val getOpt : {…} -> string list -> ('a list * string list)
-
getOpt {argOrder, options, errFn}
returns a function for processing command-line options, which will return a list of results from processing the options and a list of the residual command-line arguments. The arguments to the call areargOrder : 'a arg_order
-
Specifies the ordering policy for processing command-line arguments.
options : 'a opt_descr list
-
The descriptors for the command-line options.
errFn : string -> unit
-
An error callback function that is used to report errors during argument processing.
Examples
There are two common approaches to using the GetOpt
structure. The first
is to define a type that classifies the command-line options. For example,
datatype opt = AFlg | B of string | C of int | Other of string | Bad
val opts = [
{ short = "aA", long = [],
desc = NoArg(fn () => AFlg),
help = "Set A flag"
},
{ short = "b", long = ["set-b"],
desc = ReqArg(B, "<name>"), help = "Set B name"
},
{ short = "", long = ["cval"],
desc = OptArg (
fn (SOME s) => (case Int.fromString s
of SOME n => C n
| NONE => Bad)
| NONE => C 0,
"<n>"),
help = "Set C value (default 0)"
}
]
fun usage () = print (usageInfo{header = "usage:", options = opts})
val doOpts = getOpt {
argOrder = ReturnInOrder (fn s => Other s),
options = opts,
errFn = fn msg => raise Fail msg
}
The usage function will print the following text:
usage:
-a, -A Set A flag
-b <name> --set-b=<name> Set B name
--cval[=<n>] Set C value (default 0)
Applying the doOpts
function with the following arguments
doOpts ["-A", "foo", "--", "-c", "baz"];
results in
([AFlg, Other "foo", Other "--", Other "-c", Other "baz"], [])
Note that the second component of the result will always be the empty list
because the non-options were wrapped with Other
. The “-c” argument was
treated as a non-option because it came after the "--."
The other approach to using the GetOpt
structure is to define references
for the various options and then update them in the argument-descriptor
functions. For example:
val aFlg : bool ref = ref false
val bOpt : string option ref = ref NONE
val cVal : int option ref = ref NONE
val errorFlg : bool ref = ref false
val opts = [
{ short = "aA", long = [],
desc = NoArg(fn () => aFlg := true),
help = "Set A flag"
},
{ short = "b", long = ["set-b"],
desc = ReqArg(fn s => bOpt := SOME s, "<name>"),
help = "Set B name"
},
{ short = "", long = ["cval"],
desc = OptArg (
fn (SOME s) => (case Int.fromString s
of NONE => errorFlg := true
| someN => cVal := someN)
| NONE => cVal := SOME 0,
"<n>"),
help = "Set C value (default 0)"
}
]
val doOpts = getOpt {
argOrder = Permute,
options = opts,
errFn = fn msg => raise Fail msg
}
With this version, applying the doOpts
function with the following arguments
doOpts ["-A", "foo", "--", "-c", "baz"];
results in
([()], ["foo", "--", "-c", "baz"])
with the aFlg
set to true
and the other flags unchanged. One reason
for using this imperative approach is that it is supported by the
Controls Library.
Bugs
The function arguments to ReqArg
and OptArg
should really have
an option return type so that the case where the argument is badly formed
can be identified in the GetOpt
implementation.


Try hovering the button, it will toggle background yellow. When your mouse is active on element, it toggles red background color.
Hover over this button to add shadow5 class.
shadow5


Everything you need to build an amazing dealership website.
There are many variations of passages of Lorem Ipsum typesetting industry has been the industry's standard dummy text ever since the been when an unknown printer.
Our Project
Our Services
There are many variations of passages of Lorem Ipsum typesetting industry has been the industry's standard dummy text ever since the been when an unknown printer.
Industrial Construction
Lorem ipsum dolor sit adipiscing elit sed diam nonummy nibh euismod
Read MoreWhat Clients Says
There are many variations of passages of Lorem Ipsum typesetting industry has been the industry's standard dummy text ever since the been when an unknown printer.
“ Don’t buy this theme, you won’t be able to resist its charm. Right, like you’re charmed. A theme that is truly multipurpose and flexible ”.
David Matin
Student“ Don’t buy this theme, you won’t be able to resist its charm. Right, like you’re charmed. A theme that is truly multipurpose and flexible ”.
David Matin
Student“ Don’t buy this theme, you won’t be able to resist its charm. Right, like you’re charmed. A theme that is truly multipurpose and flexible ”.


The CSS layout rules for the page stop at the GLAM element. For all descendants of the GLAM element, the CSS properties specify 3D scene graph units, not page units. With the exception of 3D transforms, standard CSS layout properties do not apply.
GLAM uses CSS 3D transforms to place objects in the 3D scene by setting the transform property, such as in the following example:
#photocube {
image:url(../../images/flowers.jpg);
transform:rotateX(30deg);
}
Elements inherit the 3D transforms of the their ancestors.
GLAM uses CSS Animations and CSS Transitions to dynamically animate or transition property values.
The following CSS fragment defines a keyframe animation to rotate the cube cube1 about its y-axis over a 10-second duration with looping:
/* keyframe animation for the cube: 10-second looping rotation about y-axis */
@keyframes kfRotateY {
from {
transform: rotateY(0deg);
}
to {
transform: rotateY(360deg);
}
}
#cube1 {
animation-duration: 10s;
animation-name: kfRotateY;
animation-iteration-count: infinite;
animation-timing-function:linear;
}
GLAM defines several new CSS properties for controlling the material of a visual element: 'ambient-color', 'diffuse-color', 'emissive-color', 'specular-color', 'reflectivity', 'image', 'normal-image', 'specular-image', 'cube-image-back', 'cube-image-bottom', 'cube-image-front', 'cube-image-left', 'cube-image-right', 'cube-image-top', 'sphere-image', 'shader', 'fragment-shader', 'vertex-shader', 'shader-uniforms', and 'render-mode'.
| Value: | <color> |
| Initial: | white |
| Applies to: | visual elements |
Specifies the ambient color for materials of visual elements.
| Value: | <color> |
| Initial: | white |
| Applies to: | visual elements |
Specifies the diffuse color for materials of visual elements. This property is a synonym for the standard CSS property 'color'.
| Value: | <color> |
| Initial: | white |
| Applies to: | visual elements |
Specifies the emissive color for materials of visual elements.
| Value: | <color> |
| Initial: | white |
| Applies to: | visual elements |
Specifies the specular color for materials of visual elements.
| Value: | <number> |
| Initial: | |
| Applies to: | visual elements |
Specifies the reflectivity for materials of visual elements. Applies to materials with specular reflection only.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to the texture map image for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a normal map image for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a specular map image for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the right image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the left image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the top image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the bottom image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the front image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a the back image of a cubic environment map for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to a spherical environment map image for materials of visual elements.
| Value: | phong | blinn | unlit |
| Initial: | unlit |
| Applies to: | visual elements |
Specifies the fixed-function shader to apply to materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to the GLSL fragment shader program for materials of visual elements.
| Value: | <URI> |
| Initial: | |
| Applies to: | visual elements |
Specifies the URI to the GLSL vertex shader program for materials of visual elements.
| Value: | <string> |
| Initial: | |
| Applies to: | visual elements |
Specifies the uniform input declarations for the GLSL fragment shader program for materials of visual elements.
| Value: | <URI> |
| Initial: | standard |
| Applies to: | visual elements |
An enumerated value defining the style of rendering. Valid values are "wireframe" and "standard" (the default).
The visual properties 'dash-size', 'gap-size', 'line-width', and 'point-size' specify values for various visual elements such the width of lines and size of points.
| Value: | <number> |
| Initial: | 0 |
| Applies to: | visual elements |
This property specifies the dash size for dashed lines (<lines> element only). A value of 0 means no dash.
| Value: | <number> |
| Initial: | 0 |
| Applies to: | visual elements |
This property specifies the gap size for dashed lines (<lines> element only). A value of 0 means no gap.
| Value: | <number> |
| Initial: | auto |
| Applies to: | visual elements |
This property specifies the width (thickness) of lines (<lines> element only). The default is implementation-specific.
| Value: | <number> |
| Initial: | 0 |
| Applies to: | visual elements |
This property specifies the point size for points (<points> element only). A value of 0 means use a default size.
Properties to add to CSS for 3D text, including 'bevel-size', 'bevel-thickness', 'font-bevel', and 'font-depth'.
| Value: | <number> |
| Initial: | auto |
| Applies to: | text elements |
This property specifies the bevel size for beveled 3D text.
| Value: | <number> |
| Initial: | auto |
| Applies to: | text elements |
This property specifies the bevel thickness for beveled 3D text.
| Value: | bevel | none |
| Initial: | bevel |
| Applies to: | text elements |
Specifies whether to bevel 3D text.
| Value: | <number> |
| Initial: | 0 |
| Applies to: | text elements |
Specifies the depth to extrude 3D text along the model space z axis. A value of 0 means the text is not extruded but rendered as flat polygons.


Kuwait's Government Resigns
Kuwait's prime minister has submitted his cabinet's resignation to the Emir, a government spokesman said on Thursday.
Prime Minister Sheikh Jaber Mubarak Al-Sabah "submitted the resignation of the cabinet to the emir... in order to allow for a cabinet reshuffle," government spokesman Tareq al-Mazrem said in a statement.
Minister of Finance Nayef al-Hajraf and Minister of Public Works Jenan Bushehri resigned this month.
The resignation came after Kuwaiti lawmakers on Tuesday submitted a motion for a no-confidence vote against Interior Minister Sheikh Khalid al-Jarrah Al-Sabah.


Creating an Array
Using the JavaScript Keyword new
Access the Elements of an Array
Access the Full Array
Arrays are Objects
Array Elements Can Be Objects
Array Properties and Methods
The length Property
Looping Array Elements
Adding Array Elements
How to Recognize an Array
Solution 1:
Solution 2:
Solution 3:


We specialize in group planning in the digital age
About PlanIt
Group chats just don't work for making plans anymore and we expect better. That's why we created PlanIt so that your group of friends can easily choose a fun activity for the weekend and keep all the details in one place.
The Team
The people who made PlanIt possible
Diana
15 // Hoboken, NJ
Amanda
16 // Jericho, NY
Prerna
16 // Manhattan, NY
Amina
16 // Brooklyn, NY
What our users say
"I can't wait for all my friends to join!" John Doe
"One word... WOW!!" Jane Smith
"Making plans is a breeze and I never forget the details!" Joe Bling


CSS Concepts
23 September 2015
This week during DevBootcamp's Phase 0 we were introduced to CSS. I am writing this post to explain the differences between the CSS's display feature as it can be confusing.
The three that I am going to elaborate is Inline, Block, and Inline-block.
General rules for Inline elements:
- Can not have a height or width set.
- Allows other elements to sit to left and right.
- Respects left and right margins, but not top and bottom.
General rules for Inline-Block elements:
- Allows other elements to sit to left and right.
- Repects top and bottom margins and padding.
- Repects height and width.
General rules for Block elements:
- Repects all margins.
- Forces a line break after the block element.
Here is a good image showing the differences between the three:


--- layout: post title: dConstruct 2005 date: 2005-12-23 00:00:00 categories: business mobile personal software-development ---
There's an MP3 of my talk at the dConstruct Web 2.0 event online, available here. Download it and experience me from the comfort of your living room or workplace.


|
My family uses many odd, specific turns of phrase that are more or less inscrutable, including “dublavaytay” and “ on mange toujour ici.” But perhaps my favorite is “ceramic sheep.”
For many years, my parents maintained a farm full of chickens, ducks, sheep, goats, and all sorts. My mother loved them all, but especially the sheep, primarily because she loved working her sheepdogs, Shadow and Sky. One Christmas, my mother found my father the perfect gift: a family of ceramic sheep figurines to sit on the mantle in the living room. They matched the aesthetic of the house (my mother’s aesthetic) perfectly.
On Christmas morning, she watched my father unwrap his gift with great anticipation. As he tore the paper away, his smile settled into a polite, mildly confused grimace. “Oh!” he said, an octave higher than his typical register. “Ceramic sheep!”
“Aren’t they darling?” my mother gushed. “I think they’ll look so good on the mantlepiece.”
“They’re lovely!” my father said, his voice rising ever higher. He paused, turning them over in his hands. “It’s just … why did you get them … for me?”
The air went still. “What do you mean? I thought they were so cute.”
“Well exactly. I think you got them because you wanted them, but you didn’t want to buy them for yourself, so you justified getting them by making it a gift for me.”
My mother thought for a moment, then burst out laughing. “Oh no! You’re exactly right!”
Ever since then, we have used “ceramic sheep” to refer to any gift you give to a loved one not because they’ll like it, but because you want to borrow/use/enjoy it for yourself. This can be used in a gut-check context, e.g. “I want to get Simone these earrings that I love, but I can’t tell if this is just a ceramic sheep.” Or in a warning context, e.g.  Save it for yourself.” Occasionally it is used as a disclaimer, e.g. “I think you’ll like this but it’s also a bit of a ceramic sheep so I hope you’ll let me borrow it.” Perhaps it says something about the myopia of my family that we need a word for this hyper-specific dynamic, but it’s been endlessly useful over the years. And the family of ceramic sheep still sit on the mantle, watching over our every flawed but earnest gift exchange.
Your families have equally perplexing internal phraseology, and I love them all. I present to you: the Good Question family dictionary.
- Bamficillent, adj. good at teleporting. “From BAMF! the ‘sound’ Nightcrawler from the X-Men makes when he teleports in the comics. It’s just a cute word my old friend invented, and we have it spelled in magnetic letters on the fridge and hopefully always will.” e.g. You got here so fast! You must be bamficillent.
- Don’t change your camel on the way to the opera, proverb. stick with your plan. “My family plays lots of gin rummy & Yahtzee on vacations and slow days. In both games, sticking to your plan is often the winning strategy! Somehow, we’ve started saying ‘don’t change your camel on the way to the opera’ to remind each other of this strategy.” e.g. I was trying to decide if I should stop collecting kings and go for a diamond flush instead, but then I remembered: don’t change your camel on the way to the opera.
- Garburate, v. to finish leftovers before they go bad. “A garburator is the Canadian term for garbage disposal, though ironically (and I mean it in the way fellow Canadian Alanis would use it) garburators are illegal in most Canadian provinces.” e.g. I didn’t feel like cooking so I garburated last week’s lasagna.
- Get mashed, v. to drink potato vodka. e.g. “Come on over, let’s get mashed!”
- Mildew, n. a nondescript activity, often accompanied by dull weather outside. “True to the blah term, to have done or to be about to do ‘mildew’ is to have done or be about to do nothing much. The term originated on my mom’s side of the family.” e.g. What did you do this weekend? Oh nothing much, just mildew.
- Sherpa duty, n. the responsibilities of the person who takes the groceries from the car to the kitchen or from the kitchen to the basement. “Perhaps a little culturally insensitive; picked up when my mom taught middle school geography which included Mount Everest.” e.g. I just did a big shopping trip so I need someone on sherpa duty.
- Skerp, v. to chew on something that’s not edible, like tape or wood. “A decade ago, my wife got knockoff Sharpies that were named ‘Skerples.’ We liked to imagine that our cat, Bonus Cat, had an unscrupulous corporation named Smidgeo, that would sell shady products and services like Skerples.  Quit skerping.
- Soldier, n. a bottle of decent-but-not-the-best weekday wine. “My mom doesn’t drink a large quantity of wine at any given time, but she likes savoring a little bit of wine at a time. Still, these ‘soldiers’ were a part of my childhood as well as the jokes that went with them.” e.g. Quite a few soldiers in the recycling today! Rough week, mom?
- Squirting tarbor, n. any non-edible spreadable mixture or paste. “A phrase invented by my mom’s mom.” e.g. Is that cream cheese on the table? No, it’s just a bit of squirting tarbor left over from spackling the wall.
- Womp-womp, n. a groundhog. “I don’t have one with my family... but in college, we called groundhogs ‘womp-womps’. Totally inexplicable! And it wasn’t just my friend group: this was a well-known phrase across the entire school. Many people didn’t know that the animal had another name.” e.g. Did the womp-womp see his shadow? Yep, six more weeks of winter.
- Yellow door, n. something you think is super obvious but no one else sees it. “So my dad and I are driving down Ward Parkway going north and just passed Meyer’s Circle (Kansas City here). My dad exclaims (only appropriate word) ‘isn’t that yellow door really noticeable!!!?!?’ while pointing to a house with a bright yellow door. Me: ‘what yellow door?!’ completely befuddled.” e.g. I couldn’t stop staring at the spinach in his teeth, but no one else seemed to notice. I guess it was a yellow door.
For next time, I’d love to know: How do you conceptualize time? The replies to this tweet totally blew my mind and I want to know how you visualize your days, weeks, months, seasons, and years when you think about past or upcoming events.
|


- validate(int, int, Double, int) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Test all item's value whether the package is valid based on constraints.
- validate(int, int, Double, int) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-
- validateMaxCostConstraint(Double) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Validate if the package don't exceed the dvalid package based on constraint.
- validateMaxCostConstraint(Double) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-
- validateMaxItemAmountConstraint(int) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Validate if the package has a valid weight to be created accordingly with the
constraint defined.
- validateMaxItemAmountConstraint(int) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-
- validateMaxItemWeightConstraint(int) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Validate if the package has a item weight limit expected.
- validateMaxItemWeightConstraint(int) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-
- validatePackageWeightLimit(int) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Validate if the package has a package weight limit expected.
- validatePackageWeightLimit(int) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-
- valueOf(String) - Static method in enum com.mobiquityinc.util.DelimeterConstants
-
Returns the enum constant of this type with the specified name.
- values() - Static method in enum com.mobiquityinc.util.DelimeterConstants
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- verifyFileExists(String) - Method in interface com.mobiquityinc.validator.PackageFileValidator
-
Tests whether the file pathname exists.
- verifyFileExists(String) - Method in class com.mobiquityinc.validator.PackageFileValidatorImpl
-


US cows swim miles to safety after storm sweeps them into the sea
NEW YORK, Nov 15 — Three cows swept into the ocean when Hurricane Dorian struck the US east coast in September were found living on a string of sandy islands miles away from their home, US media reported yesterday.
The bovine trio is believed to have swum six to 10 kilometres before placing hoof on land — in this case an island of sand dunes and scattered vegetation that is part of North Carolina’s Outer Banks, the Charlotte Observer newspaper reported.
The animals were recently discovered by park rangers at the Cape Lookout National Seashore, a long chain of undeveloped barrier islands off the North Carolina coast.
Three months had gone by since the animals, belonging to a free-range herd living on private land on Cedar Island, went missing during the storm.
Category One Hurricane Dorian created a “mini-tsunami” that swept cattle and some 30 wild horses from Cedar Island into the ocean when it struck on September 6.
The cows were identified by their keeper, Woody Hancock. They will likely be sedated and sent home on a boat, a Park spokeswoman told the Observer. — AFP


W3 Accessibility Guidelines General Information
Audio-only and Video-only Time Based Media
For prerecorded audio-only and prerecorded video-only media, the following are true, except when the audio or video is a media alternative for text and is clearly labeled
The intent of this Success Criterion is to make information conveyed by prerecorded audio-only and prerecorded video-only content available to all users. Alternatives for time-based media that are text based make information accessible because text can be rendered through any sensory modality (for example, visual, auditory or tactile) to match the needs of the user. In the future, text could also be translated into symbols, sign language or simpler forms of the language (future). An example of pre-recorded video with no audio information or user interaction is a silent movie. The purpose of the transcript is to provide an equivalent to what is presented visually. For prerecorded video content, authors have the option to provide an audio track. The purpose of the audio alternative is to be an equivalent to the video. This makes it possible for users with and without vision impairment to review content simultaneously. The approach can also make it easier for those with cognitive, language and learning disabilities to understand the content because it would provide parallel presentation.


{% include header.html %} {% include nav.html %}
Click on the links below to view the posters that were showcased at the 2:AM conference in Amsterdam:


ALADDIN A film review by Eric Walker Copyright 1992 Eric Walker
After BEAUTY AND THE BEAST was became the first animated feature film to be nominated for the Best Picture Oscar last year (Disney's hypesters have done everything possible to make the public remember this), the Disney Studios have once again proven that when it comes to making audience-pleasing animated films, they are second to none. These days, the only standards they can top are their own. But how do you top a film that everyone has gone out of their way to rain praise upon, calling it the best animated feature since the days of BAMBI and PINOCCHIO?
Once again, the Disney folks have made the right choice: you don't. Instead of going for heart-warming romance this time, they've toned down the myth-making and have instead aimed for a much more down-to-earth target, namely laughter. We now have ALADDIN, the latest addition to the ever-growing list of successful Disney animated films - and Disney money-makers. But this time it's not going to be romance or realistic characters or even the always-impressive animation that will win over the audiences. The success of ALADDIN is going to be summarized in two words: Robin Williams.
Williams runs away with the entire movie, lock, stock, and barrel. He plays the voice of the Genie, a non-stop cloud of blue energy who saves the day, helps Aladdin get the girl, lets the Disney animators get away with more sight gags and throwaway bits since THE NAKED GUN, and keeps the audience rolling in the aisles. There are other good characters in this movie, such as a wisecracking parrot (played by another comedian, Gilbert Gottfreid), a flying carpet, and a little monkey sidekick, but this movie belongs to Williams.
The Disney animators deserve an award for being able to keep up with Williams' 90 m.p.h. dialogue, with impressions, puns, and yuks galore. The Genie puts the pedal to the metal (like Williams himself - he even *looks* like Williams), shape-changing into an infinite variety of forms to keep up with the jokes. Look fast and you'll see references to the Marx Brothers, Delta Airlines, Ed Sullivan, THE LITTLE MERMAID, PINOCCHIO, Walt Disney World ... in fact, the Genie's routines are so packed with Disney in-jokes that if they weren't so funny, one would think Disney was shamelessly plugging its theme parks. I suppose a cynic would say that this is exactly what's going on, but I don't think so. Williams is obviously having a ball here, biting the hand that feeds him and satirizing the famous Disney merchandising machine with his constant references to 20th Century icons.
However, these in-jokes and allusions to the modern era do have one other effect on the movie that is noticeably missing from other Disney animated films: they date it. It's been pointed out that the Disney films can credit their everlasting popularity to their timelessness. The problem with contemporary films is that in twenty or thirty years time they can look terribly dated, and no one will want to watch them anymore.  ALADDIN obviously doesn't worry as much about being an "immortal Disney classic," going instead for the immediate laughs.
Perhaps this is the influence of Jeff Katzenberg, the Disney head honcho (second only to Michael Eisner) who has been re-shaping the animation studio in his own image. Like most of the Hollywood moguls today, Katzenberg seems concerned with what sells *now* and what can make the quickest profits; he doesn't think about the future. Since ALADDIN will be released on video for the 1993 Christmas season - you can count on it - we may not be seeing a theatrical re-release of this film the way we've seen revivals of 101 DALMATIANS, PETER PAN, LADY AND THE TRAMP, and the other Disney classics (all of which have now also been released on video); but in the long run, Katzenberg may regret his decision to make ALADDIN a "1990s" film. Still, this is a topic to be discussed at a future date. What matters right now is that ALADDIN is a very funny film.
However it does have its flaws: primarily the fact that it is nothing *besides* a funny film. The hero and heroine, Aladdin and Princess Jasmine, are carbon copies of Prince Eric from THE LITTLE MERMAID and Belle from BEAUTY AND THE BEAST (during one musical number Jasmine sounds exactly like Belle - or Ariel); and the villain, Jafar, comes a long list of Stereotypical Disney Villains: he's evil, threatening, clever, and he's got a talking animal sidekick as well. The story is, of course, predictable - in fact, it's almost a carbon copy of the classic Max Fleischer cartoon, "Popeye Meets Aladdin and his Wonderful Lamp." Aladdin is a fun-loving, clever thief and Jasmine is another 1990s-era heroine who Thinks For Herself (until Aladdin comes to her rescue), while Jafar puts in a passable, entertaining performance.
But aside from the Genie, it's the sidekicks who get all the attention and all of the laughs. Jafar's loyal stooge, a loudmouthed talking parrot, steals every scene he's in - he's almost as effective as the Genie in his own way. He's loud, annoying, and rude; so of course we love watching him get dumped on again and again. Likewise, there's Abu, Aladdin's loyal pet monkey, who makes fun of Aladdin's crush on the Princess and who has big eyes that show his emotions - and elecits even more laughs from the audience.
And there's a magic carpet as well, with no voice - but whose personality shines through nonetheless. The carpet is a triumph of animation, as it expresses its feelings better than Aladdin himself does. Its intricate detail comes once again from computer animation.
And once again, computer animation is used in a Disney film to augment the hand-drawn method and make it even more impressive. More emphasis on hand-painted backgrounds is used this time, and in the beginning of the film during the scenes in the (unnamed) desert city, the animation does not seem quite up to Disney standards - it's good, but it's "ordinary." (Perhaps I'm spoiled by computer animation.) Once we enter the Sultan's Palace, however, the film becomes a feast for the eyes to behold. There's a Cave of Wonders that is truly wonderful, with treasures galore and awe-inspiring animation to boot. One scene being pushed in the television commercials shows Aladdin on the flying carpet, moving through a series of caves that reminds one of a video game; seeing this sequence on the big screen is exciting and delightful. Computer animation is seamlessly blended with the hand drawings this time; it's the best combination of the two styles of animation since THE RESCUERS DOWN UNDER.
There are several songs in the movie as well, though none of them are very memorable. Ever since the success of THE LITTLE MERMAID, Disney has been milking the success of its song-writing crew (even using Howard Ashman-Alan Menken songs in their live-action musical NEWSIES earlier this year) and using the same song-writing team over and over. While the songs of MERMAID were a delight, I didn't think the music of BEAUTY AND THE BEAST was quite as good - and here, it's simply generic. Music and comedy don't mix very well; one is reminded of the films of the Marx Brothers, when each movie would come to a standstill while one song-and-dance number was performed, and the audience would patiently wait for the song to end so that they could continue laughing. It's the same way here; the best song of the movie is "You've Never Had A Friend Like Me," sung by the Genie as he dazzles us (and makes us laugh) with a phantasmagoria of shapes, sizes, impressions and gags galore. The song's entertainment comes not from the music (which is by Alan Menken and Tim Rice, Andrew Lloyd Weber's co-conspirator), but from Robin Williams.
However, no one is going to complain about the weak main characters, or any flaws in the animation, or the musical numbers. ALADDIN aims to do one thing only - to make you laugh - and it succeeds admirably. After a year where the biggest movies have been either disappointments (BATMAN RETURNS, BRAM STOKER'S DRACULA) or deep, serious "epics" (UNFORGIVEN, MALCOLM X), here's a movie that's just a lot of fun.
Forget HOME ALONE 2, and go see ALADDIN!
-- Channel 1 (R) Cambridge, MA
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


CHAPTER 478
INTEREST AND USURY
Section
478-1 Definitions
478-2 Legal rate; computation
478-3 On judgment
478-4 Rate by written contract
478-5 Usury not recoverable
478-6 Usury; penalty
478-7 Compound, not recoverable
478-8 Exemptions from usury
478-8.5 Repealed
478-9 Rejection of federal law
478-10, 11 Repealed
478-11.5 Credit cards
478-12 Renumbered
478-13 Repealed


Notebooks
Story: The ||gaun-a. The Ghost
The ||gaun-a. The Ghost
Title
The ||gaun-a. The Ghost
Collection
Summary
|uma tells of his experiences with a ghost (or ||gaun-a).
Comments
1) p.10 260v: |uma from personal observation; a note by Tamme (not translated) – continued on next verso page, 2) This story is found in Book XIII & XIV-1
Contributors
Date
24 October 1881
Categories
Keywords
ghost (the ||gaun-a) , ghost (the slaying or killing of) , ghost (its bow) , ghost (its blood) , ghost (and |uma) , ghost (killed with assegai) , ghost (the 'slayer' burnt its bow) , ghost (name of) , weapons (the ghost's bow) , |uma (his experience of ghosts) , personal history (|uma and the ghost) , personal history (|uma's) , bow (of the ghost or ||gaun-a) , death (the killing of the ||gaun-a or ghost) , name (used by the !kun for the ghost is ||gaun-a)
Story Pages
10 261-10 263


Digital Painting
;
Home
(current)
Pages
About Us
Events
Gallery
Colourful
Collection
Market Place
Wooden Arts
Bags
Paintings
Contact
Sign IN
1
Sign In Here
×
Email
We'll never share your email with anyone else.
Password
Check me out
Submit
Checkout
Shipping Address
Add a Shipping address
Shipping Address
×
Address
Address 2
City
State
Maharashtra
Karnataka
Tamil Nadu
Andhra Pradesh
Uttra Pradesh
Telangana
Punjab
Jammu & Kashmir
Delhi
Kerla
Goa
Rajashthan
Gujarat
Banglore
Kolkata
Manipal
Madhya Pradesh
...
Zip
Payment Method
Add a credit card
Add a payment method
×
I agree terms and conditions
Cancel
Submit
Proceed to Order to Review
Your Order
Product
Total
Amlan Dutta
INR 40,000
Cart Subtotal
INR 40,000
Order Total
INR 40,000