| Internet Engineering Task Force | A. Wright, Ed. |
| Internet-Draft | October 13, 2016 |
| Intended status: Informational | |
| Expires: April 16, 2017 |
JSON Schema: A Media Type for Describing JSON Documents
draft-wright-json-schema-00
JSON Schema defines the media type "application/schema+json", a JSON based format for describing the structure of JSON data. JSON Schema asserts what a JSON document must look like, ways to extract information from it, and how to interact with it, ideal for annotating existing JSON APIs that would not otherwise have hypermedia controls or be machine-readable.
The issues list for this draft can be found at <https://github.com/json-schema-org/json-schema-spec/issues>.
For additional information, see <http://json-schema.org/>.
To provide feedback, use this issue tracker, the communication methods listed on the homepage, or email the document editors.
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at http://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."
This Internet-Draft will expire on April 16, 2017.
Copyright (c) 2016 IETF Trust and the persons identified as the document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Simplified BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Simplified BSD License.
JSON Schema is a JSON media type for defining the structure of JSON data. JSON Schema is intended to define validation, documentation, hyperlink navigation, and interaction control of JSON data.
This specification defines JSON Schema core terminology and mechanisms, including pointing to another JSON Schema by reference, dereferencing a JSON Schema reference, specifying the vocabulary being used, and declaring the minimum functionality necessary for processing an instance against a schema.
Other specifications define the vocabularies that perform assertions about validation, linking, annotation, navigation, and interaction.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 [RFC2119].
The terms "JSON", "JSON text", "JSON value", "member", "element", "object", "array", "number", "string", "boolean", "true", "false", and "null" in this document are to be interpreted as defined in RFC 7159 [RFC7159].
This document proposes a new media type "application/schema+json" to identify JSON Schema for describing JSON data. JSON Schemas are themselves written in JSON. This, and related specifications, define keywords allowing to describe this data in terms of allowable values, textual descriptions and interpreting relations with other resources. The following sections are a summary of features defined by related specifications.
JSON Schema describes the structure of a JSON document (for instance, required properties and length limitations). Applications can use this information to validate instances (check that constraints are met), or inform interfaces to collect user input such that the constraints are satisfied.
Validation behaviour and keywords are specified in a separate document [json-schema-validation].
JSON Hyper-Schema describes the hypertext structure of a JSON document. This includes link relations from the instance to other resources, interpretation of instances as multimedia data, and submission data required to use an API.
Hyper-schema behaviour and keywords are specified in a separate document [json-hyper-schema].
A JSON document is an information resource (series of octets) described by the application/json media type.
In JSON Schema, the terms "JSON document", "JSON text", and "JSON value" are interchangable because of the data model it defines.
JSON Schema interperts documents according to a data model. A JSON value interperted according to this data model is called an "instance".
An instance has one of six primitive types, and a range of possible values depending on the type:
Whitespace and formatting conserns are thus outside the scope of JSON Schema.
Since an object cannot have two properties with the same key, behavior for a JSON document that tries to define two properties (the "member" production) with the same key (the "string" production) in a single object is undefined.
Two JSON instances are said to be equal if and only if they are of the same type and have the same value according to the data model. Specifically, this means:
Implied in this definition is that arrays must be the same length, objects must have the same number of members, properties in objects are unordered, there is no way to define multiple properties with the same key, and mere formatting differences (indentation, placement of commas, trailing zeros) are insignificant.
A JSON Schema document, or simply a schema, is a JSON document used to describe an instance. A schema is itself interperted as an instance. A JSON schema MUST be an object.
Properties that are used to describe the instance are called keywords, or schema keywords. The meaning of properties is specified by the vocabulary that the schema is using.
A JSON Schema MAY contain properties which are not schema keywords. Unknown keywords SHOULD be ignored.
A schema that itself describes a schema is called a meta-schema. Meta-schemas are used to validate JSON Schemas and specify which vocabulary it is using.
An empty schema is a JSON Schema with no properties, or only unknown properties.
The root schema is the schema that comprises the entire JSON document in question.
Some keywords take schemas themselves, allowing JSON Schemas to be nested:
{ "title": "root", "items": { "title": "array item" } }
In this example document, the schema titled "array item" is a subschema, and the schema titled "root" is the root schema.
An instance may be any valid JSON value as defined by JSON [RFC7159]. JSON Schema imposes no restrictions on type: JSON Schema can describe any JSON value, including, for example, null.
JSON Schema is programming language agnostic, and supports the full range of values described in the data model. Be aware, however, that some languages and JSON parsers may not be able to represent in memory the full range of values describable by JSON.
Some programming languages and parsers use different internal representations for floating point numbers than they do for integers.
For constistency, integer JSON numbers SHOULD NOT be encoded with a fractional part.
Implementations MAY define additional keywords to JSON Schema. Save for explicit agreement, schema authors SHALL NOT expect these additional keywords to be supported by peer implementations. Implementations SHOULD ignore keywords they do not support.
Authors of extensions to JSON Schema are encouraged to write their own meta-schemas, which extend the existing meta-schemas using "allOf". This extended meta-schema SHOULD be referenced using the "$schema" keyword, to allow tools to follow the correct behaviour.
The "$schema" keyword is both used as a JSON Schema version identifier and the location of a resource which is itself a JSON Schema, which describes any schema written for this particular version.
The root schema of a JSON Schema document SHOULD use this keyword. The value of this keyword MUST be a URI [RFC3986] (an "absolute" URI), and this URI MUST be normalized. The current schema MUST be valid against the meta-schema identified by this URI.
Values for this property are defined in other documents and by other parties. JSON Schema implementations SHOULD implement support for current and previous published drafts of JSON Schema vocabularies as deemed reasonable.
Any time a subschema is expected, a schema may instead use an object containing a "$ref" property. The value of the $ref is a URI Reference. Resolved against the current URI base, it identifies the URI of a schema to use. All other properties in a "$ref" object MUST be ignored.
The URI is not a network locator, only an identifier. A schema need not be downloadable from the address if it is a network-addressible URL, and implementations SHOULD NOT assume they should perform a network operation when they encounter a network-addressible URI.
A schema MUST NOT be run into an infinite loop against a schema. For example, if two schemas "#alice" and "#bob" both have an "allOf" property that refers to the other, a naive validator might get stuck in an infinite recursive loop trying to validate the instance. Schemas SHOULD NOT make use of infinite recursive nesting like this, the behavior is undefined.
RFC3986 Section 5.1 [RFC3986] defines how to determine the default base URI of a document.
Informatively, the initial base URI of a schema is the URI it was found at, or a suitable substitute URI if none is known.
The "id" keyword defines a URI for the schema, and the base URI that other URI references within the schema are resolved against. The "id" keyword itself is resolved against the base URI that the object as a whole appears in.
If present, the value for this keyword MUST be a string, and MUST represent a valid URI-reference [RFC3986]. This value SHOULD be normalized, and SHOULD NOT be an empty fragment <#> or an empty string <>.
The root schema of a JSON Schema document SHOULD contain an "id" keyword with an absolute-URI (containing a scheme, but no fragment).
To name subschemas in a JSON Schema document, subschemas can use "id" to give themselves a document-local identifier. This form of "id" keyword MUST begin with a hash ("#") to identify it as a fragment URI reference, followed by a letter ([A-Za-z]), followed by any number of letters, digits ([0-9]), hyphens ("-"), underscores ("_"), colons (":"), or periods (".").
{ "id": "http://example.com/root.json", "definitions": { "A": { "id": "#foo" }, "B": { "id": "other.json", "definitions": { "X": { "id": "#bar" }, "Y": { "id": "t/inner.json" } } }, "C": { "id": "urn:uuid:ee564b8a-7a87-4125-8c96-e9f123d6766f" } } }
For example:
The schemas at the following URI-encoded JSON Pointers [RFC6901] (relative to the root schema) have the following base URIs, and are identifiable by either URI:
Schemas can be identified by any URI that has been given to them, including a JSON Pointer or their URI given directly by "id".
Tools SHOULD take note of the URIs that schemas, including subschemas, provide for themselves using "id". This is known as "Internal referencing".
For example, consider this schema:
{ "id": "http://example.net/root.json", "items": { "type": "array", "items": { "$ref": "#item" } }, "definitions": { "single": { "id": "#item", "type": "integer" }, } }
When an implementation encounters the <#/definitions/single> schema, it resolves the "id" URI reference against the current base URI to form <http://example.net/root.json#item>.
When an implementation then looks inside the <#/items> schema, it encounters the <#item> reference, and resolves this to <http://example.net/root.json#item> which is understood as the schema defined elsewhere in the same document.
To differentiate schemas between each other in a vast ecosystem, schemas are identified by URI. As specified above, this does not necessarially mean anything is downloaded, but instead JSON Schema implementations SHOULD already understand the schemas they will be using, including the URIs that identify them.
Implementations SHOULD be able to associate arbritrary URIs with an arbritrary schema and/or automatically associate a schema's "id"-given URI, depending on the trust that the the validator has in the schema.
A schema MAY (and likely will) have multiple URIs, but there is no way for a URI to identify more than one schema. When multiple schemas try to identify with the same URI, validators SHOULD raise an error condition.
One of the largest adoptors of JSON has been HTTP servers for automated APIs and robots. This section describes how to enhance processing of JSON documents in a more RESTful manner when used with protocols that support media types and Web linking [RFC5988].
It is RECOMMENDED that instances described by a schema/profile provide a link to a downloadable JSON Schema using the link relation "describedby", as defined by Linked Data Protocol 1.0, section 8.1 [W3C.REC-ldp-20150226].
In HTTP, such links can be attached to any response using the Link header [RFC5988]. An example of such a header would be:
Link: <http://example.com/my-hyper-schema#>; rel="describedby"
Instances MAY specify a "profile" as described in The 'profile' Link Relation [RFC6906]. When used as a media-type parameter, HTTP servers gain the ability to perform Content-Type Negotiation based on profile. The media-type parameter MUST be a whitespace-separated list of URIs (i.e. relative references are invalid).
The profile URI is opaque and SHOULD NOT automatically be dereferenced. If the implementation does not understand the semantics of the provided profile, the implementation can instead follow the "describedby" links, if any, which may provide information on how to handle the profile. Since "profile" doesn't necessarily point to a network location, the "describedby" relation is used for linking to a downloadable schema. However, for simplicity, schema authors should make these URIs point to the same resource when possible.
In HTTP, the media-type parameter would be sent inside the Content-Type header:
Content-Type: application/json; profile="http://example.com/my-hyper-schema#"
Multiple profiles are whitespace seperated:
Content-Type: application/json; profile="http://example.com/alice http://example.com/bob"
HTTP can also send the "profile" in a Link, though this may impact media-type semantics and Content-Type negotiation if this replaces the media-type parameter entirely:
Link: </alice>;rel="profile", </bob>;rel="profile"
When used for hypermedia systems over a network, HTTP [RFC7231] is frequently the protocol of choice for distributing schemas. Misbehaved clients can pose problems for server maintainers if they pull a schema over the network more frequently than necessary, when it's instead possible to cache a schema for a long period of time.
HTTP servers SHOULD set long-lived caching headers on JSON Schemas. HTTP clients SHOULD observe caching headers and not re-request documents within their freshness period. Distributed systems SHOULD make use of a shared cache and/or caching proxy.
User-Agent: so-cool-json-schema/1.0.2 curl/7.43.0
Clients SHOULD set or prepend a User-Agent header specific to the JSON Schema implementation or software product. Since symbols are listed in decreasing order of significance, the JSON Schema library name/version goes first, then the more generic HTTP library name (if any). For example:
Clients SHOULD be able to make requests with a "From" header so that server operators can contact the owner of a potentially misbehaving script.
Both schemas and instances are JSON values. As such, all security considerations defined in RFC 7159 [RFC7159] apply.
Instances and schemas are both frequently witten by untrusted third parties, to be deployed on public Internet servers. Validators should take care that the parsing of schemas doesn't consume excessive system resources. Validators MUST NOT fall into an infinite loop.
Servers need to take care that malicious parties can't change the functionality of existing schemas by uploading a schema with an pre-existing or very similar "id".
Individual JSON Schema vocabularies are liable to also have their own security considerations. Consult the respective specifications for more information.
The proposed MIME media type for JSON Schema is defined as follows:
| [RFC2119] | Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997. |
| [RFC3986] | Berners-Lee, T., Fielding, R. and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, DOI 10.17487/RFC3986, January 2005. |
| [RFC7159] | Bray, T., "The JavaScript Object Notation (JSON) Data Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March 2014. |
| [W3C.REC-ldp-20150226] | Speicher, S., Arwe, J. and A. Malhotra, "Linked Data Platform 1.0", World Wide Web Consortium Recommendation REC-ldp-20150226, February 2015. |
| [RFC5988] | Nottingham, M., "Web Linking", RFC 5988, DOI 10.17487/RFC5988, October 2010. |
| [RFC6901] | Bryan, P., Zyp, K. and M. Nottingham, "JavaScript Object Notation (JSON) Pointer", RFC 6901, DOI 10.17487/RFC6901, April 2013. |
| [RFC6906] | Wilde, E., "The 'profile' Link Relation Type", RFC 6906, DOI 10.17487/RFC6906, March 2013. |
| [RFC7231] | Fielding, R. and J. Reschke, "Hypertext Transfer Protocol (HTTP/1.1): Semantics and Content", RFC 7231, DOI 10.17487/RFC7231, June 2014. |
| [json-schema-validation] | Wright, A. and G. Luff, "JSON Schema Validation: A Vocabulary for Structural Validation of JSON", Internet-Draft draft-wright-json-schema-validation-00, October 2016. |
| [json-hyper-schema] | Wright, A. and G. Luff, "JSON Hyper-Schema: A Vocabulary for Hypermedia Annotation of JSON", Internet-Draft draft-wright-json-schema-hyperschema-00, October 2016. |
Thanks to Gary Court, Francis Galiegue, Kris Zyp, and Geraint Luff for their work on the initial drafts of JSON Schema.
Thanks to Jason Desrosiers, Daniel Perrett, Erik Wilde, Ben Hutton, Evgeny Poberezkin, and Henry H. Andrews for their submissions and patches to the document.
[CREF1]This section to be removed before leaving Internet-Draft status.


