You've come to the right place if you want to start building F2 apps. Before continuing, make sure you've cloned the F2 repository on GitHub or downloaded the latest framework build (v1.1.1). Secondly, read about the F2 Framework. There are a few important concepts to help you better understand apps, containers and context.
F2 apps are synonymous with modules, widgets and portlets. Think charts, portfolios, trade tickets, and screeners. F2 apps only need to be programmed once, no matter where they will be used. To start, F2 Apps are either:
For the purposes of the documentation on this page, we'll focus on developing display apps. Browse to The Basics: Framework for more background information about F2 apps.
Interested in developing F2 containers? Browse to Container Development.
To help you get started building an F2 app, browse through the resources below. To jump start your F2 app development, download the F2 app template (which now includes a basic container) or follow the instructions below.
Download Basic F2 App Template
To begin, you do not need to build F2 as described in the readme on GitHub. Simply download Bootstrap and save a local copy of F2.js. Also ensure you're properly configured.
Download F2.js Download Bootstrap
Create your basic container HTML template:
<!DOCTYPE html>

<title>F2 Container</title>
<link rel="stylesheet" href="/path/to/your/bootstrap.css">

Hello F2

In developing a more advanced container, the HTML document's body
element would contain additional markup and allow for specific positioning or placement of apps. Additionally, more advanced containers could introduce features and functionality to their apps in the form of authentication APIs, streaming data feeds, federated search, etc. All containers must follow the F2 design guidelines.
Create your basic F2 app manifest and save it as /path/to/your/manifest.js
using this code below. Note the path to this file should be specified in the manifestUrl
property within the _appConfigs
array in your basic container (shown above).
F2_jsonpCallback_com_your_app_id({
"scripts": [],
"styles": [],
"apps": [{
"data": {},
"html": "

Hello, world. I'm an F2 app.

"
}]
})
Note You can download the F2 app template instead of creating the basic app by hand.
Now with a basic container and a basic app, you can load your F2 container and expect to see:
In getting to this point, you've only scratched the surface of F2 containers and apps. Continue reading and understanding the F2 spec to build exactly the financial solutions that our customers want.
Good news! In the project repo on GitHub, you will find a basic container along with a number of sample apps which demonstrate functionality far beyond the basic app above. Once you clone or download the project repository, open the sample container by pointing your browser at:
http://localhost/F2/examples/container/
It is assumed you will be developing F2 apps locally and have a localhost
setup. The URLs mentioned in this specification also assume you have configured your F2 apps to run at http://localhost/F2/
. The examples provided as part of the project repository demonstrate apps written in different languages (PHP, JavaScript, C#). While it is not a requirement you have a web server configured on your computer, it will certainly allow you to more deeply explore the sample apps.
To better understand F2 and the role of apps, you need to understand the role of the container. If you haven’t already, read more about containers in the Framework.
To get started working with or developing containers, browse to the documentation for developing the container.
Ready to start coding?
Developing F2 Apps F2.js SDK Reference
Design considerations are an important first step when creating a new app. Content can range from news to research to multimedia, and content should be presented using Progressive Enhancement, Mobile First and Responsive Design methodologies. That is to say multimedia content, for example, should be shown plugin-free (using HTML5 video or audio elements) for capable browsers and fallback to Flash-based players for browsers that do not yet support HTML5 related technologies. (VideoJS is good example of open-source JavaScript and CSS "that makes it easier to work with and build on HTML5 video, today.")
If App Developers embed URLs back to their own websites or to third party sites, URLs must be opened in a new window as to not interrupt the experience of someone using the container. If authentication is required on an App Developer's site, this can be accomplished with pass-through authentication using encrypted URLs as discussed in Single Sign On.
In order to ensure that apps built using F2 are successful, they must be accessible. As such, F2 made choices for which open-source libraries and frameworks would be leveraged to reduce the level of effort across F2 adopters.
Read more about those choices in the Framework.
Ultimately, the responsibility of app design falls on either the Container or App Developer. In many cases, Container Developers will provide App Developers will visual designs, style guides or other assets required to ensure apps have the form and function for a given container. Container Developers may also provide CSS for App Developers to adhere to—which should be easy since F2 enforces a consistent HTML structure across all containers and apps.
Let's take a close look at how to build an F2 app. We'll explain how to get an F2 AppID, what the AppManifest
is all about, what output format your app needs to support, how the contents of the AppContent.html
property work, and the two hooks for adding form and function to your app: scripts
and styles
.
Before opening your editor, read the configuration assumptions.
To develop an F2 app, you need a unique identifier called an AppID. This AppID will be unique to your app across the entire open financial framework ecosystem. The format of the AppID looks like this: com_companyName_appName
, where the companyName
"namespace" is your company name and appName
is the name of your app.
As an example, your AppID could look like this:
com_acmecorp_watchlist
If you built more than one app while working at Acme Corporation, you could create more AppIDs. All of these are valid:
com_acmecorp_watchlist2
com_acmecorp_watchlist_big_and_tall
com_acmecorp_static_charts
com_acmecorp_interactive_charts
To guarantee uniqueness, we have provided an AppID generation service that allows you to customize your AppID.
Once you have your AppID, start by setting up your project. You will need at least one file: the App Manifest. Create a new file called manifest.js
. Also, chances are you'll want custom styling and functionality, so go ahead and create appclass.js
(for your app logic) and app.css
for your CSS. Your project folder should look like this:
Helper Download the F2 app starter zip or read about setting up a basic container and app in Getting Started.
For an app to be considered F2-capable, it must first have this basic structure—called the App Manifest—represented in JSON:
{
"inlineScripts":[],
"scripts":[],
"styles":[],
"apps":[{
"data":{},
"html":"",
"status":""
}]
}
The App Manifest can be generated by the server-side code of your choice or be written-by-hand in your favorite text editor. In the GitHub repository, there are apps written in JavaScript, PHP, and C# to serve as examples to get you started.
When it's complete (using the examples further below), the App Manifest looks like this:
F2_jsonpCallback_com_companyname_appname({
"inlineScripts":["(function(){ var foo = bar; doSomething(); })()"],
"scripts":[
"http://www.domain.com/js/appclass.js"
],
"styles":[
"http://www.domain.com/css/app.css"
],
"apps":[{
"data":{
foo: "bar",
value: 12345
},
"html":"
Hello world.
",
"status":"good"
}]
})
Let's break the App Manifest object down and look at each property (in reverse order to keep it fun).
The apps
property is an array of AppContent
objects. Each AppContent
object contains three properties:
html
data
status
The html
property contains the view of your app represented in (optionally encoded) HTML. While you can modify the way your app appears or functions within the container, the html
property is what the container will show when it registers your app and displays its contents for the first time.
Example:
"html": "
Hello world.
"
The optionally encoded version of the html
example above is:
"html": "%3Cdiv%20class%3D%22sunrise%22%3EHello%20world.%3C%2Fdiv%3E"
The data
property exists to support the placement of arbitrary data needing to be passed along with the app. This field is optional.
Example:
"data": {
foo: "bar",
value: 12345
}
The status
property allows app developers to communicate a server-side arbitrary status code to itself or to the container. This field is optional.
Example:
"status": "good"
The styles
property is an array of URLs. The styles
array refers to any CSS files needed by the app so it will be displayed properly on the container. The externally-referenced CSS files should be fully-qualified, including a protocol.
Example:
"styles": [
"http://www.domain.com/css/app.css"
]
In the case when multiple stylesheetes are needed, simply add to the array as shown in this example:
"styles": [
"http://www.domain.com/css/app.css",
"http://www.domain.com/css/app-responsive.css"
]
Read more about CSS and namespacing inside your app.
Note URLs referenced in the Scripts and Styles arrays are loaded synchronously by F2.js, so be sure to order your scripts properly.
The scripts
property is an array of URLs. The scripts
array refers to any JavaScript files needed by the app so that it will function correctly on the container. The externally-referenced JS files should be fully-qualified.
Example:
"scripts": [
"http://www.domain.com/js/appclass.js"
]
In the case when multiple scripts are needed, simply add to the array as shown in this example:
"scripts": [
"http://www.domain.com/js/lib.js",
"http://www.domain.com/js/appclass.js"
]
Read more about JavaScript and namespacing inside your app.
Note URLs referenced in the Scripts and Styles arrays are loaded synchronously by F2.js, so be sure to order your scripts properly.
The inlineScripts
property is an array of strings. The inlineScripts
array can include any JavaScript code needed by the app that cannot be included in your App Class. The contents of the inlineScripts
array will be evaluated as JavaScript (using eval()
) when all scripts
have finished loading.
Example:
"inlineScripts": [
"(function(){ var foo = bar; doSomething(); })()"
]
While the use of inlineScripts
is supported by F2's App Manifest, it is not recommended for use. There are many reasons for this, the main one is to avoid cluttering the global namespace. Developers should make every attempt to put their JavaScript code inside their App Class.
Read more about JavaScript and namespacing inside your app.
Note URLs referenced in the Scripts and Styles arrays are loaded synchronously by F2.js, so be sure to order your scripts properly.
If we use the examples above, our AppManifest
would look like this:
F2_jsonpCallback_com_companyname_appname({
"inlineScripts":["(function(){ var foo = bar; doSomething(); })()"],
"scripts":[
"http://www.domain.com/js/appclass.js"
],
"styles":[
"http://www.domain.com/css/app.css"
],
"apps":[{
"data":{
foo: "bar",
value: 12345
},
"html":"
Hello world.
",
"status":"good"
}]
})
Note You may have noticed the presence of the function name F2_jsonpCallback_com_companyname_appname
on the first line of the example above. That function name is the callback and is explained in App Manifest Response.
OK, so you know about F2 apps and you're ready to write your own App Manifest. To go from zero to something, download the F2 app starter zip. Once you have your AppManifest
defined (or at least stubbed out), there's one important detail you need to know now—the App Manifest response format.
As part of F2, containers register apps—typically hosted on different domains—using JSONP. This means F2 App Manifest files must provide a JSONP callback function. (If you don't know what JSONP is or how it works, we recommend reading what Remy Sharp has to say about it.)
For security reasons, the App Manifest JSONP callback function must be a specific, reliable, and testable format. F2 has defined that using a combination of a string and your unique F2 AppID. The JSONP callback function name looks like this:
F2_jsonpCallback_<AppID>
When applied, the final (bare bones) App Manifest file looks like this example (where com_companyname_appname
is your AppID):
//manifest.js
F2_jsonpCallback_com_companyname_appname({
"scripts":[
"http://www.domain.com/js/appclass.js"
],
"styles":[
"http://www.domain.com/css/app.css"
],
"apps":[{
"html":"
Hello world.
"
}]
})
Note the JSONP callback function name will not be passed from the container using a traditional querystring parameter (HTTP GET), so you must configure this correctly for your app to appear on a container. This means you have to hard-code it in your appmanifest.js
.
Required Don't forget you need an AppID before you can run your app on a container. Get your AppID now »
Every F2 app has HTML. The only catch is that the HTML isn't provided by the app itself but rather passed to the container via the app's AppManifest
. But that's not a problem because F2 has provided examples to show you the way. Here are the steps for getting your app HTML into your AppContent.html
property:
html
property of your AppContent
object within your App Manifest file's App
object.Huh? Check out this example:
Step 1.

Hello world.

Step 2. Encoded HTML. (Optional)
%3Cdiv%20class%3D%22sunrise%22%3EHello%20world.%3C%2Fdiv%3E
Step 3. App Manifest file.
{
...
"apps":[{
"html": "
Hello world.
"
...
}]
}
Note You are not required to encode the app HTML, so follow steps 2 and 3 above omitting the encoding step.
F2 uses and recommends Twitter Bootstrap for Container and App Developers to benefit from a consistent HTML and CSS structure regardless of who developed the F2 component. This way, Container Developers can write CSS they know will style F2 apps without engaging with the app developer to ensure compatability.
This also means App Developers must adhere to Bootstrap's scaffolding guidelines as defined on their website.
An example two-column layout using Bootstrap-specifed markup:

...

...

The .span4
and .span8
provide two columns in the 12-column grid.
Note Read more about Creating a Common Look and Feel with F2.
Once your app is on the container, chances are you'll want it to actually do something. As an app developer, it is entirely up to you to write your own stylesheets and javascript code to add form and function to your app. F2's standardized App Manifest provides hooks for your CSS and scripts to get onto the container—just use the scripts
and styles
arrays detailed above in the App Manifest.
Including your own CSS in the styles
array of the App Manifest opens the door to the potential of unexpected display issues. Therefore, as an app developer, you are required to properly namespace your CSS selectors and declarations. For the details on writing correctly namespaced code, read the namespacing docs.
It is recommended you include your app styles in a file named app.css
.
While it isn't required, it's expected all F2 apps will ship with javascript. This code should be included in an appclass.js
file as shown in Setting Up Your Project. The F2.Apps
property is a namespace for app developers to place the javascript class that is used to initialize their app. The javascript classes should be namepaced with the F2.App.AppID
. It is recommended that the code be placed in a closure to help keep the global namespace clean.
For more information on F2.Apps
, browse over to the F2.js SDK docs.
To make it even easier to build F2 apps and for faster app loading by the container, the F2.js SDK provides automatic JavaScript method execution at appropriate times during F2.registerApps()
(and the internal _loadApps()
method). If the class has an init()
function, it will be called automatically during execution of F2's registerApps()
method.
We recommend—and have samples below for—two different patterns for writing your appclass.js
code: prototypal inheritence or the module pattern.
When F2's registerApps()
method is called by the container, F2 passes three arguments to your App Class: appConfig
, appContent
and root
. The SDK documentation details the contents of each arg and these should be familiar because appConfig contains your apps' meta, appContent contains your html
, data
and status
properties, and root is the outermost DOM element in which your app exists on the container. The root
argument provides your App Class code your apps' parent element for faster DOM traversal.
Example:
//appclass.js snippet
...
var App_Class = function(appConfig, appContent, root) {
...
We won't even begin to talk about or describe this fantastic design pattern simply because Douglas Crockford has already written all about it.
An example of an App Class using prototypal inheritance inside a closure is below. Note the inclusion of the App_Class.prototype.init()
function—which will be called automatically during app load—and the trailing parentheses, ()
, which are responsible for automatic function execution. Thanks to the closure, the App_Class
is returned and assigned to F2.Apps["com_companyname_appname"]
.
F2.Apps["com_companyname_appname"] = (function() {
var App_Class = function(appConfig, appContent, root) {
// constructor
}
App_Class.prototype.init = function() {
// perform init actions
}
return App_Class;
})();
As an alternative to the prototypal inheritance pattern above, appclass.js
code could be written following the module pattern shown in the example below. Note the inclusion of an init()
function—which will be called automatically during app load—and the exclusion of the closure and trailing parentheses present in the example using prototypal inheritance above.
F2.Apps["com_companyname_appname"] = function(appConfig, appContent, root) {
return {
init:function() {
// perform init actions
}
};
};
Of course, you don't have to use either one of these patterns in your appclass.js
file. What you do have to use is a function
. That is to say the value assigned to F2.Apps["com_companyname_appname"]
by your App Class code must be a function. Within F2's registerApps()
method, the new
operator is used which produces an object (check out the code).
In the absence of a function in your appclass.js
, F2 will be unable to load your app on a container.
If you don't want to think about any of this and would rather just start coding, download the F2 app starter zip.
F2 is a web integration framework which means apps are inherently insecure—at least those non-secure apps. Following this spec, App Developers must avoid CSS collisions and JavaScript namespace issues to provide users with the best possible experience.
Note Continue reading for more specifics about secure apps.
As discussed in Developing F2 Apps: F2 AppID, to develop an F2 app, you need a unique identifier called an AppID. This AppID will be unique to your app across the entire open financial framework ecosystem. The format of the AppID looks like this: com_companyName_appName
, where the companyName
"namespace" is your company name and appName
is the name of your app.
When Container Developers register apps, F2.js draws each app as defined by the ContainerConfig. Before the app is added to the container DOM, F2 automatically wraps an outer HTML element—with the AppID used as a class—around the rendered app.
This example shows app HTML after it has been drawn on the container. Note the com_companyName_appName
classname.

...

To avoid styling conflicts or other display issues related to app-provided style sheets, App Developers must namespace their CSS selectors. Fortunately, this is quite easy.
Every selector in app-provided style sheets must look like this:
.com_companyName_appName p {
padding:5px;
}
.com_companyName_appName .alert {
color:red;
}
Note .com_companyName_appName
is prefixed on both p
and .alert
selectors.
While the CSS cascade will assign more points to IDs and prefixing F2 AppIDs on CSS selectors isn't required, it is recommended.
.com_companyName_appName #notice {
background-color:yellow;
}
Adhering to one of the OpenAjax Alliance goals, F2 also promotes the concept of an uncluttered global javascript namespace. For Container and App Developers alike, this means following this spec closely and ensuring javascript code is contained inside closures or is extended as a new namespace on F2
.
To ensure javascript bundled with F2 apps executes in a javascript closure, follow the guidelines for the appclass.js
file and one of the two patterns described (prototypal inheritance or module).
The F2.js SDK was designed with extensibility in mind and therefore custom logic can be added on the F2
namespace.
Example:
F2.extend('YourPluginName', (function(){
return {
doSomething: function(){
F2.log("Something has been done.");
}
};
})());
For more information, read Extending F2.
Apps are capable of sharing "context" with the container and other nearby apps. All apps have context which means the app "knows" who is using it and the content it contains. It is aware of an individual's data entitlements and user information that the container is requested to share (name, email, company, etc).
This means if a user wants to create a ticker-focused container so they can keep a close eye on shares of Proctor & Gamble, the container can send "symbol context" to any listening apps that are smart enough to refresh when ticker symbol PG is entered in the container's search box.
While apps can have context themselves, the responsibility for managing context switching or context passing falls on the container. The container assumes the role of a traffic cop—managing which data goes where. By using JavaScript events, the container can listen for events sent by apps and likewise apps can listen for events sent by the container. To provide a layer of security, this means apps cannot communicate directly with other apps on their own; apps must communicate via an F2 container to other apps since the container controls the F2.Events API.
Let's look at some code.
In this example, the container broadcasts, or emits, a javascript event defined in F2.Events.Constants
. The F2.Events.emit()
method accepts two arguments: the event name and an optional data object.
F2.Events.emit(
F2.Constants.Events.CONTAINER_SYMBOL_CHANGE,
{
symbol: "AAPL",
name: "Apple, Inc."
}
);
To listen to the F2.Constants.Events.CONTAINER_SYMBOL_CHANGE
event inside your F2 app, you can use this code to trigger an alert dialog with the symbol:
F2.Events.on(
F2.Constants.Events.CONTAINER_SYMBOL_CHANGE,
function(data){
F2.log("The symbol was changed to " + data.symbol);
}
);
The F2.Events.on()
method accepts the event name and listener function as arguments. Read the SDK for more information.
Note For a full list of support event types, browse to the SDK for F2.Constants.Events.
Often times containers will want to send context to apps during app registration. This is possible through the AppConfig.context
property. This property can contain any javascript object—a string, a number, an array or an object.
//define app config
var _appConfigs = [
{
appId: "com_acmecorp_news",
description: "Acme Corp News",
manifestUrl: "http://www.acme.com/apps/news-manifest.js",
name: "Acme News App",
context: {
sessionId: myApp.sessionId,
someArray: [value1,value2]
}
}
];
When F2.registerApps()
is called, the appConfig
is serialized and posted to the app's manifest URL. The serialized object converts to stringified JSON:
{"appId":"com_acmecorp_news","description":"Acme Corp News","manifestUrl":"http://www.acme.com/apps/news-manifest.js","name":"Acme News App","context":{"sessionId":"12345", "someArray":["value1","value2"]}}
The appConfig
object is sent to the server using the params
querystring name as shown in the example below. This is the complete app manifest request sent by F2.registerApps()
with the appConfig
URL-encoded, of course:
http://www.acme.com/apps/news-manifest.js?params=%7B%22appId%22%3A%22com_acmecorp_news%22%2C%22description%22%3A%22Acme%20Corp%20News%22%2C%22manifestUrl%22%3A%22http%3A%2F%2Fwww.acme.com%2Fapps%2Fnews-manifest.js%22%2C%22name%22%3A%22Acme%20News%20App%22%2C%22context%22%3A%7B%22sessionId%22%3A%2212345%22%2C%20%22someArray%22%3A%5B%22value1%22%2C%22value2%22%5D%7D%7D
This demonstrates complete flexibility of passing arbitrary context values from the container to any F2 app.
Important To receive context from a container during app initialization, F2 App Developers are required to build object deserialization for the params
value into their app code.
In this example, your app emits an event indicating a user is looking at a different stock ticker within your app. Using F2.Events.emit()
in your code, your app broadcasts the new symbol. As with container-to-app context passing, the F2.Events.emit()
method accepts two arguments: the event name and an optional data object.
F2.Events.emit(
F2.Constants.Events.APP_SYMBOL_CHANGE,
{
symbol: "MSFT",
name: "Microsoft, Inc."
}
);
The container would need to listen to your apps' broadcasted F2.Constants.Events.APP_SYMBOL_CHANGE
event using code like this:
F2.Events.on(
F2.Constants.Events.APP_SYMBOL_CHANGE,
function(data){
F2.log("The symbol was changed to " + data.symbol);
}
);
Note For a full list of support event types, browse to the SDK for F2.Constants.Events.
Apps can also pass context between apps. If there are two or more apps on a container with similar context and the ability to receive messages (yes, through event listeners, context receiving is opt-in), apps can communicate with each other. To communicate with another app, each app will have to know the event name along with the type of data being passed. Let's take a look.
Within "App 1", context is sent using F2.Events.emit()
:
F2.Events.emit(
"buy_stock", //custom event name
{
symbol: "GOOG",
name: "Google Inc",
price: 682.68,
isAvailableToPurchase: true,
orderType: "Market Order"
}
);
Within "App 2", context is received using F2.Events.on()
:
F2.Events.on(
"buy_stock",
function(data){
if (data.isAvailableToPurchase){
F2.log("Trade ticket order for " + data.symbol + " at $" + data.price);
} else {
F2.log("This stock is not available for purchase.")
}
}
);
The examples above demonstrate simple Context objects. In the event more complex data and/or data types are needed, F2 Context can support any JavaScript object—a string, a number, a function, an array or an object.
This is an example Context object demonstrating arbitrary JavaScript objects:
F2.Events.emit(
"example_event", //custom event name
{
//number
price: 100,
//string
name: 'John Smith',
//function
callback: function(){
F2.log('Callback!');
},
//array
watchlist: ['AAPL','MSFT','GE'],
//object
userInfo: {
name: 'John Smith',
title: 'Managing Director',
groups: ['Alpha','Beta'],
sessionId:<PHONE_NUMBER>
}
}
);
If two apps want to communicate data for populating a trade ticket and execute a callback
, appclass.js code might look like this:
F2.Events.emit(
"buy_stock", //custom event name
{
symbol: "GOOG",
name: "Google Inc",
price: 682.68,
isAvailableToPurchase: true,
orderType: "Market Order",
//define callback
callback: function(data){
alert('Trade ticket populated');
}
}
);
The F2 app listening for the buy_stock
event would fire the callback
function.
F2.Events.on(
"buy_stock",
function(data){
F2.log("Trade ticket order for " + data.symbol + " at $" + data.price);
//..populate the trade ticket...
//fire the callback
if (typeof data.callback === 'function'){
data.callback();
}
}
);
Context is a term used to describe the state of an F2 container and its apps. At the same time, Context is also the information passed from Container-to-App or from App-to-App or from App-to-Container. In the examples shown above, two types of context were shown: symbol and trade ticket context. It is important to realize F2.js allows client-side messaging between third parties using a collection of arbitrary name-value pairs. This provides the utmost flexibility and affords Container Developers the option to define context within their container.
Said another way, while { symbol:"AAPL", name: "Apple, Inc" }
can be used to communicate symbol context, developers could also use { symbol: "123456789" }
to identify Apple, Inc. The latter is more likely given not all apps would programmatically understand AAPL
but—given symbol lookup services—would understand 123456789
as the universal F2 identifier for Apple, Inc. It is clear Container and App Developers alike would prefer to communicate with a guaranteed-to-never-change universal ID for all instrument types across all asset classes.
F2 will be providing lookup web services in future releases that provide universal F2 identifiers for container and app providers. These lookup services will not just be limited to symbols. Further details will be forthcoming as the F2 specification evolves.
F2 fully supports secure apps. A secure app is one that exists inside an iframe
on a container and is hosted on a different domain. The F2.js SDK provides developers with seamless handling of Context, UI and the other F2 APIs whether or not an app is secure. This means app developers do not have to code apps any differently if an app is secure.
An app is defined as "secure" in the AppConfig. Creating the AppConfig
is something that is done when apps are registered on the Developer Center.
Noting the isSecure
property, the AppConfig
looks like this:
{
"appId": "com_f2_demo",
"description": "A demo F2 app.",
"height":250,
"minGridSize": 4,
"manifestUrl": "manifest.js",
"name": "F2 App",
"isSecure": true //secure boolean
}
To see examples of secure apps, fork F2 on GitHub and point your browser at:
http://localhost/F2/examples/container/
The example container runs sample apps—defined in sampleApps.js
—and that's where you'll find the isSecure
flag defined in some of the AppConfig
objects.
Good news! The container is responsible for loading its apps, and as long as you've followed F2's standard for App Manifests and have a working—and tested—app, you're pretty much done.
If you're curious about how containers load apps, browse to the F2.js SDK registerApps()
method or read Container Development.
When you cloned the F2 GitHub repo you also got an example F2 container for your app development and testing. Open the project repository and navigate to ~/F2/examples/container
to find them or to jump-start your testing, point your browser at:
http://localhost/F2/examples/container/
If you open ~/F2/examples/container/js/sampleApps.js
in your text editor, you'll find a list of sample F2 apps broken down by programming language. Simply modify this file to your liking and add your app anywhere in the appropriate array (JavaScript, PHP or C#). The configuration is comprised of F2.AppConfig
properties, and the following are the minimum required properties.
{
appId: "com_companyName_appName",
manifestUrl: "http://www.domain.com/manifest.js",
name: "App name"
}
For full details on these F2.AppConfig
properties and all the others, browse the F2.js SDK documentation.
There are some utility methods provided within F2.js in the UI
namespace. These helpers are for controlling layout, showing (or hiding) loading spinners, modals, managing views within your app, and more.
While there are numerous utility methods in F2.UI, we will focus on a couple important ones here such as updateHeight()
and showMask()
. The F2.UI
methods are passed as an instance to each F2 apps' App Class on the appConfig
argument. The instance of F2.UI
gets added to the appConfig
object at runtime, and is available in appclass.js
as appConfig.ui
.
Example:
//appclass.js snippet
var App_Class = function (appConfig, appContent, root) {
this.appConfig = appConfig;
this.appContent = appContent;
this.ui = appConfig.ui; //F2.UI instance
this.$root = $(root);
}
As the layout inside your app changes, your app should update or refresh its height on the container. This is particularly important for those secure apps inside iframes. To handle this, F2.js provides a updateHeight()
method you should call anytime a DOM element is added or removed from within an app.
Assuming the example above is used, the this.ui
property holds the instance of appConfig.ui
.
//appclass.js snippet
...
//user deletes row
$(".row").remove();
//call updateHeight method
this.ui.updateHeight();
...
Apps can show loading spinners—or "masks"—when they are being loaded by a container or afterwards when making data requests. Container Developers configure the UI.Mask
as discussed in the SDK F2.ContainerConfig.UI.Mask docs, therefore it is simple for app developers to call showMask()
.
To show a loading spinner when making an ajax request within an app:
//appclass.js snippet
...
//show loading
this.ui.showMask(this.root,true);
//app makes data request
$.ajax({
url: "../data.json"
}).done(function(jqxhr){
F2.log(jqxhr);
//hide loading
this.ui.hideMask(this.root);
});
...
The showMask()
method takes two arguments: a DOM element where to show the mask and a boolean indicating whether or not to show a spinning graphic.
If you do not want to show a spinning graphic, simply pass false
to the showMask()
method. A mask without a spinner is useful in the case when you want to "lock" the view from user interaction.
//appclass.js snippet
...
//show mask, no spinner
this.ui.showMask(this.root,false);
...
For full details, read about F2.UI in the SDK.
To update the title of an app in the app's chrome (as defined by the container in F2.ContainerConfig.appRender), very simply pass a string to the setTitle()
method.
//appclass.js snippet
...
this.ui.setTitle("Chart for MSFT");
...
F2.js provides two methods in F2.UI
for modal dialogs. F2 uses and recommends Twitter Bootstrap for many reasons, and taking advantage of Bootstrap's modals was an easy choice.
For full details on F2.UI.Modals and the two types of modals (alert
and confirm
), read the SDK docs.
Usage is simple:
//appclass.js snippet
...
this.ui.Modals.alert("A message to display in a modal.");
...
You can optionally provide a callback to be fired when the user closes the modal.
//appclass.js snippet
...
this.ui.Modals.alert("A message to display in a modal.", function(){
F2.log("Modal closed!");
});
...
Additionally, there is a confirm
modal.
//appclass.js snippet
...
this.ui.Modals.confirm(
"A message to display in a confirmation modal.",
function(){
F2.log("OK clicked");
},
function(){
F2.log("Cancel clicked");
}
);
...
Adding and managing views within an F2 app is considered an advanced topic. If your app only needs a single view, you don't have to worry about reading this part of the F2 spec.
F2 apps can have one or more views. Every app will have at least one "home" view, while others will include views for settings, help or about. Inside the F2.js SDK, we've included support for views and the list can be extended by the container provider.
Note If the container doesn't support all the views you need inside your app, you will need to coordinate those additions with the container provider.
Once you've determined the views you'd like to include in your app, the view should be specified by applying the F2.Constants.Css.APPVIEW
classname to the containing DOM Element. A data-
attribute should be added to the element as well which defines what view type is represented. Twitter Bootstrap's hide
class should be applied to views that are hidden on startup.
To setup a single view in your app, use this HTML on your app's outermost element noting the use of the f2-app-view
classname and the data-f2-view
attribute.

...

To setup multiple views in your app, write HTML like this noting the use the f2-app-view
and hide
classnames as well as the data-f2-view
attributes.

...

...

For details on F2.Constants.Css.APPVIEW
, browse to the SDK docs.
The F2.UI
namespace provides an API for developers to manage F2 app View state.
To programmatically change a View in javascript:
appConfig.ui.Views.change(F2.Constants.Views.HOME);
Note When appConfig.ui.Views.change()
is called, the hide
classname is automatically added or removed by F2.js depending on the visibility of the view. Read more in the SDK docs.
In F2 app HTML, you can use a combination of CSS classnames and data-
attributes to provide UI elements making it easy for users to navigate between Views.
For example, an app has two views: "home" and "about". On the "home" View, a button allows the user to navigate to the "about" view. In the presence of the classname f2-app-view-trigger
and the data-f2-view
data attribute, F2.js automatically adds a javascript event to the button.

<button class="btn f2-app-view-trigger" data-f2-view="about">Show About View</button>

To get back to the "home" View from the "about" View:

...
<button class="btn f2-app-view-trigger" data-f2-view="home">« Back Home</button>
...

You shouldn't be surprised to know F2.js contains event triggers for handling app View changes. To listen for View changes inside F2 app javascript code:
appConfig.ui.Views.change(function(view){
F2.log("View changed to ", view);
});
For details on F2.UI.Views
, browse to the SDK docs and for details on F2.Constants.Views
, head over to the F2.Constants docs.
User or content entitlements are the responsibility of the App Developer. Many apps will need to be decoupled from the content that they need. This could include apps like research aggregation, news filtering, streaming market data, etc. Similarly to how companies build their own websites today with their own authentication and access (or content) entitlements, F2 apps are no different.
Further details around app entitlements will be forthcoming as the F2 specification evolves.
Single sign-on (SSO) is a shared responsibility between the Container and App Developer. In some cases, containers will want all of its apps to be authenticated seamlessly for users;that will be negotiated between Container and App Developers. For the purposes of this documentation, it is assumed Container Developers will build and host their container access authentication.
Once a user is authenticated on the container, how is the user then authenticated with all of the apps? Encrypted URLs.*
Note The Container Developer is free to utilize any app authentication method they deem fit. Container Developers and app developers will need to work together to finalize the authentication details.
Implementing SSO using encrypted URLs is a simple and straight-forward authentication mechanism for securing cross-domain multi-provider apps. To guarantee security between the Container and App Developer, secure API contracts must be negotiated. This includes, but is not limited to, the choice of cryptographic algorithm (such as AES
) and the exchange of public keys.
When the container provider calls F2.registerApps()
, custom logic should be added to append encrypted user credentials—on a need-to-know basis—to each app requiring authentication.
Authentication is a critical part of any container-app relationship. There are a plethora of SSO implementations and there are many considerations for both Container and App Developers alike.
Further details around container and app single sign-on will be forthcoming as the F2 specification evolves.


Bloomberg Flub: Misidentifies Region He's Campaigning in on Twitter
Former New York City mayor and current Democrat presidential candidate Michael Bloomberg kicked off his campaign by delivering remarks in Norfolk, Virginia, on Monday but initially misidentified the region on Twitter, writing, “southwestern Virginia proves that – with the right candidate – we can turn areas from red to blue.”
by Hannah BleauBloomberg, who officially tossed his hat into the presidential ring on Sunday, delivered remarks in Norfolk, Virginia, on Monday but misidentified the city’s region in his initial tweet:
He eventually deleted the tweet and provided a new one, replacing “southwestern” with “southeastern”:
Bloomberg, however, named the correct region during his speech, proclaiming that southeastern Virginia “proves that with the right candidate, we can turn areas from red to blue.”
“And we need to do that all across this country,” he said.
He continued:
Today, I’m glad to announce that I’m running for president to defeat Donald Trump and to unite and rebuild America. We cannot afford four more years of Trump’s reckless and unethical actions. He is an existential threat to our country, to our values, and our national security, and every day it seems to bring another example of just how unfit he is to serve as our president and Commander-in-Chief, and this week was no exception.
Sen. Elizabeth Warren (D-MA) took aim at Bloomberg on the campaign trail on Monday, telling a crowd in Iowa that the billionaire is relying on “bags and bags of money” to “buy the nomination.”
“His view is that he doesn’t need people who knock on doors. He doesn’t need to get out and campaign with people. He doesn’t need volunteers.


June 22, 2017
Here is a funny video
A few facts about cats:
Find more information here: www.sciencekids.co.nzCheck out these fun cat facts for kids. Learn about cats as pets, their unique behavior, how long they sleep and much more. Read on and enjoy the wide range of interesting facts about cats and kittens. Cats are one of, if not the most, popular pet in the world. There are over 500 million domestic cats in the world. Cats and humans have been associated for nearly 10000 years. Cats conserve energy by sleeping for an average of 13 to14 hours a day. Cats have flexible bodies and teeth adapted for hunting small animals such as mice and rats. A group of cats is called a clowder, a male cat is called a tom, a female cat is called a molly or queen while young cats are called kittens. Domestic cats usually weigh around 4 kilograms (8 lb 13 oz) to 5 kilograms (11 lb 0 oz). The heaviest domestic cat on record is 21.297 kilograms (46 lb 15.2 oz). Cats can be lethal hunters and very sneaky, when they walk their back paws step almost exactly in the same place as the front paws did beforehand, this keeps noise to a minimum and limits visible tracks. Cats have powerful night vision, allowing them to see at light levels six times lower than what a human needs in order to see. Cats also have excellent hearing and a powerful sense of smell. Older cats can at times act aggressively towards kittens. Domestic cats love to play, this is especially true with kittens who love to chase toys and play fight. Play fighting among kittens may be a way for them to practice and learn skills for hunting and fighting. On average cats live for around 12 to 15 years. Cats spend a large amount of time licking their coats to keep them clean. Feral cats are often seen as pests and threats to native animals.


←
Home
About
Subscribe
IamVP7
Blogging about mobile API's and random fav things
Matchstick is a Firefox OS based HDMI TV
Learn some Basic Gestures in Firefox OS
Starting Firefox OS First Time in Cloud Fx
Unboxing Cloud FX
Firefox App of the Month - September
←
Newer Posts
Older Posts
→


Scoreboard
Main
Code
HUB
Scoreboard Manager
Scoreboard
Name
Score
Scoreboard Manager
×
Click create to create a Scoreboard :D


Drag and drop some MIDI files or
select files
to transform.
You can then download the files individually or as a zip.
If you change the settings, the results will be updated automatically.
Settings
See mathjs syntax.
Available variables:
n = the note number from 0 to 127;
channel = the channel number from 0 to 16


GHI Electronics Bootloader
The GHI Electronics Bootloader is used to update the firmware on our devices. It is the first program to run and unless the device specific LDR pins are set (see device documentation for details), it will execute the firmware on the device (if present).
The bootloader communicates over a USB (virtual serial port) and a regular serial port. The interface used is controlled by a MOD pin as detailed in Special Pins.
Loading the Firmware
The individual product pages include further instructions on the firmware needed and how to set the board in the loader mode. Once you have downloaded the firmware and set the board in loader mode, use the instructions below to load the firmware.
Using TinyCLR Config
TinyCLR Config tool includes multiple features developers need to work with TinyCLR OS-enabled devices. It simplifies the firmware update and it includes options for accessing the TinyCLR firmware at runtime.
Using this tool is the recommended path; however, manual installation instructions are also included on this page. Read more on the TinyCLR Config page.
Manual Update
TinyCLR Config tool should be used to update the firmware. As a backup, use these instructions:
- Put your board in bootloader mode. Each product has a specific way to enter the boot loader.
- Open any terminal software, for example Tera Term.
- Select serial and pick the COM port associated with your board. (If unsure, check Device Manager)
- Press
V
and then enter. You will see back the boot loader version number (v2.x.x) - Press
U
orX
and then enter. UseX
for firmware file type GHI andU
for firmware file type GLB. - Press
Y
to confirm then enter. You will now seeCCCC
... - Go to
File
->Transfer
->XMODEM
->Send
. - IMPORTANT: Make sure you check the
1K
option. - Select the firmware file.
- When the transfer is complete, reset your board.
Commands
All commands and results are terminated with CR and LF (\r\n). "OK." will be sent after each successful command.
On startup, a banner is sent that is terminated by "OK.". Once the banner is received, you are free to enter any of the case-insensitive single-character commands described below.
Most commands require confirmation. Send Y or y followed by a new-line to proceed or anything else to cancel.
- V: Returns the current version.
- N: Returns the current device type.
- E: Erases all user sectors of the device.
- R: Runs the firmware if present.
- B: Increases the baud rate in serial mode to 921,600.
- X: Upload a
ghi
file to the device using 1K XMODEM. Only send *.ghi files meant for your device.
USB Drivers
Tip
Only needed for Windows 7 and 8.
| File | Date | Status | MD5 |
|---|---|---|---|
| v1.0.0 x64 | 2018-12-27 | Production | 74D66FC4236126A83CCCFE28D556F339 |
| v1.0.0 x86 | 2018-12-27 | Production | 8BDE68132452E22B14597C0972ABA8FD |


FTW-Clone
Changes
Report
Logout
FTW
Countdown
Time Per Problem
Number of Problems
Create Game
User
Rating
User
Score
Start Game
Create Game
Leave Game
Waiting to start...


Confused about which programming language to learn? Take this quick quiz to get an idea of which programming language you might like to learn
Learn More About the Difference Between Front and Back End Here
CSS/DesignLearn More About CSS and Design Here
C#/.NET
Learn More About C# and .NET Here
Java/Android
Learn More About Java and Android Here
PHP/Drupal
Learn More About PHP and Drupal Here
Ruby/Rails
Learn More About Ruby and Rails Here


Remove the “x” prefixes from the red, green, and blue animation names above.
How long after edit do we see animation?


Introductions
Hello and welcome to my site. I have no real need for a web page so I decided to make a "for fun" page for this class.
I'm a 29 year-old wife and artist living in the desert of Arizona. I am a jack-of-trades in the art community, having tried my hand in both traditional and digital arts, animation, jewelery, wood carving, and furniture making.
My passion (and sometimes obsession) burns brightest during the concept and design stages. Simply tell me what it is you're imagining and I'll bring it to life in the medium of your choice.
Testing Ground for new projects
Creating A Time Calculator
I decided to do my tutorial on the time calculator with the pop up calendar. This is how the calculator works when finished. I've removedthe calendar styling to allow them the room to style it to fit thier own site.
Tutorial Mode: With Comments - Without Comments
| Sun | Mon | Tue | Wed | Thu | Fri | Sat |
|---|---|---|---|---|---|---|
close ☒


SUBROUTINE DLAED9( K, KSTART, KSTOP, N, D, Q, LDQ, RHO, DLAMDA, W, $ S, LDS, INFO ) * * -- LAPACK routine (version 3.1) -- * Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. * November 2006 * * .. Scalar Arguments .. INTEGER INFO, K, KSTART, KSTOP, LDQ, LDS, N DOUBLE PRECISION RHO * .. * .. Array Arguments .. DOUBLE PRECISION D( * ), DLAMDA( * ), Q( LDQ, * ), S( LDS, * ), $ W( * ) * .. * * Purpose * ======= * * DLAED9 finds the roots of the secular equation, as defined by the * values in D, Z, and RHO, between KSTART and KSTOP. It makes the * appropriate calls to DLAED4 and then stores the new matrix of * eigenvectors for use in calculating the next level of Z vectors. * * Arguments * ========= * * K (input) INTEGER * The number of terms in the rational function to be solved by * DLAED4. K >= 0. * * KSTART (input) INTEGER * KSTOP (input) INTEGER * The updated eigenvalues Lambda(I), KSTART <= I <= KSTOP * are to be computed. 1 <= KSTART <= KSTOP <= K. * * N (input) INTEGER * The number of rows and columns in the Q matrix. * N >= K (delation may result in N > K). * * D (output) DOUBLE PRECISION array, dimension (N) * D(I) contains the updated eigenvalues * for KSTART <= I <= KSTOP. * * Q (workspace) DOUBLE PRECISION array, dimension (LDQ,N) * * LDQ (input) INTEGER * The leading dimension of the array Q. LDQ >= max( 1, N ). * * RHO (input) DOUBLE PRECISION * The value of the parameter in the rank one update equation. * RHO >= 0 required. * * DLAMDA (input) DOUBLE PRECISION array, dimension (K) * The first K elements of this array contain the old roots * of the deflated updating problem. These are the poles * of the secular equation. * * W (input) DOUBLE PRECISION array, dimension (K) * The first K elements of this array contain the components * of the deflation-adjusted updating vector. * * S (output) DOUBLE PRECISION array, dimension (LDS, K) * Will contain the eigenvectors of the repaired matrix which * will be stored for subsequent Z vector calculation and * multiplied by the previously accumulated eigenvectors * to update the system. * * LDS (input) INTEGER * The leading dimension of S. LDS >= max( 1, K ). * * INFO (output) INTEGER * = 0: successful exit. * < 0: if INFO = -i, the i-th argument had an illegal value. * > 0: if INFO = 1, an eigenvalue did not converge * * Further Details * =============== * * Based on contributions by * Jeff Rutter, Computer Science Division, University of California * at Berkeley, USA * * ===================================================================== * * .. Local Scalars .. INTEGER I, J DOUBLE PRECISION TEMP * .. * .. External Functions .. DOUBLE PRECISION DLAMC3, DNRM2 EXTERNAL DLAMC3, DNRM2 * .. * .. External Subroutines .. EXTERNAL DCOPY, DLAED4, XERBLA * .. * .. Intrinsic Functions .. INTRINSIC MAX, SIGN, SQRT * .. * .. Executable Statements .. * * Test the input parameters. * INFO = 0 * IF( K.LT.0 ) THEN INFO = -1 ELSE IF( KSTART.LT.1 .OR. KSTART.GT.MAX( 1, K ) ) THEN INFO = -2 ELSE IF( MAX( 1, KSTOP ).LT.KSTART .OR. KSTOP.GT.MAX( 1, K ) ) $ THEN INFO = -3 ELSE IF( N.LT.K ) THEN INFO = -4 ELSE IF( LDQ.LT.MAX( 1, K ) ) THEN INFO = -7 ELSE IF( LDS.LT.MAX( 1, K ) ) THEN INFO = -12 END IF IF( INFO.NE.0 ) THEN CALL XERBLA( 'DLAED9', -INFO ) RETURN END IF * * Quick return if possible * IF( K.EQ.0 ) $ RETURN * * Modify values DLAMDA(i) to make sure all DLAMDA(i)-DLAMDA(j) can * be computed with high relative accuracy (barring over/underflow). * This is a problem on machines without a guard digit in * add/subtract (Cray XMP, Cray YMP, Cray C 90 and Cray 2). * The following code replaces DLAMDA(I) by 2*DLAMDA(I)-DLAMDA(I), * which on any of these machines zeros out the bottommost * bit of DLAMDA(I) if it is 1; this makes the subsequent * subtractions DLAMDA(I)-DLAMDA(J) unproblematic when cancellation * occurs. On binary machines with a guard digit (almost all * machines) it does not change DLAMDA(I) at all. On hexadecimal * and decimal machines with a guard digit, it slightly * changes the bottommost bits of DLAMDA(I). It does not account * for hexadecimal or decimal machines without guard digits * (we know of none). We use a subroutine call to compute * 2*DLAMBDA(I) to prevent optimizing compilers from eliminating * this code. * DO 10 I = 1, N DLAMDA( I ) = DLAMC3( DLAMDA( I ), DLAMDA( I ) ) - DLAMDA( I ) 10 CONTINUE * DO 20 J = KSTART, KSTOP CALL DLAED4( K, J, DLAMDA, W, Q( 1, J ), RHO, D( J ), INFO ) * * If the zero finder fails, the computation is terminated. * IF( INFO.NE.0 ) $ GO TO 120 20 CONTINUE * IF( K.EQ.1 .OR. K.EQ.2 ) THEN DO 40 I = 1, K DO 30 J = 1, K S( J, I ) = Q( J, I ) 30 CONTINUE 40 CONTINUE GO TO 120 END IF * * Compute updated W. * CALL DCOPY( K, W, 1, S, 1 ) * * Initialize W(I) = Q(I,I) * CALL DCOPY( K, Q, LDQ+1, W, 1 ) DO 70 J = 1, K DO 50 I = 1, J - 1 W( I ) = W( I )*( Q( I, J ) / ( DLAMDA( I )-DLAMDA( J ) ) ) 50 CONTINUE DO 60 I = J + 1, K W( I ) = W( I )*( Q( I, J ) / ( DLAMDA( I )-DLAMDA( J ) ) ) 60 CONTINUE 70 CONTINUE DO 80 I = 1, K W( I ) = SIGN( SQRT( -W( I ) ), S( I, 1 ) ) 80 CONTINUE * * Compute eigenvectors of the modified rank-1 modification. * DO 110 J = 1, K DO 90 I = 1, K Q( I, J ) = W( I ) / Q( I, J ) 90 CONTINUE TEMP = DNRM2( K, Q( 1, J ), 1 ) DO 100 I = 1, K S( I, J ) = Q( I, J ) / TEMP 100 CONTINUE 110 CONTINUE * 120 CONTINUE RETURN * * End of DLAED9 * END


Error 404: Not Found
No page exists at this URL. If you think something should be here, please contact Fenhl on Discord or at
<EMAIL_ADDRESS>. Or go back to
Lore Seeker's main page
.


---
sort_order: 83
tei_id: rdx_b5j2m.p.idm208853936
annotation_count: 0
images:
small-thumbnail: http://readux.library.emory.edu/books/emory:b5j2m/pages/emory:p765g/mini-thumbnail/
json: http://readux.library.emory.edu/books/emory:b5j2m/pages/emory:p765g/info/
full: http://readux.library.emory.edu/books/emory:b5j2m/pages/emory:p765g/fs/
page: http://readux.library.emory.edu/books/emory:b5j2m/pages/emory:p765g/single-page/
thumbnail: http://readux.library.emory.edu/books/emory:b5j2m/pages/emory:p765g/thumbnail/
title: Page 83
number: 83
---
{% raw %}ESCAPE FROM BONDAGE.{% endraw %}
{% raw %}79{% endraw %}
{% raw %}freedom and blessedness. I felt energy enough in{% endraw %}
{% raw %}my own breast to contend with privation and{% endraw %}
{% raw %}danger; and had I been a free, untrammelled man,{% endraw %}
{% raw %}knowing no tie of father or husband, and concerned{% endraw %}
{% raw %}for my own safety only, I would have felt all difficul¬{% endraw %}
{% raw %}ties light in view of the hope that was set before me.{% endraw %}
{% raw %}But, alas ' I had a wife and four dear children ; how{% endraw %}
{% raw %}should I provide for them ? Abandon them I could{% endraw %}
{% raw %}not; no ' not even for the blessed boon of freedom.{% endraw %}
{% raw %}They, too, must go. They, too, must share with me{% endraw %}
{% raw %}the life of liberty.{% endraw %}
{% raw %}It was not without long thought upon the subject{% endraw %}
{% raw %}that I devised a plan of escape. But at last I{% endraw %}
{% raw %}matured it. My mind fully made up, I communi¬{% endraw %}
{% raw %}cated the intention to my wife. She was over¬{% endraw %}
{% raw %}whelmed with terror. With a woman's instinct she{% endraw %}
{% raw %}-clung to hearth and home. She knew nothing of{% endraw %}
{% raw %}the wide world beyond, and her imagination peopled{% endraw %}
{% raw %}it with unseen horrors.  With tears and supplications she besought{% endraw %}
{% raw %}me to remain at home, contented. In vain I ex¬{% endraw %}
{% raw %}plained to her our liability to be torn asunder at any{% endraw %}
{% raw %}moment; the horrors of the slavery I had lately{% endraw %}
{% raw %}seen ; the happiness we should enjoy together in a{% endraw %}
{% raw %}land of freedom, safe from all pursuing harm. She{% endraw %}
{% raw %}had not suffered the bitterness of my lot, nor felt the{% endraw %}
{% raw %}same longing for deliverance. She was a poor,{% endraw %}
{% raw %}timid, unreasoning slave-woman.{% endraw %}
{% raw %}I argued the matter with her at various times, tfll{% endraw %}
{% raw %}I was satisfied that argument alone would not pre-{% endraw %}


Ubuntu 14.04 (Linux 3.13.0-48), freeradius 2.1.12, ASA 9.4.2 (which runs Lua 5.0.2), AnyConnect 4.2
Setting up communications between an ASA and a radius server can be tricky, because it's hard to know what attributes the radius server is sending back and are being applied to a user session. One method is to use wireshark to capture the communications between the ASA and radius server. Another is to enable debugging on the ASA with debug dap trace. An easier way is to just have the attributes printed out on the end-user device when they log in.
The dynamic access policy feature of the ASA will let you input Lua functions to get this information. Open ASDM and go to
- Configuration
- Remote Access VPN
- Network (Client) Access
- Dynamic Access Policies
- Click Add
- Policy Name: debug
- Priority: 1 (or whatever works in your environment)
- In the Selection Criteria area, click Advanced
- Make sure AND is selected. In the Logical Expressions box, enter:
assert(function() function print_table(tbl, prefix) if (type(tbl) == "table") then for k,v in pairs(tbl) do if (type(v) == "table") then print_table(v, prefix .. "." .. k) else CheckAndMsg(true, prefix .. "." .. k .. "=\"" .. v .. "\"", "") end end end end CheckAndMsg(true, "============", "") CheckAndMsg(true, "DEBUG", "") print_table(aaa, "aaa") print_table(endpoint, "endpoint") return true end)()
- Click OK to close the Add Dynamic Access Policy window, then click Apply
Now, if you log in to AnyConnect on a device, you'll notice that a dropdown message box appears and shows you the values of the AV pairs.
You might want to be able to toggle the display of the debug message from a freeradius server. That will allow you to turn it on when a user calls in and reports problems and you need to know what settings are being applied to their account.
- On the freeradius server, change their user record and add Reply-Message = "debug_print". Note that you could use any attribute you want, but I know that Reply-Message does work.
test Cleartext-Password := "test123" Class = "OU=Test_VPN;", Reply-Message = "debug_print"
- Back in ASDM, go to the debug policy you created earlier and change it so that it only fires when Reply-Message = "debug_print"
- OK and Apply


resource bzopen ( string $filename , string $mode )
bzopen() opens a bzip2 (.bz2) file for reading or writing.
If the open fails, bzopen() returns FALSE, otherwise it returns a pointer to the newly opened file.


Hi! I’m Lacy Morrow,
A freelance web developer.
I specialize in front and back–end web development, application design, and hardware maintenance.
I’m currently an engineer
at Invitae
in San Francisco
EXPERTISE
- PHP
- HTML [CSS3/HTML5]
- Javascript [AJAX/JQuery]
- Flash [ActionScript 3]
- MySQL
- CMS Theme Creation [WordPress/SocialEngine/Drupal/Joomla!]
- C/++
- Objective–C [Applescript/Cocoa/Carbon]
- Python
- Java
- VB.net
- Cutting–Edge Web Development
- Website Creation/Revival
- Application Development
- Mobile Web/Application Development
- Web Presence — Search Engine Optimization
- Flash Development
- Java Development
- Open–Source Advocate
- Technology Consultation
[I make house calls]
Development
In my free time, I enjoy snowboarding, playing the piano and drums, and scripting beautiful code. Here are some of my most notable projects listed below. Back before Flash was obsolete I used to create quite interesting projects. I encourage you to take a peek. Check it out.
Other endeavors:
Current Project:
-
xPlay.js
xPlay.js is the ultimate tool in playing multiple media files on a website. With a drop–and–go PHP script which scans a directory for media and generates a valid XSPF playlist for your video and audio files.
Visit Site » -
XSPF Jukebox
A fully–customizable, Flash–based web media player for your many video and audio files. Open–source and freely avaailable.
Visit Site » -
Experiments
A collection of programming experiments I've amassed over the years, many of them Flash-based. Sources are all freely available. Enjoy!
Visit Site »


Jim Sandoval
Senior Software Manager, Architect and Developer
Broad and deep career as manager, product owner, full-stack developer, distributed systems / microservice architect, consultant. Track-record of industry leading innovation. Excellent mentor. Team player.
I like apps that "just work" - that disappear as users engage with complex work. I have an extensive background with apps that people use all-day every-day; apps with multi-user workflows, often across companies, involving significant integration with other systems, often significantly transforming business processes.
I've architected systems that are reliable, cheap to operate, easy to iterate and easy extend for the long-haul. I've established well-defined, auditable processes that make delivery more assured without getting in the way.
Technology Focus / Skillset
Javascript, HTML, CSS, Vue, Node, Java, SQL
S3, Cloudfront, Lambda@Edge, Route 53, EC2, CloudFormation, CodePipeline
Git, Jira, Confluence, Scrum, Kanban.
Experience
2020 - Independent Consultant.
2020 (Mar-Oct) - IT Manager, Krispy Krunchy Foods. Responsible for day-to-day operations of back-end accounting system, custom-built iPad based sales support platform, EDI links to suppliers and distributors, and customer-facing ecommerce platforms.
2015 – 2020 - Senior Dev Manager, Myriad Genetics. Managed 6 engineers writing tools to analyze genetic data for clinical oncology products. Responsible for all aspects of 20 separate applications, including 6 Java/Swing apps with complex data visualization and multi-user workflow and a highly-parallelized analytical pipeline. Introduced Site Reliability Engineering for high-performance-compute environment. Led additional 2 engineers and 1 UX designer in design and build of modern front-end platform in Vue.js. Designed and established SDLC process to meet FDA guidelines for companion diagnostics.2004-2015 - Principal Engineer, JPMorgan Chase. Product Owner, UX Designer, Solution Architect and Front-End Engineer within mature, large-scale, high-performance microservice architecture. Designed and built eight separate advanced trading products for execution management platform, including innovative and industry-first Algorithm Management System allowing users to flowchart routing to different algos based on trade performance. 200,000 orders per day, 10,000 daily users, data centers in NA, EMEA and Asia, links to 150 exchanges, 500 exchanges and brokers. (Java, Swing, asynchronous messaging, FIX)
2003-2004 – TIBCO/EAI, Consultant, Zettaworks
2001-2002 – CTO, Co-Founder, ForwardCast
1997-2001 – Architect/Full-stack Engineer, Bank of Boston
1994-1997 – Architect/Dev Manager, State Street Bank
1993-1994 – Lead Developer, University of New Mexico Hospital
1992 – Lead Developer, MORE, Inc
1987-1991 – Lead Developer, Citibank
1985-1986 – Analyst/Developer, BDM


Therapist name: George Fan Xu, L,Ac. OMD
Education: University of Canton (China) Traditional Chinese Medicine.
Experience: Practice Traditional Chinese Medicine in S.C and GA for 2 years. Three generations of family practiced in Traditional Chinese Medicine in China.
Specialty: Treating allergies (Sinuses, asthma, skin diseases, etc.)
Common diseases: Common cold/flu, Anemia, Bells pause, migraine headache, menstrual problems, pain control, diabetes poor circulation, Cancer and its treatment with bad side effects healing. I.M.S
Dr. George Fan Xu is a third generation doctor from Guangzhou (formerly Canton) who began studying under his father when he was 14 and at 18 attended the prestigious Guangzhou Traditional Chinese Medical College where he graduated after 5 years of study under some of the best specialists in arioso disciplines of traditional Chinese medicine. He came to the U.S. in 1983 as an exchange student and moved to Atlanta in 1987 where he has established an excellent record as an herbalist and acupuncturist.
Dr. Xu has specialized in respiratory problems such as allergy, asthma, and bronchitis as well as athirst, kidney problems, infertility, and liver problems. He has had good success in curing arthritis and regenerating the cartilage in patients nee thereby enabling them avoid knee replacement surgery. He was very distressed to hear that there are 55,000 knee replacement surgeries each year in America when most of these bad knees could be easily cured by traditional Chinese medicine.
Dr. Xu uses the traditional Chinese diagnosis of Chi pulse, tongue, eyes, and nails to find out what is wrong with the patient and is tireless in studying the attest advances in traditional Chinese medicine. He typifies the traditional barefoot doctor approach to medicine as he always put the patient before money. He takes the time to educate them about their condition and treatment and follows up office visits with phone calls to check on their progress. In the best traditions of Chinese machine he treats case instead of the symptoms and does it without side effects to the patient.


Step-by-step guide to join KICKICO crowdsale
(even if you don’t own any crypto assets and you never used crypto before)
Buy Bitcoins on Localbitcoins.net
1. Go to Localbitcoins.net, and fill out the registration form, if you have an account already - skip this step and move to the next one.
If you want to switch interface language - you can find language switch at the bottom of the page.
Check your email after completing the registration and confirm your email. After the confirmation - you will be redirected to the page with detailed instructions.
2. Go to the main page and in the search box fill in the form with the amount you want to buy in your currency, your location and choose a payment method. If you're unsure how you want to pay, choose "All online offers" as your payment method. The site will list bitcoin traders available in your region.
3. From the list of advertisements, choose one from a trader with a good reputation score and a high amount of trades. The response time indicator shows if a trader replies within five minutes (green), within 30 minutes (yellow) or slower than 30 minutes (grey). You can click the 'Buy' button to view more information about an advertisement.
4. After you press the 'Buy' button you'll see more information about the advertisement, including the terms of the trade. Read through them before submitting the trade request, if you don't agree with them you can go back to the previous page and choose another advertisement.
To start the trade, type in the blue box how much you want to buy, enter a message for the seller and click the Send trade request button to the start the trade. Be sure you're ready to pay when clicking the button, if you don't pay before the payment window is over, the trade will be automatically cancelled.
5. Once you have made the payment, click the I have paid button. Once the trader has verified that your payment has been received your Bitcoin will be released from escrow and they are instantly available in your LocalBitcoins wallet.
And that's all there is to it, congratulations on your first Bitcoin trade!
And that's all there is to it, congratulations on your first Bitcoin trade!
Send your Bitcoins to an exchange
You may choose from variety of exchanges to send your Bitcoins to.
This step is needed to exchange your Bitcoins to Ethereum, so that you will be able to send Ethereum to your private wallet and then to KICKICO crowdsale.
In this very guide we chose EXMO as a service to exchange Bitcoins to Ethereum allowing withdrawal up to 500 ETH with no ID verification. But all other Exchanges actually do the same thing - you transfer them Bitcoins and exchange to Ethereum.
1. Go to https://exmo.me and sign up (check your email for activation link).
* In case you can’t access Exmo exchange - you can download Exodus.io wallet and send your Bitcoins to Exodus wallet and exchange them into Ethereum (but it may be longer and the rate might be higher). Exodus is a great wallet to store your crypto-assets. Just download and install it - and you can use it. Go to Wallet and select Bitcoin - then click Receive button and you will see your Exodus Bitcoin address. Send your Bitcoins to this address. After you received your Bitcoins - go to exchange tab and exchange Bitcoins to Ethereum. The exchange process may take up to 1 hour or more. After you received Ethereum - you can send it from your wallet: go to Wallet, and select Ethereum, then click Send button, insert address and amount and click send.
* Another alternative to an exchange is Changelly service. This service allows you to buy Ethereum directly using your bank card. The interface is really intuitive, BUT LOOK FOR THE RATE. The rate is often really high, so use it in carefully. It may even ask for ID verification process and so on.
2. On Exmo.me choose a Wallet section in the top menu. Then press «Deposit» for BTC.
3. Create a Bitcoin wallet.
4. The address of the wallet for transferring the bitcoins to recharge the balance appears. Copy it.
5. Go back to Localbitcoins.net select «Wallet», Send Bitcoins tab. Enter the Receiving bitcoin address and the Amount in bitcoins and click continue. Next screen will ask your account password to confirm the transaction. Enter the password and confirm.
6. Wait for the network to process your payment and your balance will be added to the stock exchange. Transfer of funds to the balance of Exmo.me pass through 6 network confirmations (6 confirmations). Check the progress of the transaction on the link that the bot offers you.
Exchange Bitcoins for Ethereum(ETH)
1. Go to Exmo.me in the «exchange» section and choose in the drop-down list what you give to BTC and get ETH.
2. Enter the amount in the bitcoins you want to change and click the «exchange». Now you have ETH on the balance sheet.
Create Ethereum wallet on myetherwallet.com
1. Go to https://myetherwallet.com. And follow the instructions to create your wallet ether.
* In case you are using Exodus wallet - you don’t need to create the address. Use the private key from the Exodus wallet to access your Ethereum address via myetherwallet.com:
— Export a private key: if you are on macOS, the develop menu is under 'Exodus'. If you are using Windows or Linux, it can be accessed by pressing Ctrl+Shift+D.
Select Developer > Assets > Ethereum > Export private keys
Go to the folder and open the export file. You will see csv file - open it and find you private key (the sybmols after the last comma), copy it.
— Then go to https://myetherwallet.com and select Send Ether & Tokens. Enter your wallet using the Private Key
2. Save your file and click the button that you understand. Continue.
3. On the next screen save your private key and click on the save your address button.
4. On the next screen choose How do you want to access your wallet. Select the Keystore File (UTC / JSON) and click on the button on the right. Select the file that you saved in step 2 and enter the password for access.
5. After unlocking the address you will see below your wallet number.
Send Ethereum to your MEW address
Go to Exmo.me. In the Wallet section opposite ETH, select «withdraw» and in the next window enter the amount available in ETH and the address of your ETH wallet from myetherwallet.com and press «withdraw».
Send Ethereum to KICKICO crowdsale
1. Having received ETH on your wallet https://myetherwallet.com, choose «Send Ether & Tokens» in the menu. Unlock your wallet with the JSON file and your password.
2. Enter the address and amount of the transfer. Set gas limit to 300000 and Gas price to 24 GWEI, click generate the transaction.
You can find the address for sending ETH on the website:
https://www.kickico.com/ru/campaigns/999/ico
Select “Contribute” and follow instructions until you see ETH address for joining crowdsale. Copy the address and send ETH using myetherwallet.com
The correct address for KickICO Crowdsale
0x3AA5FA4FBF18d19548680a5f2BbA061b18Fed26b
Add KickCoins to your wallet
To add KC tokens after sending to your wallet - enter your Ethereum wallet (usually https://www.myetherwallet.com/#view-wallet-info ) and select «Add custom token». You will see three fields: token name, address and decimals.
Address - 0xc0e4f45b828aa4aa628e897e5da38d9dc72c2257
Token name - KC
Decimals – the number of characters after the point, specify 8
After that, click «Save» and you will see your KickCoin balance.


Thank you for choosing the Quartz system to manage your professor and course information online. This page will instruct you on the Quartz installation process. The form below takes in all the information your system will need to provide a smooth installation of Quartz.
Here we will provide a brief explination of what each field is asking for so that your set up is as easy as possible:
MySQL Server Name: The servername that Quartz databases will be kept on. If you are running on WAMP/MAMP/LAMP this will be localhost.
MySQL Root User Password: The password to the server. If your server password is different from the default, enter your password. If your password is the default password enter 0. If you are unsure of the password, contact your server adminstrator.
Quartz Admin Name: The username of the Quartz admin. If you are the admin, please input your desired admin name. This should be the same as the name portion of your BU email. (EX: If your email is<EMAIL_ADDRESS>the username should be "john") If you are a professor installing Quartz, please contact your administrator for this information.
Quartz Admin Password: The password of the Quartz admin. If you are the admin, please input your desired password. If you are a professor installing Quartz, please contact your administrator for this information.
Quartz Database Name: The main database name for Quartz. If you are the admin, choose a name. If you are a professor, contact your Quartz adminstrator for this information.
URL of your Webserver: This requires the URL of the webserver on which Quartz runs. In the case you are running on WAMP/MAMP/LAMP and you Apache server runs on a different port than the default, write the server URL with the name of the different port number. (EX: If your server URL is http://localhost/ and it must run on port 81, write http://localhost:81/). If you are unsure of this information, contact your Quartz administrator.
Name of Quartz's subfolder: The subfolder where Quartz can be found.(EX: http://localhost/Quartz2012 or http://localhost:81/Quartz2012). If you are unsure of this information ask your Quartz administrator.
Does your server have the ability to send mail? field asks if your server has the capability to send an email directly. If you have LAMP/MAMP/WAMP select no. If you are unsure of this, ask your Quartz administrator.
Please do not leave any field blank, the form is not prepared to handle that situation and will give an error. In the case of that situation, or any such issue, simply come back to this page and fill out this form again.
If for some reason you must re-fill the form, you must fill out the entire form again, not just the part you wish to change.
If you are an admin, you are able to use Quartz right after the installation. Simply use your BU email and the password you provided.
If you are a professor, you still have to apply for a new account to use Quartz after the installation process. There will be more instructions after the form as been submitted correctly.


from EasyFileHandling.main import FileHandler
Returns: bool
Description: As name itself describes it, it returns True if file exists and returns False if file doesn't exists.
Returns: str
Description:Returns all content in file
Returns: Union[str, int]
Description: Returns number of lines in the file
Returns: str
Description: Returns longest line length and line indices of lines with that length
Returns:None
DescriptionChanges whole file content
Returns: None
Description: Appends content to end of the file!
Returns: str
Description: Tells you what type of file is it.
Returns: str
Description: Changes file extension
Returns: bool
Description: Tells you if file is writeable
from EasyFileHandling.jsonHandler import JsonHandler
Returns: None
Description: Writes to json file
Returns: None
Description: Appends to json file
Returns: Union[dict, list]
Description: Reads the the JSON file and returns that data in python data structures
Returns: None
Description: Changes file name
Returns: Union[str, bool, None]
Description: Creates a file
Returns: Union[str, None]
Description: Deletes file
Returns: list
Description: Gives a list of all items in the folder
Returns: list
Description: Deletes all items in the folder
Returns: bool
Description: Returns True if file extension is py and if not then false.
from EasyFileHandling.imagehandler import ImageHandler
Returns: None
Description: Applies filters on the image
Options: 'blur', 'contour', 'detail', 'edge_enhance', 'emboss', 'edge_enhance_more', 'find_edges', 'sharpen', 'smooth', 'smooth_more'
Returns: None
Description: Adds text onto the image


Rumour Has It: Clubs hover around disgruntled Dortmund star Sancho
by BeSoccerReports suggest England winger Jadon Sancho could be on his way out of Borussia Dortmund, where he feels "humiliated and scapegoated".
The battle for Jadon Sancho's signature looks set to begin.
Four high-profile clubs in England and Spain are reportedly monitoring the teenager, one of Europe's brightest prospects.
Aggrieved with recent events at Borussia Dortmund, Sancho could now seek a new home for next season.
TOP STORY – CLUBS QUEUE UP FOR 'SCAPEGOAT' SANCHO
Barcelona, Liverpool, Manchester United and Real Madrid are the "leading quartet" of suitors for Borussia Dortmund star Jadon Sancho, according to The Athletic.
Former club Manchester City have also asked to be "kept informed" following a string of events that have upset the 19-year-old England winger, notably his first-half substitution in the 4-0 Klassiker loss to Bayern Munich earlier this month.
Featured links
- Neymar or Mbappé? Zidane choose
- The latest football transfers news and rumours
- What Cristiano said about Messi to his Man Utd teammates
- Kante explains why he turned down PSG
Sancho's representatives are said to have deemed that move "disgraceful", paving the way for his Dortmund departure at the end of the Bundesliga season.
ROUND-UP
- Paul Pogba's prolonged absence for Manchester United is part of a concerted effort to force through a January transfer to LaLiga giants Madrid, claims Spanish journalist Paco Gonzalez. Pogba, not sighted since September, is recovering from an ankle injury.
- According to Calciomercato, Zlatan Ibrahimovic is weighing up a move to AC Milan. The 38-year-old is available on a free transfer after leaving MLS outfit LA Galaxy. Ibrahimovic has been linked to Bologna, Tottenham, Napoli and Perth Glory.
- West Ham are considering replacing Manuel Pellegrini with Chris Wilder, reports The Mirror. The Hammers are languishing 16th in the Premier League after 13 games, while Wilder's Sheffield United are riding high in sixth. Chris Hughton, David Moyes and Rafael Benitez are reportedly among the other candidates should West Ham lose patience with Pellegrini.
- Wolves defender Owen Otasowie is wanted by Ligue 1 champions Paris Saint-Germain and Bundesliga team Schalke, reports The Sun. 18-year-old centre-back has also been watched by Liverpool and Arsenal.
- The Mirror reports Aston Villa are leading the race to sign Rhian Brewster on loan in January. Brewster, 19, has been unable to break his way into Liverpool's Premier League plans this term. The report states Villa face competition from Crystal Palace, Leeds United and Swansea City.


Autogyro
Manually adjust your device orientation; no gyroscope or fumbling necessary.
Download Autogyro
0.1.0
Works on Android 5.0 (Lollipop) and up.


GovernanceRoleAssignmentRequest extends Entity
GovernanceRoleAssignmentRequest class
Tags
Table of Contents
- $_propDict : array<string|int, mixed>
- The array of properties available to the model
- __construct() : mixed
- Construct a new Entity
- getAssignmentState() : string|null
- Gets the assignmentState Required. The state of the assignment. The possible values are: Eligible (for eligible assignment), Active (if it is directly assigned), Active (by administrators, or activated on an eligible assignment by the users).
- getId() : string|null
- Gets the id Read-only.
- getLinkedEligibleRoleAssignmentId() : string|null
- Gets the linkedEligibleRoleAssignmentId If this is a request for role activation, it represents the id of the eligible assignment being referred; Otherwise, the value is null.
- getODataType() : string|null
- Gets the ODataType
- getProperties() : array<string|int, mixed>
- Gets the property dictionary of the Entity
- getReason() : string|null
- Gets the reason A message provided by users and administrators when create the request about why it is needed.
- getRequestedDateTime() : DateTime|null
- Gets the requestedDateTime Read-only. The request create time. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
- getResource() : GovernanceResource|null
- Gets the resource Read-only. The resource that the request aims to.
- getResourceId() : string|null
- Gets the resourceId Required. The id of the resource which the role assignment request is associated with.
- getRoleDefinition() : GovernanceRoleDefinition|null
- Gets the roleDefinition Read-only. The role definition that the request aims to.
- getRoleDefinitionId() : string|null
- Gets the roleDefinitionId Required. The id of the role definition which the role assignment request is associated with.
- getSchedule() : GovernanceSchedule|null
- Gets the schedule The schedule object of the role assignment request.
- getStatus() : GovernanceRoleAssignmentRequestStatus|null
- Gets the status The status of the role assignment request.
- getSubject() : GovernanceSubject|null
- Gets the subject Read-only. The user/group principal.
- getSubjectId() : string|null
- Gets the subjectId Required. The id of the subject which the role assignment request is associated with.
- getType() : string|null
- Gets the type Required. Representing the type of the operation on the role assignment. The possible values are: AdminAdd , UserAdd , AdminUpdate , AdminRemove , UserRemove , UserExtend , AdminExtend , UserRenew , AdminRenew.
- jsonSerialize() : array<string|int, mixed>
- Serializes the object by property array Manually serialize DateTime into RFC3339 format
- setAssignmentState() : GovernanceRoleAssignmentRequest
- Sets the assignmentState Required. The state of the assignment. The possible values are: Eligible (for eligible assignment), Active (if it is directly assigned), Active (by administrators, or activated on an eligible assignment by the users).
- setId() : Entity
- Sets the id Read-only.
- setLinkedEligibleRoleAssignmentId() : GovernanceRoleAssignmentRequest
- Sets the linkedEligibleRoleAssignmentId If this is a request for role activation, it represents the id of the eligible assignment being referred; Otherwise, the value is null.
- setODataType() : Entity
- Sets the ODataType
- setReason() : GovernanceRoleAssignmentRequest
- Sets the reason A message provided by users and administrators when create the request about why it is needed.
- setRequestedDateTime() : GovernanceRoleAssignmentRequest
- Sets the requestedDateTime Read-only. The request create time. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
- setResource() : GovernanceRoleAssignmentRequest
- Sets the resource Read-only. The resource that the request aims to.
- setResourceId() : GovernanceRoleAssignmentRequest
- Sets the resourceId Required. The id of the resource which the role assignment request is associated with.
- setRoleDefinition() : GovernanceRoleAssignmentRequest
- Sets the roleDefinition Read-only. The role definition that the request aims to.
- setRoleDefinitionId() : GovernanceRoleAssignmentRequest
- Sets the roleDefinitionId Required. The id of the role definition which the role assignment request is associated with.
- setSchedule() : GovernanceRoleAssignmentRequest
- Sets the schedule The schedule object of the role assignment request.
- setStatus() : GovernanceRoleAssignmentRequest
- Sets the status The status of the role assignment request.
- setSubject() : GovernanceRoleAssignmentRequest
- Sets the subject Read-only. The user/group principal.
- setSubjectId() : GovernanceRoleAssignmentRequest
- Sets the subjectId Required. The id of the subject which the role assignment request is associated with.
- setType() : GovernanceRoleAssignmentRequest
- Sets the type Required. Representing the type of the operation on the role assignment. The possible values are: AdminAdd , UserAdd , AdminUpdate , AdminRemove , UserRemove , UserExtend , AdminExtend , UserRenew , AdminRenew.
Properties
$_propDict
The array of properties available to the model
protected
array<string|int, mixed>
$_propDict
Methods
__construct()
Construct a new Entity
public
__construct([array<string|int, mixed> $propDict = array() ]) : mixed
Parameters
- $propDict : array<string|int, mixed> = array()
-
A list of properties to set
Return values
mixed —getAssignmentState()
Gets the assignmentState Required. The state of the assignment. The possible values are: Eligible (for eligible assignment), Active (if it is directly assigned), Active (by administrators, or activated on an eligible assignment by the users).
public
getAssignmentState() : string|null
Return values
string|null —The assignmentState
getId()
Gets the id Read-only.
public
getId() : string|null
Return values
string|null —The id
getLinkedEligibleRoleAssignmentId()
Gets the linkedEligibleRoleAssignmentId If this is a request for role activation, it represents the id of the eligible assignment being referred; Otherwise, the value is null.
public
getLinkedEligibleRoleAssignmentId() : string|null
Return values
string|null —The linkedEligibleRoleAssignmentId
getODataType()
Gets the ODataType
public
getODataType() : string|null
Return values
string|null —The ODataType
getProperties()
Gets the property dictionary of the Entity
public
getProperties() : array<string|int, mixed>
Return values
array<string|int, mixed> —The list of properties
getReason()
Gets the reason A message provided by users and administrators when create the request about why it is needed.
public
getReason() : string|null
Return values
string|null —The reason
getRequestedDateTime()
Gets the requestedDateTime Read-only. The request create time. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
public
getRequestedDateTime() : DateTime|null
Return values
DateTime|null —The requestedDateTime
getResource()
Gets the resource Read-only. The resource that the request aims to.
public
getResource() : GovernanceResource|null
Return values
GovernanceResource|null —The resource
getResourceId()
Gets the resourceId Required. The id of the resource which the role assignment request is associated with.
public
getResourceId() : string|null
Return values
string|null —The resourceId
getRoleDefinition()
Gets the roleDefinition Read-only. The role definition that the request aims to.
public
getRoleDefinition() : GovernanceRoleDefinition|null
Return values
GovernanceRoleDefinition|null —The roleDefinition
getRoleDefinitionId()
Gets the roleDefinitionId Required. The id of the role definition which the role assignment request is associated with.
public
getRoleDefinitionId() : string|null
Return values
string|null —The roleDefinitionId
getSchedule()
Gets the schedule The schedule object of the role assignment request.
public
getSchedule() : GovernanceSchedule|null
Return values
GovernanceSchedule|null —The schedule
getStatus()
Gets the status The status of the role assignment request.
public
getStatus() : GovernanceRoleAssignmentRequestStatus|null
Return values
GovernanceRoleAssignmentRequestStatus|null —The status
getSubject()
Gets the subject Read-only. The user/group principal.
public
getSubject() : GovernanceSubject|null
Return values
GovernanceSubject|null —The subject
getSubjectId()
Gets the subjectId Required. The id of the subject which the role assignment request is associated with.
public
getSubjectId() : string|null
Return values
string|null —The subjectId
getType()
Gets the type Required. Representing the type of the operation on the role assignment. The possible values are: AdminAdd , UserAdd , AdminUpdate , AdminRemove , UserRemove , UserExtend , AdminExtend , UserRenew , AdminRenew.
public
getType() : string|null
Return values
string|null —The type
jsonSerialize()
Serializes the object by property array Manually serialize DateTime into RFC3339 format
public
jsonSerialize() : array<string|int, mixed>
Return values
array<string|int, mixed> —The list of properties
setAssignmentState()
Sets the assignmentState Required. The state of the assignment. The possible values are: Eligible (for eligible assignment), Active (if it is directly assigned), Active (by administrators, or activated on an eligible assignment by the users).
public
setAssignmentState(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The assignmentState
Return values
GovernanceRoleAssignmentRequest —setId()
Sets the id Read-only.
public
setId(string $val) : Entity
Parameters
- $val : string
-
The id
Return values
Entity —setLinkedEligibleRoleAssignmentId()
Sets the linkedEligibleRoleAssignmentId If this is a request for role activation, it represents the id of the eligible assignment being referred; Otherwise, the value is null.
public
setLinkedEligibleRoleAssignmentId(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The linkedEligibleRoleAssignmentId
Return values
GovernanceRoleAssignmentRequest —setODataType()
Sets the ODataType
public
setODataType(string $val) : Entity
Parameters
- $val : string
-
The ODataType
Return values
Entity —setReason()
Sets the reason A message provided by users and administrators when create the request about why it is needed.
public
setReason(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The reason
Return values
GovernanceRoleAssignmentRequest —setRequestedDateTime()
Sets the requestedDateTime Read-only. The request create time. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
public
setRequestedDateTime(DateTime $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : DateTime
-
The requestedDateTime
Return values
GovernanceRoleAssignmentRequest —setResource()
Sets the resource Read-only. The resource that the request aims to.
public
setResource(GovernanceResource $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : GovernanceResource
-
The resource
Return values
GovernanceRoleAssignmentRequest —setResourceId()
Sets the resourceId Required. The id of the resource which the role assignment request is associated with.
public
setResourceId(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The resourceId
Return values
GovernanceRoleAssignmentRequest —setRoleDefinition()
Sets the roleDefinition Read-only. The role definition that the request aims to.
public
setRoleDefinition(GovernanceRoleDefinition $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : GovernanceRoleDefinition
-
The roleDefinition
Return values
GovernanceRoleAssignmentRequest —setRoleDefinitionId()
Sets the roleDefinitionId Required. The id of the role definition which the role assignment request is associated with.
public
setRoleDefinitionId(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The roleDefinitionId
Return values
GovernanceRoleAssignmentRequest —setSchedule()
Sets the schedule The schedule object of the role assignment request.
public
setSchedule(GovernanceSchedule $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : GovernanceSchedule
-
The schedule
Return values
GovernanceRoleAssignmentRequest —setStatus()
Sets the status The status of the role assignment request.
public
setStatus(GovernanceRoleAssignmentRequestStatus $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : GovernanceRoleAssignmentRequestStatus
-
The status
Return values
GovernanceRoleAssignmentRequest —setSubject()
Sets the subject Read-only. The user/group principal.
public
setSubject(GovernanceSubject $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : GovernanceSubject
-
The subject
Return values
GovernanceRoleAssignmentRequest —setSubjectId()
Sets the subjectId Required. The id of the subject which the role assignment request is associated with.
public
setSubjectId(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The subjectId
Return values
GovernanceRoleAssignmentRequest —setType()
Sets the type Required. Representing the type of the operation on the role assignment. The possible values are: AdminAdd , UserAdd , AdminUpdate , AdminRemove , UserRemove , UserExtend , AdminExtend , UserRenew , AdminRenew.
public
setType(string $val) : GovernanceRoleAssignmentRequest
Parameters
- $val : string
-
The type


You understand 1 or 2 of these frameworks and want to know about the other(s).
You just really wanted some reddit stickers.
You have come to the right workshop!
This workshop depends on audience participation.
I've done some work in all these. However, these are all large, robust, and mature frameworks. If you know a better pattern to share, let's stop and talk about it.
That said, let's not get semantic. This workshop is really to communicate the look and feel of working in these frameworks, not every nut and bolt.
Unsolicited Opinions
Why Backbone?
Dead simple to interact with with RESTful APIs on a model level.
Offers great way to organize JavaScript code. Gets out of your way after that.
Barebones. Piece together your own client-side tech stack.
Works great for large applications.
Why AngularJS / EmberJS?
These largely scratch the itch.
Perfect use case for these is rapid prototyping.
Also do fairly well in small-to-medium size products.
Some interesting idiosyncrasies become evident at large scales.
 They both have areas of churn in different places.
AngularJS
The power of the directive. Directives are an extremely powerful way to influence the DOM in a declarative fashion.
The ease of the POJO (plain ol' JavaScript object.) This makes Angular both easier to pick up and easier to apply your already awesome JS skills to it.
While monolithic at present, AngularJS is being decomposed into a more modular fashion, making it easier to piece together and improve on. Like how awesome the Angular-UI router is.
EmberJS
Computed properties are awesome. Binding together models in your code makes some really cool possibilities.
Opinion: EmberJS has fewer weird gotchas than AngularJS. I think this comes from having control over their objects.
Though I believe Ember's barrier to entry to is higher, I think the router is much easier to get used to. The Ember router is awesome.
Ember's docs are better.
There's tons of great things about these frameworks that we didn't talk about. Core features even.
Cool things not addressed here.
Backbone
Mentioned a bit, but interacting with APIs once you have your models up and going is really easy.
We did this workshop with pretty vanilla Backbone. There are a ton of awesome libraries to go along with Backbone. Marionette is a personal favorite of mine as it makes a lot of these common design patterns in Backbone dead simple and takes away a lot of the boilerplate.
Backbone seems like a lot of code, but once you get your core models and views together, it becomes a very productive framework to work in.
Ember
Computed. Properties. You can set up properties that become are dependent on other properties. Like if you have a rectangle and you have an area property. You can make that a computed property that depends on the length and height.
Ember is a framework as opposed to the toolset that Angular confesses to be. The difference is subtle but is evident in their design patterns. You use Angular to build a framework for your app. Ember is the framework.
Everyone says Angular directives are amazing (they are) but most things can largely accomplished in Ember's views.
Angular
Okay. Directives are really, really cool. Think of them as decorators for HTML elements that you can mix and match. A directive can be as simple as adding two-way data-binding for a CSS property all the way to being a fully-functional web component(-esque) element.
Filters! Filters allow you filter input before you display it. If you wanted to not show some of your todos based on if it didn't have any letter 'V' in the title, it'd be simple to write a filter for that. Or automatically take display format currency or time.
Custom services. You saw scope, but you can write your own dependency injected services. Things that you find yourself doing a lot can easily be abstracted into a service, tested, and reused. I made one for a essentially a local version of memcache using localStorage. Really simple to do using services.


The following languages are currently included in the scope of the Storybooks Bangladesh project:
Please note that some translations and recordings are not yet complete.
We are always looking for translators! If you speak one of the above languages and would like to help us translate or record stories, please contact us at globalafricanstorybook [at] gmail [dot] com


Brand
Who I am
(current)
About
Contact
Dropdown
Action
Another action
Something else here
Search
Click success!
×
Open


A representative sample of the functions are benchmarked here, to provide
a sense of how fast they might run in different browsers.
Each iteration runs on an array of 1000 elements.
For example, the 'intersect' test measures the number of times you can
find the intersection of two thousand-element arrays in one second.


Delegated {{ record.right_name }} ({{ record.right_id }}) access is being given to the outlook mailbox {{ record.accessee.display_name }} ({{ record.accessee.netid }}).
You've been identified as an admin of the group {{ record.accessor.display_name }} ({{ record.accessor.name }})!
You all are receiving this email because your list members are getting delegated access to the above mailbox.
Admin emails of group given delegated access:
{% else %}You are receiving this email because you were given delegated access to the above mailbox.
Delegated netid email address:
{% endif %}


This is our first post This is our first postThis is our first postThis is our first postThis is our first post
This is our first post This is our first postThis is our first postThis is our first postThis is our first post
This is our first post This is our first postThis is our first postThis is our first postThis is our first post