public interface HttpFilters
Interface for objects that filter HttpObject
s, including both
requests and responses, and informs of different steps in request/response.
Multiple methods are defined, corresponding to different steps in the request processing lifecycle. Some of these methods is given the current object (request, response or chunk) and is allowed to modify it in place. Others provide a notification of when specific operations happen (i.e. connection in queue, DNS resolution, SSL handshaking and so forth).
Because HTTP transfers can be chunked, for any given request or response, the
filter methods that can modify request/response in place may be called
multiple times, once for the initial HttpRequest
or
HttpResponse
, and once for each subsequent HttpContent
. The
last chunk will always be a LastHttpContent
and can be checked for
being last using ProxyUtils.isLastChunk(HttpObject)
.
HttpFiltersSource.getMaximumRequestBufferSizeInBytes()
and
HttpFiltersSource.getMaximumResponseBufferSizeInBytes()
can be used
to instruct the proxy to buffer the HttpObject
s sent to all of its
request/response filters, in which case it will buffer up to the specified
limit and then send either complete HttpRequest
s or
HttpResponse
s to the filter methods. When buffering, if the proxy
receives more data than fits in the specified maximum bytes to buffer, the
proxy will stop processing the request and respond with a 502 Bad Gateway
error.
A new instance of HttpFilters
is created for each request, so these
objects can be stateful.
To monitor (and time measure?) the different steps the request/response goes through, many informative methods are provided. Those steps are reported in the following order:
| Modifier and Type | Method and Description |
|---|---|
io.netty.handler.codec.http.HttpResponse |
clientToProxyRequest(io.netty.handler.codec.http.HttpObject httpObject)
Filters requests on their way from the client to the proxy.
|
io.netty.handler.codec.http.HttpObject |
proxyToClientResponse(io.netty.handler.codec.http.HttpObject httpObject)
Filters responses on their way from the proxy to the client.
|
void |
proxyToServerConnectionFailed()
Informs filter that proxy to server connection has failed.
|
void |
proxyToServerConnectionQueued()
Informs filter that proxy to server connection is in queue.
|
void |
proxyToServerConnectionSSLHandshakeStarted()
Informs filter that proxy to server ssl handshake is initiating.
|
void |
proxyToServerConnectionStarted()
Informs filter that proxy to server connection is initiating.
|
void |
proxyToServerConnectionSucceeded()
Informs filter that proxy to server connection has succeeded.
|
io.netty.handler.codec.http.HttpResponse |
proxyToServerRequest(io.netty.handler.codec.http.HttpObject httpObject)
Filters requests on their way from the proxy to the server.
|
void |
proxyToServerRequestSending()
Informs filter that proxy to server request is being sent.
|
void |
proxyToServerRequestSent()
Informs filter that proxy to server request has been sent.
|
java.net.InetSocketAddress |
proxyToServerResolutionStarted(java.lang.String resolvingServerHostAndPort)
Filter DNS resolution from proxy to server.
|
void |
proxyToServerResolutionSucceeded(java.lang.String serverHostAndPort,
java.net.InetSocketAddress resolvedRemoteAddress)
Informs filter that proxy to server DNS resolution has happened.
|
io.netty.handler.codec.http.HttpObject |
serverToProxyResponse(io.netty.handler.codec.http.HttpObject httpObject)
Filters responses on their way from the server to the proxy.
|
void |
serverToProxyResponseReceived()
Informs filter that server to proxy response has been received.
|
void |
serverToProxyResponseReceiving()
Informs filter that server to proxy response is being received.
|
io.netty.handler.codec.http.HttpResponse clientToProxyRequest(io.netty.handler.codec.http.HttpObject httpObject)
httpObject
- Client to Proxy HttpRequest (and HttpContent, if chunked)io.netty.handler.codec.http.HttpResponse proxyToServerRequest(io.netty.handler.codec.http.HttpObject httpObject)
httpObject
- Proxy to Server HttpRequest (and HttpContent, if chunked)void proxyToServerRequestSending()
void proxyToServerRequestSent()
io.netty.handler.codec.http.HttpObject serverToProxyResponse(io.netty.handler.codec.http.HttpObject httpObject)
httpObject
- Server to Proxy HttpResponse (and HttpContent, if chunked)void serverToProxyResponseReceiving()
void serverToProxyResponseReceived()
io.netty.handler.codec.http.HttpObject proxyToClientResponse(io.netty.handler.codec.http.HttpObject httpObject)
httpObject
- Proxy to Client HttpResponse (and HttpContent, if chunked)void proxyToServerConnectionQueued()
java.net.InetSocketAddress proxyToServerResolutionStarted(java.lang.String resolvingServerHostAndPort)
resolvingServerHostAndPort
- Server "HOST:PORT"void proxyToServerResolutionSucceeded(java.lang.String serverHostAndPort, java.net.InetSocketAddress resolvedRemoteAddress)
serverHostAndPort
- Server "HOST:PORT"resolvedRemoteAddress
- Address it was proxyToServerResolutionSucceeded tovoid proxyToServerConnectionStarted()
void proxyToServerConnectionSSLHandshakeStarted()
void proxyToServerConnectionFailed()
void proxyToServerConnectionSucceeded()


This package contains functions to fit the filtering model of Forcheh et al., (2012) which is used to derive the intra-cluster correlation (ICC). Model fitting is done using the modified version of the “MLM.beadarray" function of Kim and Lin (2011).
| Version: | 1.1.0 |
| Depends: | beadarray, RColorBrewer |
| Suggests: | beadarrayExampleData, lumi |
| Published: | 2013-02-07 |
| Author: | Anyiawung Chiara Forcheh, Geert Verbeke, Adetayo Kasim, Dan Lin, Ziv Shkedy, Willem Talloen, Hinrich WH Gohlmann, Lieven Clement. |
| Maintainer: | Lieven Clement <lieven.clement at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | beadarrayFilter results |
| Reference manual: | beadarrayFilter.pdf |
| Package source: | beadarrayFilter_1.1.0.tar.gz |
| Windows binaries: | r-devel: beadarrayFilter_1.1.0.zip, r-release: beadarrayFilter_1.1.0.zip, r-oldrel: beadarrayFilter_1.1.0.zip |
| OS X binaries: | r-release: beadarrayFilter_1.1.0.tgz, r-oldrel: not available |
| Old sources: | beadarrayFilter archive |
Please use the canonical form https://CRAN.R-project.org/package=beadarrayFilter to link to this page.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 2
Try this quick and easy recipe for homemade sweet and sour pork.
For the pork, place the roasted peanuts, a few pinches of ground pepper and the dried chillies into a food processor and pulse until coarsely ground. Transfer to a shallow bowl and set aside.
Place the pork steaks in between two sheets of cling film and, using a meat mallet or rolling pin, bash the pork steaks until halved in thickness. Roll the steaks in the soya bean mixture until well-coated, then pat lightly to secure the mixture to the meat, shaking off any excess.
Heat a wok until smoking and add the groundnut oil, then add the pork steaks and cook for 2-3 minutes on both sides, or until golden-brown and cooked through. Remove the steaks from the wok transfer to a warm plate to rest.
For the sweet and sour sauce, place all of the sauce ingredients into a food processor and blend to a smooth paste.
Pour the sweet and sour sauce into the wok used to cook the pork and leave to simmer for 1-2 minutes, or until the sauce has reduced to a thick consistency. Season, to taste, with light soy sauce, rice wine and ground white pepper.
To serve, pour the sauce over the pork and serve with rice and choi sum.


TSNavigationStripModel Class Reference
| Inherits from | NSObject |
| Conforms to | TSNavigationStripDataSource |
| Declared in | TSNavigationStripModel.h |
Tasks
-
leftItems
property -
rightItems
property -
sections
property -
navigationStrip
property -
useEdgeInsetsForSections
property -
customClassForSection
property -
– initWithNavigationStrip:
-
– setSections:
-
– setItems:fromLeft:
-
– insertNewSection:atIndex:animated:
-
– insertNewItem:atIndex:fromLeft:animated:
-
– removeSectionAtIndex:animated:
-
– removeItemAtIndex:fromLeft:animated:
Properties
customClassForSection
If not set then UIButton class is used. Specify if you want to provide specific draw implementation or additional functionalit for section view.
@property (nonatomic, strong) NSString *customClassForSection
Discussion
Warning: If you provide custom class it should inherit from UIButton. @def nil
Declared In
TSNavigationStripModel.h
leftItems
Menu items located on the left side of TSNavigationStripView.
@property (nonatomic, strong, readonly) NSArray *leftItems
Declared In
TSNavigationStripModel.h
navigationStrip
Instance of TSNavigationStripView which is managed by this data model.
@property (nonatomic, strong, readonly) TSNavigationStripView *navigationStrip
Declared In
TSNavigationStripModel.h
rightItems
Menu items located on the right side of TSNavigationStripView.
@property (nonatomic, strong, readonly) NSArray *rightItems
Declared In
TSNavigationStripModel.h
sections
Navigation sections.
@property (nonatomic, strong, readonly) NSArray *sections
Declared In
TSNavigationStripModel.h
useEdgeInsetsForSections
If YES edge insets are used for section’s content. Need for some UI layouts where graphics from one section should overlap sibling sections. @def NO
@property (nonatomic, assign) BOOL useEdgeInsetsForSections
Declared In
TSNavigationStripModel.h
Instance Methods
initWithNavigationStrip:
Initialize TSNavigationStripModel and provide instance of TSNavigationStripView which would display content of the data model.
- (id)initWithNavigationStrip:(TSNavigationStripView *)navigationStrip
Parameters
- navigationStrip
Instance of TSNavigationStripView.
Declared In
TSNavigationStripModel.h
insertNewItem:atIndex:fromLeft:animated:
Insert new menu item at specified position. TSNavigationStripView would be notified about changes in data model.
- (void)insertNewItem:(TSNavigationStripItem *)itemInfo atIndex:(NSInteger)index fromLeft:(BOOL)fromLeft animated:(BOOL)animated
Parameters
- itemInfo
Information about new menu item.
- index
Insert position.
- fromLeft
Specify on which side menu item should be inserted.
- animated
If YES item will be appear with animation.
Declared In
TSNavigationStripModel.h
insertNewSection:atIndex:animated:
Insert new section at specified position. TSNavigationStripView would be notified about changes in data model.
- (void)insertNewSection:(TSNavigationStripSection *)sectionInfo atIndex:(NSInteger)index animated:(BOOL)animated
Parameters
- sectionInfo
Information about new section.
- index
Insert position.
- animated
If YES section will be appear with animation.
Declared In
TSNavigationStripModel.h
removeItemAtIndex:fromLeft:animated:
Remove menu item at specified position. TSNavigationStripView would be notified about changes in data model.
- (void)removeItemAtIndex:(NSInteger)index fromLeft:(BOOL)fromLeft animated:(BOOL)animated
Parameters
- index
Remove position.
- fromLeft
Specify on which side menu item should be removed.
- animated
If YES item will be removed with animation.
Declared In
TSNavigationStripModel.h
removeSectionAtIndex:animated:
Remove section at specified position. TSNavigationStripView would be notified about changes in data model.
- (void)removeSectionAtIndex:(NSInteger)index animated:(BOOL)animated
Parameters
- index
Remove position.
- animated
If YES section will be removed with animation.
Declared In
TSNavigationStripModel.h
setItems:fromLeft:
Set menu items information. TSNavigationStripView would be notified about changes in data model.
- (void)setItems:(NSArray *)items fromLeft:(BOOL)fromLeft
Parameters
- items
Array of TSNavigationStripItem objects.
- fromLeft
Specify on which side menu items should be updated.
Declared In
TSNavigationStripModel.h
setSections:
Set sections information. TSNavigationStripView would be notified about changes in data model.
- (void)setSections:(NSArray *)sections
Parameters
- sections
Array of TSNavigationStripSection objects.
Declared In
TSNavigationStripModel.h


Incepted in 2000, GAMI Group has become the most trusted and reliable name in the real estate industry led by a dynamic persona, Mr.Ambalal Gami, the Company has accomplished the zenith of success in a mere span of 13 years. The group believes in creating a lifestyle the's aspirational, state-of-the-art, unique. That's why, every landmark built by us is not just to elevate your dreams but your life too.
One of the finest builders with on time delivery & assistance in getting your own home.


Selection and/or smoothing of ordinally scaled independent variables using a group lasso or generalized ridge penalty.
| Version: | 0.3-1 |
| Depends: | grplasso, mgcv, RLRsim, tcltk |
| Suggests: | IsoGene, Biobase |
| Published: | 2015-05-21 |
| Author: | Jan Gertheiss |
| Maintainer: | Jan Gertheiss <jgerthe at uni-goettingen.de> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | ordPens results |
| Reference manual: | ordPens.pdf |
| Package source: | ordPens_0.3-1.tar.gz |
| Windows binaries: | r-devel: ordPens_0.3-1.zip, r-release: ordPens_0.3-1.zip, r-oldrel: ordPens_0.3-1.zip |
| OS X binaries: | r-release: ordPens_0.3-1.tgz, r-oldrel: ordPens_0.3-1.tgz |
| Old sources: | ordPens archive |
Please use the canonical form https://CRAN.R-project.org/package=ordPens to link to this page.


Software Requirements
- To work on this lab on your own machine, you must be compatible with Vagrant, and Virtual Box.
- Shipped supports Mac OS X, Windows 7 or higher, and Ubuntu 13.04 or higher.
- Shipped supports any modern browser, but Chrome gives the best experience.
Hardware Requirements
- Total Memory: Minimum 4 GB, but 8 GB is better.
- Available Storage: Minimum 20 GB free, but 50 GB of Disk Storage free is better.


Working with exponents was a very easy topic for me. I worked with exponents before, and the process was very familiar.
Next, was my experience with log. It was a lot more challenging because it was my first time learning about this topic. After some practice and in depth explanations about it, I was able to grasp the concept in no time!
Overall, my experience with these two topics went very well. I was able to add two more math concepts to my skill set.
Back to Home


Brevis News
Shorten News. Read the most important parts of the news.
{% csrf_token %} {{form}}
Submit
Article
{{text|safe}}
Article Summary
{{text_summary}}


Online Status
Get Online Status
Exit
Online Status Controller
This block only appears in browser development mode.
Set online status to:
Online
Offline


Welcome to the Ders!
Home
About Me
Blogs
My Projects
Contact Me!
View some of my projects!!!
See my games
Ruby Cheat Sheet


{% extends 'base.html' %} {% block title %} Password Reset Complete {% endblock %} {% block body %}
Your password has been successfully reset.
You can now use your new password to log in.


--- title: The Orientation Distribution Function sidebar: documentation_sidebar permalink: ODFTheory.html folder: documentation toc: false ---
The orientation distribution function (ODF), sometimes also called orientation density function, is a function on the orientation space that associates to each orientation \(g\) the volume percentage of crystals in a polycrystaline specimen that are in this specific orientation. Formaly, this is often expressed by the formula
\[\mathrm{odf}(g) = \frac{1}{V} \frac{\mathrm{d}V(g)}{\mathrm{d}g}.\]
Let us demonstrate the concept of an ODF at the example of an Titanium alloy. Using EBSD crystal orientations \(g_j\) have been measured at a hexagonal grid \((x_j,y_j)\) on the surface of the specimen. We may visualize these orientations by plotting accordingly rotated crystal shapes at the positions \((x_j,y_j)\).
{% highlight matlab %} % import the data mtexdata titanium % define the habitus of titanium as a somple hexagonal prism cS = crystalShape.hex(ebsd.CS); % plot colored orientations plot(ebsd,ebsd.orientations,'micronbar','off') % and on top the orientations represented by rotated hexagonal prism hold on plot(reduce(ebsd,4),40*cS) hold off {% endhighlight %} {% highlight plaintext %} ebsd = EBSD Phase Orientations Mineral Color Symmetry Crystal reference frame 0 8100 (100%) Titanium (Alpha) LightSkyBlue 622 X||a, Y||b*, Z||c* Properties: ci, grainid, iq, sem_signal, x, y Scan unit : um {% endhighlight %}The idea of the orientation distribution function is to forget about the spatial coordinates \((x_j,y_j)\) and consider the orientations as points in the three dimensional orientation space.
{% highlight matlab %} plot(ebsd.orientations,'Euler') {% endhighlight %} {% highlight plaintext %} plot 2000 random orientations out of 8100 given orientations {% endhighlight %}As the orientation space is not an Euclidean one there is no canonical way of visualizing it. In the above figure orientations are represented by its three Euler angles \((\varphi_1, \Phi, \varphi_2)\). Other visualizations are discussed in the section 3D Plots. The orientation distribution function is now the relative frequency of the above points per volume element and can be computed by the command calcDensity
.
More detais about the computation of a density function from discrete measurements can be found in the section Density Estimation.
The resulting orientation distribution function odf
can be evaluated for any arbitrary orientation. Lets us e.g. consider the orientation
Then value of the ODF at this orientation is
{% highlight matlab %} odf.eval(ori) {% endhighlight %} {% highlight plaintext %} ans = 0.8166 {% endhighlight %}The resulting value needs to be interpreted as multiple of random distribution (mrd). This means for the specimen under investiagtion it is less likely to have an crystal with orientation (0,0,0) compared to a completely untextured specimen which has the orientation distribution function constant to \(1\).
Since, an ODF can be evaluated at any point in the orientation space we may visualize it as an contour plot in 3d
{% highlight matlab %} plot3d(odf,'Euler') hold on plot(ebsd.orientations,'Euler','MarkerEdgeColor','k') hold off {% endhighlight %} {% highlight plaintext %} plot 2000 random orientations out of 8100 given orientations {% endhighlight %}Three dimensional plot of an ODF in Euler angle space are for various reason not very recommendet. A geometrically much more reasonable representation are so called sigma sections.
{% highlight matlab %} plotSection(odf,'sigma') {% endhighlight %}


S.W.E.A.T.
Shower Wireless External Availability Tracker
First shower
loading...
Second shower
loading...


Calculator
Uint Converter
Weight Converter
Pounds
Grams
Kilograms
Ounces
Stones
Temperature Converter
Fahrenheit
Celsius
Kelvin
Length Converter
Feet
Yards
Meters
cm
Kilometers
Miles
Inches
Speed Converter
MPH
KPH
Knots
Mach


The Object of My Affection (1998)
a review by Christian Pyle
Playwright Wendy Wasserstein's first screenplay to be produced (based on a novel by Stephen McCauley) raises intriguing questions about love and the various forms in which it comes. At the center of a very amusing array of characters are roommates George (Paul Rudd) and Nina (Jennifer Aniston). George is gay and has just been dumped when he moves in with Nina. Nina is dating Vince (John Pankow of "Mad About You"), an overbearing socialist lawyer. George and Nina become close friends quickly, leading Nina to hope that they might become more than friends. When she becomes pregnant, Nina persuades George that they should raise the baby together.  "The Object of My Affection" is too smart a film to let Nina off so easy. She harbors a secret fantasy, of course, that George will "convert" for her, and she has to suffer through a series of disappointments before she sees how hopeless that fantasy is. The real charm of the movie is the parade of supporting characters that Wasserstein uses to broaden and complicate the questions she raises about love. These characters include George's conceited ex (Tim Daly of "Wings"), Nina's stepsister and her bigwig husband (Allison Janney, Alan Alda), George's new beau Paul (Amo Gulinello), Paul's lovesick mentor Rodney (Nigel Hawthorne), George's womanizing brother (Steve Zahn), and a nice cop who gives Nina a ride home (Kevin Carroll). All these folks are seeking love; a few are in love with themselves. The weak point in this movie is the acting of Jennifer Aniston. Since Nina's dreams and disappointments are the focus of "Object," Aniston has to carry more of the acting load than anyone else, and she is horribly inadequate. As far as Aniston is concerned, this might as well be an episode of "Friends" because there seems to be little difference between Nina and Rachel, Aniston's TV character. Aniston's inability to rise to the challenge sinks the movie and keeps a sharp script from achieving its full potential. There's still pleasure to be had, though, by watching the rest of the cast work. Rudd does a fine job of portraying the conflicted George, who wants to be a father to Nina's baby but cannot deny who he is to please her. Hawthorne also stands out; he gives a rich and subtle performance as a drama critic infatuated with Paul, who is young enough to be his grandson. (Bit of trivia: "Object" was directed by Nicholas Hytner, who also directed Hawthorne's breakthrough film, "The Madness of King George.") Pankow was surprisingly good; now that his TV series is retiring, I hope we'll see more of him on the big screen.
Grade: B-
© 1999 Christian L. Pyle
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


To analyze the value of this trading strategy, we compare its performance to buying-and-holding the S&P 500 index ETF, SPY. We can see the results from the table below. The strategy has a lower Sharpe ratio than the SPY for all of the time frames we tested, except for the downfall of the 2020 stock market crash. During this time it greatly outperformed the SPY, achieving a 10.4 Sharpe ratio. We also notice that the strategy generates more consistent returns than the benchmark, documented by the lower annual standard deviation of returns throughout all the testing periods.
| Period Name | Start Date | End Date | Strategy | Sharpe | ASD |
|---|---|---|---|---|---|
| Backtest | 1/1/2015 | 8/16/2020 | Strategy | 0.192 | 0.046 |
| Benchmark | 0.709 | 0.186 | |||
| Fall 2015 | 8/10/2015 | 10/10/2015 | Strategy | -1.448 | 0.052 |
| Benchmark | -0.724 | 0.251 | |||
| 2020 Crash | 2/19/2020 | 3/23/2020 | Strategy | 10.386 | 0.104 |
| Benchmark | -1.243 | 0.793 | |||
| 2020 Recovery | 3/23/2020 | 6/8/2020 | Strategy | -2.942 | 0.177 |
| Benchmark | 13.761 | 0.386 |
We find the lack of performance for this strategy is not largely attributed to the trading fees. After ignoring the transaction fees, spread costs, and slippage, the strategy still has a lower Sharpe ratio than the benchmark. See the backtest results here.


Navi
Home
Dashboard
Settings
Dashboard
{% for component in chain %}
{{ component.name }}
Show
0.0
0.0
{% endfor %}


What is SQL Injection?
SQL injection, while having been around for a long time, is still a very common vulnerability. In fact it was the #1 attack in 2010 and 2011. It occurs when commands are inserted into SQL where only data was expected. The injection is usually done on a login form.
When you sign up for a site, your information gets stored in various fields. When you login, the information you provide are queried against the site's database. If the information matches what is in the database, you are logged in.
However, what if the information you type in is something along the lines of "1=1," or you enter a comment demarcation to essentially disable a query parameter? The information in the field can include something like "DROP TABLE users," which would delete the table and screw everything to Hell.
So how do we go about preventing this? The answer is parameterized queries, and they look something like this:
"SELECT * FROM users WHERE email=? AND password=?", [user.email, user.password]
This tells the database that you will look up an email and its password, but you will pass the specific values later. The database then sets up a query plan, which is a set of steps to find the records.


{% extends "base.html" %} {% block content %}
Rapid Relay accepts data from multiple sources at a frequency of 500ms. The data is segregated into different containers based on the data types
The dataset is compressed with compression ratio of 5.1493 ie actual data is compressed by 83%
60 multithreaded bots were deployed to collect data from different sources and was live for six hours with ZERO packet loss
Compressed data was uploaded to cloud if there is internet connectivity.


Number of municipalities supported to develop, review and implement Operation and Maintenance Plans, including spending of minimum 7% of the OPEX budget
Providing support to develop O&M Plans and to ensure the minimum spending of 7% of the OPEX Budget
Improvement and sustainability of municipal infrastructure services delivery


BuilderTrend Projects
|
BuilderTrend Static Site Generation A customizable content management system for hosting homebuilder websites. Team: Christopher Eilenstine, Morgan Haworth, Jon Hermsen, Shannon Hire, Shihang Li |
Agora: BuilderTrend Meeting APIs Integration A meeting manager that enables integrating multiple videoconferencing APIs (Zoom, Webex, etc.) into a web platform. Team: Kaleb Ball, Jacob Hansen |
|
BuilderTrend Sticky Performance Headers A project to monitor website performance metrics via a sticky header bar superimposed on web applications. Team: Daniel Cook, Addison Gangwish, Connor Lynch |
BuilderTrend Construction Project Estimation A tool for entering customizable formulas for estimating costs of construction projects. Team: Conner Kennell, Joe Romsa, Joel Sare |
|
BuilderTrend Docusign API Integration A prototype for integrating Docusign e-signature features into a web platform. Team: Blake Bartenbach, Roger Marquiz, Hilario Mendez-Vallejo, Rene Ramirez-Garcia, Jacob Rush, Rayanna Shirley |
|
|
Coming soon! |
Prairie STEM Projects
|
Prairie STEM SimBot Version 2 A simulator for the STEMBoT robot, in Unity, with rudimentary Python programmability. Team: Mason Fleming, Jackson Henery, Cassie Miller |
Prairie STEM Augmented Reality for STEMBoTs A prototype that adds augmented reality capabilities for enhancing STEMBoT remote control experience. Team: Hans Espiritu, Matthew Kalahar, Joshua Roberts |
Games and Simulations
|
PKI VirtualTours A simulation that presents interactive virtual tours of PKI for virtual open houses. Team: Chad Knowlton, Sean May, Sam Miserez, Wesley Thompson, Nataliya Zhuromskaya |
Timekeeper: Rhythmic Auditory Cueing A gamified app for UNO Biomechanics to enable in-home rehabilitation through rhythmic auditory cueing therapy. Team: Ryan Narducci, Kyle Phipps, Alex Ramsey |
|
Putt-Ryte An app that aims to improve your golf game through video analysis of putting attempts. Team: Taylor Andrews, Kyle Coulter, Nico Mariniello, Sasha Price, Bryson Yumul |
AI Education for Ag An online game for learning about artificial intelligence (machine learning) in an agricultural context. Team: Tanner Beaulieu, Brian Hart, Tyler LaBreck, Matthew Malzacher |
Automation Tools
|
Mutual of Omaha File Parsing and Mapping Tool A tool for parsing files for benefits enrollment and generating Kafka messages for downstream processing. Team: Ben Jahnke, Adele Kanley, Devin Kellogg, Bailey Pinkelman |
UNO Aviation Flight Risk Assessment A tool to support student pilots in the Aviation program in assessing risky conditions during pre-flight preparations. Team: Kyle Hamana, Zac Hartzog, Makaila Reilly, Martin Simonini, Lee Yoder |
|
UNO Academic Assessment Import Tool An import tool that parses and extracts information from degree program assessment reports in Word documents for saving into a database. Team: Alex Hesselgesser, Zijun Mei, Trent Wisecup |
|


This is me
My name is Marcela Sena and I’m from Tepic Nayarit, México 🇲🇽
Software Engineer passionate about code, implement web and enterprise applications, share knowledge, learn new technologies, diversity.
I’m Co-founder of the TechWo community, speaker and Blog writer by choice.
I love music, movies, running/hike, read, and my dog 🐾
My Career
I’ve got a bachelors degree in Computer Systems Engineering specialized in “Distributed Systems” and I’ve been working as a Software Engineer since 2009. My experience has been focused in large Java systems as Web and Enterprise applications, and most of my time I’ve been working as a back-end developer by doing tickets, designing and implementing new features, scaling up, upgrading to new versions, applying security, communicating systems, refactorizing code to improve performance, handling concurrency in distributed envs, and improving the collaborative company’s culture by sharing knowledge for cross teams.
eBay
Staff Software Engineer / Sep 2021 - present
- SEO Tools
- Batch jobs
- Indexing APIs
- Web, REST APIs
- Java, Spring, Hadoop, Spark SQL
Senior Software Engineering - Contract / Dec 2020 – Sep 2021
- SEO Tools
- Batch jobs
- Indexing APIs
- Java, Spring, Hadoop, Spark SQL
Avenue Code
Consultant at Apple / Jun 2019 – Sep 2021
- Internal tools for asset management
- DMA (Digital asset management)
- Java 11, Spring boot, PostgreSQL, Python scripting
- Typescript, React
TOSHIBA Global Commerce Solutions, Inc
Software Engineer / Mar 2013 – Jun 2018
-
Remote Management System
- Inventory & Monitoring of POS (Point Of Sale) terminals from different customer stores on their different locations.
- I was leading a team for the development of a Data Collector component, which gathers data from different devices and publishes them into an Azure IoT Hub.
- Java, ActiveMQ, Python, Javascript, Bootstrap
- Azure: IoT Hub SDK, IoT Hub, Stream Analytics, Cosmos DB, Power BI
-
Web POS Application
- Development & maintenance of a web POS application
- Development & maintenance of a “POS Controller” framework for the different events and routes of the Web POS application.
- Development of the POS UI elements and widgets
- Javascript, dojo, Java, Spring, Camel, JMS, xml, json
- ActiveMQ
-
Middleware Solutions, Messaging Brokers
- Development & maintenance of a middleware solution to communicate the retail store applications with an external hosts
- Development of a Java API to embedded a Messaging broker supporting bidirectional broker-to-broker communication
- JMS, MQJMS, MQTT, JSE & JEE, Spring, Camel, slf4j, xml, xslt, xsd
- ActiveMQ, Moquette, Mosquito, WebSphereMQ, Micro Broker, KahaDB
A4Sys
Software Engineer / Jul 2010 - March 2013
-
Web Applications
- Development of new configuration and execution components for a web application used and administered by a bank to authorize credits.
- JSE & JEE, Spring MVC, JSTL, Apache Commons API, iText, Hibernate
- Fedora, Suse Enterprise, Ubuntu
- Tomcat, WebSphere, Glassfish
- jQuery, SiteMesh, HTML, CSS
- PL/SQL, SQL: Store Procedures, Jobs
- SQLDeveloper, SQLServer, pgAdmin
- Development of new configuration and execution components for a web application used and administered by a bank to authorize credits.
-
Web Services
- Development & Design of the Web Services for a “Credit Card Application”
- SOAP, SoapUI
- Development & Design of the Web Services for a “Credit Card Application”
Medisist
Java Engineer / Jul 2009 - Jul 2010
- Desktop Application
- Analysis, design and development of an accounting application under the Java platform (JSE), using design patterns, OO programming
- UML Modeling: Visual Paradigm, Visio
- Reports in CrystalReports
- DDL and DML in SQLServer using stored procedures, functions, views, triggers
- Analysis, design and development of an accounting application under the Java platform (JSE), using design patterns, OO programming
Communities
I’m a member of the TechWo {❤} & Technolatinas communities because I’m on my way to improve the women in tech path for future generations. I dreamed this for me and for the rest of the girls that now need to be brave for choosing this path, but that they won’t need to be brave in the future due to the efforts we’re doing today.
Tech Women Community
Organizer / Mar 2014 - present
- I am a Co-Founder of TechWo {❤} community to encourage women to choose STEM careers and keep them interested in programming
- I was the leader of the TechWo community during 2015-2016 where I was the focal point for other communities, partners and companies.
- I did organize different Tech Events: Meetups, Workshops, Anniversary.
- I was the co-creator and leader of a programming summer course for girls called “Pequeñas Programadoras” (Little programmers) (2016 and 2017) which taught girls how to program in Javascript for free.
- I was the co-creator and leader of a blog in Medium (TechWo Blog) that looks to group women with different skill set levels to write about programming in Spanish. So that we encourage Mexican Women to keep learning and become role models for other women. You can see my contributions here.
- I have been a speaker on different technology events talking about programming and diversity. You can see more about my talks in the following section “As Speaker”.
Technolatinas
Organizer / Sep 2020 - present
I’ve been part of this community for a while but I recently have a chance to actively partipate with the organization in some events:
- Día de la programadora
- I’ve helped to organize a Tech Panel about Prgramming Languages and their impact in the tech industry as I also participated as a Speaker in the panel representing the Java language.
- I did organize a Coding Dojo event by creating a Presentation to explain what a Coding Dojo is and a repo to contribute by adding the Solutions to the Katas.
Courses & Certifications
- M101J: MongoDB for Java Developers
- Java SE 8 Lambdas and Streams
- Oracle Certified Expert, Java EE 6 Web Services Developer
- Oracle Certified Expert, Java EE 6 Web Component Developer
- Oracle Certified Professional, Java SE 6 Programmer
As Speaker
- 2021
- Panel: Lenguajes y Frameworks de Programación en el mercado laboral (Technolatinas)
- Coding Dojo - Día de la programadora (Technolatinas)
- 2020
- Un plan de carrera con diversidad e inclusión (Tecnológico de Tepic)
- Hackaton Judge (Tecnológico de Tepic)
- 2019
- Desmitificando las entrevistas técnicas (TechWo)
- 2018
- Functional Programming in Scala (Toshiba GCS)
- Sé tu propio líder (Luxoft)
- Spark Framework Workshop (Talent Network)
- 2017
- MongoDB Workshop (Campus Party 8, Toshiba GCS)
- Actor Model with Akka (Campus Party 8, Toshiba GCS)
- MQTT & IoT in Cloud (Toshiba GCS)
- IoT - How to start? (TechWo Aniversary)
- 2016
- MQTT for IoT & Mobile demo (UNIVA IoT Fest)
- Member of the Judge for the Highschool girls (TechnovationChallengeMx)
- Java Web Technologies (Campus Party 7, Toshiba GCS)
- Hugo Framework (Campus Party 7)
- 2015
- Las Internetas - Presentation of the CoC (Campus Party 6)
- The role of women in IT through TWC (DIVEC Fest - CUCEI, Campus Party 6)
- Spring MVC Workshop (Toshiba GCS - Tech Submit)
- Google I/O 2015 Experience (TechWo)
- 2014
- Spring - MVC Moduel & Project 101 (JavaGDL Community)
- Strings, I/O, Formatting, and Parsing - Chapter for a OCJP course (Toshiba GCS)
- 2013
- Java Security Topics (JavaGDL Community)
Interests
I’m interested in … (learning some of them)
- JS frameworks: React.js, AngualarJS
- Programming languages: Scala, go, python, JS using Node.js
- NoSQL-DB: MongoDB, DynamoDB
- Analitics: Kafka, Spark, Hadoop
- IoT
- Reactive Systems
- Test Driven Development
- Microservices
- Functional Programming
- Cloud Computing
- Docker
Check out my GitHub


Bespoke Luxury Stationery
At Bigday we pride ourselves on our continually evolving, innovative portfolio of luxury invitations, event & business stationery. We are constantly creating new designs and striving for exciting ways to create perfection. Whether it’s a new creation or working with your theme, our aim is to bring your ideas to life. Incredibly lavish to low key, outrageous or traditional - Bigday has something to suit all tastes. Our in-house printing and design service ensures we can produce a bespoke, high quality product while maintaining control throughout the process.
Our twenty years experience has given us the expertise to amalgamate both modern and traditional printing techniques. Foiling, embossing, raised print, calligraphy and wax seals together with laser cutting/engraving, digital print and Perspex fabrication.
Our excellent customer service ethos ensures that Bigday’s Production Team work on a one-to-one basis with our clients to create a fabulous, bespoke, luxury product.
Just contact Bigday to organise a visit to our Radlett showroom or if you’re based too far from there, we will come and see you.
Phone: 01442 828100
Email: info@bigdaydesigns.co.uk


Mix Of The Day: Bufiman
A live set from the Düsseldorf mainstay, recorded for Fault Radio at San Francisco's Vinyl Dreams record shop.
by Resident AdvisorBufiman (AKA Jan Schulte) came through with an hour-plus mix of psyched-out downtempo jams at the Haight Street. His debut album, Albumsi, drops Monday via Dekmantel.


{% extends "all-posts/base.html" %} {% load bootstrap4 %} {% load static %} {% block content %}
owned by :{{business.name}}
by {{business.email}}


Delivered key contribution to the knowledge graph group. Conducted research in the areas of knowledge graph and linked data with applications in biomedical data with strong emphasis on cancer prediction. Successfully implemented various modules for the prediction of molecular biomarkers using state of the art machine learning and data science libraries. Conveniently worked with huge biomedical, text and graph datasets. Established a robust system to make use of complex n-arty hyper-graphs in machine learning and statistical inference methods. Collaborated with multi-disciplined team of researchers and developers.
Languages: Python
Libraries: Tensorflow, Scikit-learn, Pandas, Numpy, Scipy, Gensim, Nltk, Scrapy, Matplotlib, plotly, biopython, networkx, requests, beautifulsoup, Ipython Others: Git, Sphix, Vagrant
Worked as backend web developer to develop telehealth product. Collaborated with multi-disciplined team of backend, frontend, qa, product definition and UX designers in planning, designing, development and testing. Helped the clients by successfully handling the deployments and bug resolutions on live product server. Achieved employee of the month award twice.
Programming: Java (Play framework), C#.Net MVC
Databases: SQL, MySQL
Others: Git, AmazonS3
Awards: Achiever of the month
Formulated & developed a statistical inference system to robustly embed posterior probabilities. Successfully experimented & verified the proposed algorithm on multiple images and text datasets.
Published the work in ICMLA 2016.
Programming: MATLAB, Python
Developed simulation softwares for research & training purposes of PAF using C, C++, C#, DirectX & SQL. Most of projects showcased at different international level exhibitions.
Taught Database management systems course to undergraduate students
1st in a batch of 40 - Gold Medalist
Thesis:Robust Kernel Bayes’ Rule & Applications”;
A non-parametric robust Bayesian inference model to find conditional & posterior probabilities and its validation on ‘Zero-Shot classification’ using deep learning & word embedding’s”
Major Subjects:Artificial Intelligence & Machine Learning, Information Retrieval, Data mining and Advanced Algorithms Analysis
1st in a class of 60 - Gold Medlaist
Graduation Project:“Autonomous Artificial Intelligence Robot”;
A robot capable of finding efficient path in dynamic maze with manifold obstacles
Major Subjects: Artificial Intelligence, OOP, Robotics, Algorithms
Major Subjects:Artificial Intelligence, OOP, Robotics, Algorithms
(Under Process)
Distinction in batch
Distinction in batch
An outdoor activity trianing organised by Youth Impact for 100+ university students where multiple teams competed with each other and the team I led my team to won the award
A mobile app devlopment competition to develop something unique in 72 hours


We're sorry but newtest doesn't work properly without JavaScript enabled. Please enable it to continue


public class Configuration
Represents the parameters that can be set for the an LGP environment.
An implementation of interface ConfigurationLoader
can load class Configuration
s from a specified source.
interface ConfigurationLoader
,
class Configuration
| Constructor and Description |
|---|
Configuration()
Represents the parameters that can be set for the an LGP environment.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
equals(java.lang.Object other) |
double |
getBranchInitialisationRate()
How often branches should be included in evolved programs.
|
java.util.List<java.lang.String> |
getConstants()
Any values to be used as constants in an LGP program.
|
double |
getConstantsRate()
The probability with which instructions in an LGP program will contain a constant value.
|
double |
getCrossoverRate()
The frequency with which crossover should occur.
|
int |
getGenerations()
Number of generations to evolve.
|
int |
getInitialMaximumProgramLength()
The maximum length of a program generated during population initialisation.
|
int |
getInitialMinimumProgramLength()
The minimum length of a program generated during population initialisation.
|
double |
getMacroMutationRate()
The frequency with which macro-mutations should occur.
|
int |
getMaximumProgramLength()
The upper bound for program length during the evolution process.
|
double |
getMicroMutationRate()
The frequency with which micro-mutations should occur.
|
int |
getMinimumProgramLength()
The lower bound for program length during the evolution process.
|
int |
getNumCalculationRegisters()
How many additional calculation registers should be provided to an LGP program.
|
int |
getNumFeatures()
The number of features in the data set (i.e. the number of input registers that should be made available).
|
int |
getNumOffspring()
Number of individuals that should be taken from the population in each generation.
|
int |
getNumberOfRuns()
Provides the ability to pass in the number of runs as a configuration parameter
instead of a hard-coded value in the problem definition.
|
java.util.List<java.lang.String> |
getOperations()
A collection of fully-qualified class names specifying the classes of
lgp.core.program.instructions.Operations to be loaded into an lgp.core.environment.Environment.
|
int |
getPopulationSize()
How many individuals should be generated in the initial population.
|
double |
getStoppingCriterion()
Determines the threshold for stopping the evolutionary process.
|
ConfigurationValidity |
isValid() |
void |
setBranchInitialisationRate(double p)
How often branches should be included in evolved programs.
|
void |
setConstants(java.util.List<java.lang.String> p)
Any values to be used as constants in an LGP program.
|
void |
setConstantsRate(double p)
The probability with which instructions in an LGP program will contain a constant value.
|
void |
setCrossoverRate(double p)
The frequency with which crossover should occur.
|
void |
setGenerations(int p)
Number of generations to evolve.
|
void |
setInitialMaximumProgramLength(int p)
The maximum length of a program generated during population initialisation.
|
void |
setInitialMinimumProgramLength(int p)
The minimum length of a program generated during population initialisation.
|
void |
setMacroMutationRate(double p)
The frequency with which macro-mutations should occur.
|
void |
setMaximumProgramLength(int p)
The upper bound for program length during the evolution process.
|
void |
setMicroMutationRate(double p)
The frequency with which micro-mutations should occur.
|
void |
setMinimumProgramLength(int p)
The lower bound for program length during the evolution process.
|
void |
setNumCalculationRegisters(int p)
How many additional calculation registers should be provided to an LGP program.
|
void |
setNumFeatures(int p)
The number of features in the data set (i.e. the number of input registers that should be made available).
|
void |
setNumOffspring(int p)
Number of individuals that should be taken from the population in each generation.
|
void |
setNumberOfRuns(int p)
Provides the ability to pass in the number of runs as a configuration parameter
instead of a hard-coded value in the problem definition.
|
void |
setOperations(java.util.List<java.lang.String> p)
A collection of fully-qualified class names specifying the classes of
lgp.core.program.instructions.Operations to be loaded into an lgp.core.environment.Environment.
|
void |
setPopulationSize(int p)
How many individuals should be generated in the initial population.
|
void |
setStoppingCriterion(double p)
Determines the threshold for stopping the evolutionary process.
|
java.lang.String |
toString() |
public Configuration()
Represents the parameters that can be set for the an LGP environment.
An implementation of interface ConfigurationLoader
can load class Configuration
s from a specified source.
interface ConfigurationLoader
,
class Configuration
public int getInitialMinimumProgramLength()
The minimum length of a program generated during population initialisation.
public void setInitialMinimumProgramLength(int p)
The minimum length of a program generated during population initialisation.
public int getInitialMaximumProgramLength()
The maximum length of a program generated during population initialisation.
public void setInitialMaximumProgramLength(int p)
The maximum length of a program generated during population initialisation.
public int getMinimumProgramLength()
The lower bound for program length during the evolution process.
public void setMinimumProgramLength(int p)
The lower bound for program length during the evolution process.
public int getMaximumProgramLength()
The upper bound for program length during the evolution process.
public void setMaximumProgramLength(int p)
The upper bound for program length during the evolution process.
@NotNull public java.util.List<java.lang.String> getOperations()
A collection of fully-qualified class names specifying the classes of lgp.core.program.instructions.Operations to be loaded into an lgp.core.environment.Environment.
NOTE: Custom loaders can be provided that can provided a collection of lgp.core.program.instructions.Operations in some custom way, by implementing the lgp.core.environment.operations.OperationLoader interface.
public void setOperations(@NotNull java.util.List<java.lang.String> p)
A collection of fully-qualified class names specifying the classes of lgp.core.program.instructions.Operations to be loaded into an lgp.core.environment.Environment.
NOTE: Custom loaders can be provided that can provided a collection of lgp.core.program.instructions.Operations in some custom way, by implementing the lgp.core.environment.operations.OperationLoader interface.
public double getConstantsRate()
The probability with which instructions in an LGP program will contain a constant value.
public void setConstantsRate(double p)
The probability with which instructions in an LGP program will contain a constant value.
@NotNull public java.util.List<java.lang.String> getConstants()
Any values to be used as constants in an LGP program.
NOTE: Constants are specified as string values to permit the use of custom register types. This means that a custom lgp.core.environment.constants.ConstantLoader will need to be implemented to load the list of strings into an appropriate type suitable to be loaded into a register set.
public void setConstants(@NotNull java.util.List<java.lang.String> p)
Any values to be used as constants in an LGP program.
NOTE: Constants are specified as string values to permit the use of custom register types. This means that a custom lgp.core.environment.constants.ConstantLoader will need to be implemented to load the list of strings into an appropriate type suitable to be loaded into a register set.
public int getNumCalculationRegisters()
How many additional calculation registers should be provided to an LGP program.
public void setNumCalculationRegisters(int p)
How many additional calculation registers should be provided to an LGP program.
public int getPopulationSize()
How many individuals should be generated in the initial population.
public void setPopulationSize(int p)
How many individuals should be generated in the initial population.
public int getNumFeatures()
The number of features in the data set (i.e. the number of input registers that should be made available).
public void setNumFeatures(int p)
The number of features in the data set (i.e. the number of input registers that should be made available).
public double getCrossoverRate()
The frequency with which crossover should occur.
public void setCrossoverRate(double p)
The frequency with which crossover should occur.
public double getMicroMutationRate()
The frequency with which micro-mutations should occur.
public void setMicroMutationRate(double p)
The frequency with which micro-mutations should occur.
public double getMacroMutationRate()
The frequency with which macro-mutations should occur.
public void setMacroMutationRate(double p)
The frequency with which macro-mutations should occur.
public int getGenerations()
Number of generations to evolve.
public void setGenerations(int p)
Number of generations to evolve.
public int getNumOffspring()
Number of individuals that should be taken from the population in each generation.
public void setNumOffspring(int p)
Number of individuals that should be taken from the population in each generation.
public double getBranchInitialisationRate()
How often branches should be included in evolved programs.
public void setBranchInitialisationRate(double p)
How often branches should be included in evolved programs.
public double getStoppingCriterion()
Determines the threshold for stopping the evolutionary process.
When a solution with a fitness of stoppingCriterion
is found, the search will stop.
By default, we don't stop until the fitness is minimised perfectly.
stoppingCriterion
public void setStoppingCriterion(double p)
Determines the threshold for stopping the evolutionary process.
When a solution with a fitness of stoppingCriterion
is found, the search will stop.
By default, we don't stop until the fitness is minimised perfectly.
stoppingCriterion
public int getNumberOfRuns()
Provides the ability to pass in the number of runs as a configuration parameter instead of a hard-coded value in the problem definition.
The parameter is not used by default anywhere in the system, but consumers can choose to use it.
public void setNumberOfRuns(int p)
Provides the ability to pass in the number of runs as a configuration parameter instead of a hard-coded value in the problem definition.
The parameter is not used by default anywhere in the system, but consumers can choose to use it.
@NotNull public ConfigurationValidity isValid()
public boolean equals(@Nullable java.lang.Object other)
@NotNull public java.lang.String toString()


Title
[Administration]
Service owner
service description
Generate your API key
you subscribed
click here to check api key
No items yet
Javascript Libraries
Javascript Libraries


Passengers
Name
Embarked
Passenger Class
Search
Passenger ID
Passenger Name
Links (View Edit Delete)
Doc
Doc
View
Edit
Delete
Add New


Anxiety
Defintion: A feeling of worry, nervousness, or unease, typically about an imminent event or something with an uncertain outcome.
Breathe. Inhale like you're sipping through a straw. Exhale through your teeth making a "tssss" sound. Gain control over your anxiety. You can do it.


Vim 7.3 on Windows -- Installed Successfully But Crashes When Opening A File
-
Jonah
I am on win7 with vim 7.3. I installed rubyinstaller-1.9.1-p430 and DevKit-4.5.0-20100819-1536-sfx, so that (I think) the version of ruby vim came compiled with matches the one I used to execute
ruby extconf.rb
.Here is the output of the make command:
gcc -I. -IC:/Ruby191/include/ruby-1.9.1/i386-mingw32 -I/C/Ruby191/include/ruby-1 .9.1/ruby/backward -I/C/Ruby191/include/ruby-1.9.1 -I. -DHAVE_RUBY_H -O2 -g - Wall -Wno-parentheses -std=c99 -Wall -Wextra -Wno-unused-parameter -o ext.o -c ext.c gcc -I. -IC:/Ruby191/include/ruby-1.9.1/i386-mingw32 -I/C/Ruby191/include/ruby-1 .9.1/ruby/backward -I/C/Ruby191/include/ruby-1.9.1 -I. -DHAVE_RUBY_H -O2 -g - Wall -Wno-parentheses -std=c99 -Wall -Wextra -Wno-unused-parameter -o match.o -c match.c gcc -I. -IC:/Ruby191/include/ruby-1.9.1/i386-mingw32 -I/C/Ruby191/include/ruby-1 .9.1/ruby/backward -I/C/Ruby191/include/ruby-1.9.1 -I. -DHAVE_RUBY_H -O2 -g - Wall -Wno-parentheses -std=c99 -Wall -Wextra -Wno-unused-parameter -o matcher. o -c matcher.c gcc -shared -s -o ext.so ext.o match.o matcher.o -L. -LC:/Ruby191/lib -L. -Wl,- -enable-auto-image-base,--enable-auto-import -lmsvcrt-ruby191 -lshell32 -lws2 _32
At first I was happy because it seemed to be working: http://i.imgur.com/hxQ4S.png
But then I was sad because as soon as I selected a file by pressing enter, vim crashed: http://i.imgur.com/sft8b.png
Any ideas for troubleshooting?
Reply
This topic is now closed.


{% extends "base.html" %} {% block content %}
Drag and Drop From Your Device!
Or upload from your social media
{% endblock %}
Or upload from your social media


Services
Selected professional activities
Professional Affiliation
- IEEE Senior Member, 2019 – present
- ACM Member, 2019 – present
- AIS Member, 2021 – present
- INFORMS Member, 2021 – present
Grant Proposal Reviewer
- Panelist, National Science Foundation, 2017 – 2021
- External Reviewer, Hong Kong Research Grants Council, 2017 – 2021
- Reviewer, Kentucky Science & Engineering Foundation, 2016
Journal Editorship
- Editor, IEEE Transactions on Vehicular Technology, 2018 – present
- Guest Editor, Special Issue on Information Centric Wireless Networking with Edge Computing for 5G and IoT, IEEE Access, 2018
Conference Organization Committee
- Track Co-Chair, 19th Annual International Conference on Privacy, Security and Trust (PST2022), Privacy Track, 2022
- Track Co-Chair, IEEE 94th Vehicular Technology Conference (VTC2021-Fall), Spectrum Management, Radio Access Technology, Services and Security, 2021
Technical Committee Member
- IEEE International Conference on Computer Communications (INFOCOM), 2016 – 2023
- The 1st International Workshop on Cybersecurity and Social Sciences (CySSS), 2022
- International Joint Conference on Artificial Intelligence (IJCAI), 2020
- ACM International Conference on Future Energy Systems (e-Energy), 2017 – 2019
- IEEE Conference on Communications and Network Security (CNS), 2017 – 2019
- IEEE International Conference on Distributed Computing Systems (ICDCS), 2017
- IEEE International Conference on Smart Grid Communications (SmartGridComm), 2015 – 2018
- IEEE ComSoc International Communications Quality and Reliability Workshop (CQR), 2017
- IEEE International Conference on Computer Communication and Networks (ICCCN), 2016
- IEEE International Conference on Communications (ICC), 2015 – 2017
- IEEE Global Communications Conference (GLOBECOM), 2014 – 2016
- International Conference on Networking and Network Applications (NaNa), 2016
- IEEE International Conference on Computer and Information Technology (CIT), 2015
- IEEE International Symposium on Wireless Vehicular Communications (WiVec), 2014
Journal Reviewer
- IEEE Transactions on Information Forensics and Security
- ACM Transactions on Cyber-Physical Systems
- ACM Computing Surveys
- IEEE Transactions on Wireless Communications
- IEEE Transactions on Computers
- IEEE Transactions on Big Data
- IEEE Transactions on Cloud Computing
- IEEE Transactions on Mobile Computing
- IEEE Transactions on Parallel and Distributed Systems
- IEEE Transactions on Emerging Topics in Computing
- IEEE/ACM Transactions on Networking
- IEEE Journal on Selected Areas in Communications
- IEEE Transactions on Vehicular Technology
- IEEE Transactions on Smart Grid
- IEEE Transactions on Power Systems
- IEEE Transactions on Sustainable Energy
- IEEE Transactions on Industrial Informatics
- IEEE Internet of Things Journal
- IEEE Transactions on Emerging Topics in Computational Intelligence
- IEEE Networks
- IEEE Wireless Communications
- IEEE Communications
- IEEE Signal Processing Letters
- IEEE Access
- Computer Networks
- Applied Energy


In this short tutorial we’ll look at how to get Node running on your Raspberry PI, run it in the background and automatically have it start when the PI reboots.
First things first fire up a terminal or SSH into your PI and download the latest node tarball.
At the time of this writing that is v0.8.19 but of course substitute that with whatever version you choose.
$ wget http://nodejs.org/dist/v0.8.19/node-v0.8.19.tar.gz $ tar xvzf node-v0.8.19.tar.gz $ cd node-v0.8.19 |
Next you’re ready to build Node from source.
On my Model B w/ 512MB of RAM this took about an hour and a half.
$ ./configure && make && sudo make install |
If everything went ok you should now have node and npm installed on your PI.
$ node --version v0.8.19 $ npm --version 1.2.2 |
Cool, now let’s run a simple test app.
Create a new file and call it hello-node.js and paste the following into it:
// Load the http module to create an http server. var http = require('http'); // Configure our HTTP server to respond with Hello World to all requests. var server = http.createServer(function (request, response) { response.writeHead(200, {"Content-Type": "text/plain"}); response.end("Hello World\n"); }); // Listen on port 8000, IP defaults to <IP_ADDRESS> server.listen(8000); |
Now start the server –
$ node ./hello.node.js |
and navigate a browser to localhost:8000 and you should see “hello world” print to the screen.
Hurrah it works!
Ok, now let’s setup a daemon to run our node server outside of our shell and automatically have it start whenever the PI reboots.
First cd into /etc/init.d/ and create a new file called node-server.sh
$ cd /etc/init.d $ sudo nano node-server.sh |
Next copy the following into it:
Note to change the path_to_node_app variable to wherever your app lives.
#! /bin/sh # /etc/init.d/node-server ### BEGIN INIT INFO # Provides: node-server # Required-Start: $remote_fs $syslog # Required-Stop: $remote_fs $syslog # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 ### END INIT INFO # change this to wherever your node app lives # path_to_node_app=/var/node/hello-node.js # Carry out specific functions when asked to by the system case "$1" in start) echo "* starting node-server * " echo "* starting node-server * [`date`]" >> /var/log/node-server.log /usr/local/bin/node $path_to_node_app >> /var/log/node-server.log 2>&1& ;; stop) echo "* stopping node-server * " echo "* stopping node-server * [`date`]" >> /var/log/node-server.log killall /usr/local/bin/node ;; *) echo "Usage: /etc/init.d/node-server {start|stop}" exit 1 ;; esac exit 0 |
Next we need to make this file executable via :
$ chmod 755 ./node-server.sh |
Now let’s tell the PI to execute this script and start the server on reboot:
$ update-rc.d node-server.sh defaults |
If we ever want to disable this just type :
$ update-rc.d -f node-server.sh remove |
And lastly you can now start and stop your node server in the background anytime via :
# start-server # sudo /etc/init.d/node-server.sh start # stop-server # sudo /etc/init.d/node-server.sh stop |
I personally added aliases to these two commands in my ~/.bashrc
# start / stop node server in background # alias nodestart='sudo /etc/init.d/node-server.sh start' alias nodestop='sudo /etc/init.d/node-server.sh stop' alias nodetail='tail -n100 /var/log/node-server.log' |
So I can start / stop the server and view the log file simply by typing the following :
$ nodestart $ nodestop $ nodelog |
And that’s about it. Any problems or questions feel free to post in the comments below.


|
Shalom and welcome to Chavah! Now that you're signed in, here are some fun things you can do: Thumb-up songs you likeYou can 👍 songs you like (and 👎 those you don't!) Chavah learns what you like and plays more of the good stuff. Thumbing-up a song increases its ranking, and songs with higher ranking are played more often for everyone. Read more... Do a song request
Got a song you like? 😎 Request a song and it'll play for you and everyone listening. It'll play instantly for you, and everyone else when their current song finishes. Share your favorite songs on FacebookFound great song that you want your friends to hear? 😍 Share the song to Facebook, Twitter, WhatsApp, and more. You can also share the song in a text message from your phone.  Spread Messiah's music around! 🙌 Read more... Get the appChavah is in the app store! If you're on a mobile device, grab the Chavah app for the best experience:
Thanks!This just scratches the surface of some fun things you can do with Chavah. If you're really digging Chavah, you can also:
We genuinely hope you enjoy Messiah's music. Thanks for listening, fine Chavah fans!
|


{% extends 'shared/base.html' %} {% block content %}
Are you sure you want to permanently delete "{{ object.title }}" recipe?


Begin the Fugue, Part II
Vocationtional Vicissitudes
After existing in this bootcamp space for the past few months, I feel like I am walking away with a very fresh take on what it means to teach in a vocational, rather than a liberal arts setting. When the goal of the teaching is unabashedly “be useful in a neoliberal vocation” context, there’s a lot less theory (of course something I personally wasn’t the biggest fan of for hopefully obvious reasons) and much more honesty about what this specific type of student wanted out of their education: new opportunities for employment.
I want to be very clear that I do not think that this approach should be the default goal of education (even though that is the new constant pressure), but now having experienced living in this bizarro world where success is defined solely by employment I now have a lot more opinions about the “value/values” demarcation in education. In many ways, I very much agree with many goals of Flatiron in that there is a huge hole in the way things are set up now for vocational job training that doesn’t fit the traditional guild/apprentice model (electrician, plumber) and there should be more opportunities for people to accomplish this if they want.
This is especially true if it will lead to a marked difference in quality of life when it comes to their income. This absurdly large differences in income has been benefiting people (white dudes) in tech for a long time, and opening it up to others via education is imporant. It makes me very happy to have worked for a company that has made this a priority and has allocated scholarship money for those that are underrepresented in tech and to have been able to pass on those opportunities to people I know personally.
Of course the idealist in me would go so far as to try to steer the next part of this conversation away from idea of social mobility (why don’t we just pay people all more than living wages and avoid classist ideas that value white collar above blue collar work) but the realist in me knows that this structure is entrenched in Western society right now so if there is a way to open the door to making more money and better quality of life for people through work, then people who can open that door need to open it as wide as humanly possible.
Emulating Ideas from Vocational Education
Reflecting on the vocational versus liberal arts really has me thinking about that and what the future of what higher education could be. Many of my academic colleagues know the pressure of being asked to demonstrate “transferable skills” in their curricula. I literally was praised today for including a line in a course I plan on teaching this Winter for explicitly saying I will talk about career paths within music psychology. Students rightly want to be able to make a living for themselves when they graduate.
But if we just follow the job market and placements as our only metric for success, I feel as though we really betray the entire goal of education. If you do think that, you need to get yourself a copy of David Graeber’s Bullshit Jobs immedietly. Now I don’t want to fall prey to Rule Number 2 of grad school (“Be on the lookout for false dichotomies”) thinking we can’t have both, but as more pressure is put on higher education to use employment as a KPI (a new term I learned this year) there is a lot higher ed can and should take from the vocational/bootcamp model. If so much can be accomplished in so little time that can lead to better chances at employment, I am sure there is time during a four year undergraduate degree to equip them with what they need for employment (if they want to do this) that is not just a few resume review sessions.
I know this might not be as big of a deal for some of my STEM colleagues or students, but I do think about what this would look like if there was some sort of vocational option for music students (my home field). The irony is also not lost on me that when I talk about music students, I understand the historical links to a music conservatory, which again is all about going on to “work” as a professional musician (having lived that life myself). But the reality that every one of my conservatory friends found post-graduation is that it is really, really hard to have a “normal life” as a performing musician. You can gig a lot and do a fair bit of teaching, but you often find that many of your colleagues are bank rolled by their wealthy spouses or parents. And on top of that, the hours don’t align with the “working day” (which I know not everyone wants anyway).
If you do this, you can be in the position to make a living, but it’s not exactly normal. I know things are a bit different for Music Ed, but I’m more thinking about the many jobs that people with really fantastic music educations could do, but either don’t know exist or have zero job preparation to get themselves that role. For example, the graduate student in musicology who has their finger on the pulse of the fantastic ideas going around academic circles, but would never have anything in their curricula about putting theory into practice at something like an arts organisation, let alone the connection from a professor to put them in touch with the person to get them employed.
I could easily imagine what a summer intensive might look like for music students (especially grad students) looking to pick up the skills they would need to go alt. I am sure there are tons of major orchestras or larger arts organizations that would benefit tremendously from music students who are like what I just described, but lack the mental model as to what power tools they need to be effective. Just learning basic data literacy, enough programming to wrangle data and make convincing visualizations for the board, and tools for thinking to not make rookie inferential mistakes could all be learned in a setting like this. Of course how I am thinking about it takes much more of a quant focus than what would traditionally be offered in a music school setting, but that’s kind of the point in that you’d be able to do both. I can’t emphasize enough how much computer and research/data literacy (not even mastery) can add value to your organization when you couple it with the pre-existing expertise you have of your domain.
I am sure a small group of students who just wanted to learn these in-demand vocational skills over the summer or an alt-semester, they’d be ripe and ready by the end of it to go on and help arts organizations or work somewhere else. Maybe even set it up to lead to internships or something? The new skill set would give them comfort in knowing all their eggs are not in the one basket that is music performance or the “academic job market” while not losing the culture of total immersion in music. Just a little bizarro world like the one I have been living in for the past year for them to enter for a few months to give them something different.1
Of course I don’t know who is going to pay for that or if students would be interested, but it’s got my mind ticking after seeing what can be done in three months when you just stare into vocationalism.
The whole experience teaching in this context thing really felt like if you’ve had the chance to learn a second language (non-natively) like being a white kid learning Spanish in secondary school and even though you’re learning Spanish, you’re also learning more about English because you had no idea what you took for granted about your own language. I will definitely be re-doing many parts of my teaching statement after the past nine months here.
I won’t be able to implement these zany ideas anytime soon, but I did want to put them out there now since I think this push for vocational skills within the liberal arts will only become stronger as funding continues to drop for higher education and students withdraw from enrolling until they can go back on campus.
I’ll just end this section again here with repeating that I do not think that this emphasis on jobs should be the new standard for higher ed, but rather stealing ideas from the bootcamp model, annexing it as something separate for students who are interested, and then actually pulling this idea that liberal arts degrees need to be about employability out of the curricula so we can focus on deeper issues than just getting jobs.
Now knowing I won’t be doing this next, what might I be?
This takes me to Part III of this series of me having a lot of time to think the past month, but no ability whatsoever to concentrate on my professional research.
I can already hear the response of “There is no room for this in the curricula! We barely can let go of Set Theory!” Maybe one day it can be a fun Twitter conversation.↩


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
A healthy and filling dish with lots of delicious veggies and plenty of protein to keep you feeling full.
For this recipe you will need a food processor and a griddle pan.
For the ginger sauce, heat 2 tablespoons of oil in a frying pan. Fry the cumin seeds over a low heat for 1-2 minutes then add the sesame seeds, ginger, green chilli and chilli powder. Season with a little salt. Stir fry for 2-3 minutes and then cover the mixture with a circle of greaseproof paper and let it cook very gently for 40-45 minutes.
Let the mixture cool then transfer to a food processor and blend to a fine paste with the tamarind paste and palm sugar.
Heat the remaining oil in a separate pan, add the asafoetida, red chilli and mustard seeds. As the mustard seeds pop, add the curry leaves, stir for 30 seconds then pour into the ginger chutney mixture and mix well. Set aside.
For the quinoa salad, heat a large griddle pan. Put the oil in a large bowl and add all the vegetables and lemon. Mix to combine and season with salt and pepper. Place onto the griddle pan and cook for 3-4 minutes on each side or until char marks appear.
Cook the quinoa according to the packet instructions and place in a large bowl. Mix in the charred vegetables, sultanas, tomatoes and herbs. Season with salt and pepper and squeeze over some of the juice from the lemon wedges.
For the salmon, heat a large frying pan and add the oil. Once hot, add the salmon skin-side down. Cook for 2-3 minutes then turn over and cook for a further 4-5 minutes.
To serve, dress the plates with the ginger sauce and dot round the salad. Place the salmon on top.